【python基础语法】函数的作用域和内置函数和关键字（第7天课堂笔记）

一、函数的作用域：

1、全局变量

2、局部变量

3、global

二、内置函数

1、常见的内置函数

print : 输出

input : 输入

type : 查看数据类型

id : 获取数据的内存地址

range : 生成数据

len : 获取数据的长度(元素总数)

int、float 、bool 、str、list、tuple、dict、set：代表对应的数据类型

最大值 最小值的内置函数

min:求最小值

max:求最大值

sum:求和

2、python中高级内置函数

2.1、 enmerate

返回一个可以枚举的对象，enmerate将其组成一个索引序列，利用它可以同时获得索引和值

2.2 、eval:

取出字符串中的内容

将字符串str当成有效的表达式来求值，并返回计算结果

2.3 、filter:过滤器

filter:(参数1、参数2)

参数1：过滤规则的函数

参数2：要过滤的数据

2.4、zip:聚合打包

"""
函数的参数：
拆包
函数中可以传入参数，那么我们在传入参数的时候可不可以传入列表和字典来当做参数？

一、函数的作用域：
1、函数的作用域:在函数内部中定义的变量，只有在该函数中才能够使用
2、局部变量：定义在函数内部的变量叫做局部变量
3、全局变量：直接定义在文件中的变量，叫做全局变量，在该文件任何地方都能够访问
4、global关键字：将函数内部的局部变量转换为全局变量

二、内置函数
1、常见的内置函数
print : 输出
input : 输入
type : 查看数据类型
id : 获取数据的内存地址
range : 生成数据
len : 获取数据的长度(元素总数)
int、float 、bool 、str、list、tuple、dict、set：代表对应的数据类型
最大值 最小值的内置函数
min:求最小值
max:求最大值
sum:求和
2、python中高级内置函数
2.1、enmerate
返回一个可以枚举的对象，enmerate将其组成一个索引序列，利用它可以同时获得索引和值
2.2、eval:
取出字符串中的内容
将字符串str当成有效的表达式来求值，并返回计算结果
2.3、filter:过滤器
filter:过滤器
filter:(参数1、参数2)
参数1：过滤规则的函数
参数2：要过滤的数据
2.4、zip:聚合打包

"""
# 函数参数拆包
# 一个*用来接收位置参数的不定长参数
# 两个**是用来接收关键字参数的不定长参数
def func(*args, **kwargs):
    print(args)
    print(**kwargs)
data = (11, 22, 33, 44, 55)
data1 = [11, 22, 33, 44, 55]
# 通过*对元祖、字符串、列表(序列类型)拆包，只有在调用函数的时候可以用(用在函数的参数上)
func(*data) # 函数拆包
def func5(a,b,c):
    print(a)
    print(b)
    print(c)
data = [11,22,33]
# 调用函数才能拆包
func5(*data)
aa,bb,cc = data
print(aa,bb,cc)
# 函数的作用域:在函数内部中定义的变量，只有在该函数中才能够使用
# 局部变量：定义在函数内部的变量叫做局部变量
# 全局变量：直接定义在文件中的变量，叫做全局变量，在该文件任何地方都能够访问
a = 100
def func1():
    b = 100
    print(a)
    print(b)
func1()

def func2():
    global b
    b = 100
func2()
print(b)

# 扩展知识点,函数嵌套里面是默认全局变量，可以正常使用
def func3():
    aa = 11
    def func4():
        nonlocal aa # 使用nonlocal可以在嵌套函数内部修改外部函数的局部变量的值
        aa += 1
        print(aa)
    func4()
    print(aa)
func3()

# 变量的查找过程：由内向外去找的，先找自身一层作用域有没有，没有的话会去外面找
a = 100
# 如果在函数内部定义的局部变量和全局变量重名，那么最好把局部变量的定义放在该函数的最前面
def func4():
    a = 11
    print(a)
func4()
print(a)
'''
最大值 最小值的内置函数
min:求最小值,里面全部是数值类型
max:求最大值,里面全部是数值类型
sum:求和
'''
li = [11,34,1,54,6,88,99]
# 获取最小值
res = min(li)
print(res)
# 获取最大值
res2 = max(li)
print(res2)
# 求和sum
res3 = sum(li)
print(res3)

# li = [11,22,33,44,55]
# 返回一个可以枚举的对象，enmerate将其组成一个索引序列，利用它可以同时获得索引和值
res = enumerate(li)
list2 = list(res)
print(list2)

dic = {"a":11,"b":22}
print(list(dic.items()))

# eval:识别字符串中的python表达式
# eval：可以将字符串类型转换为列表或者元祖
s1 = "(1,2,3)"
s2 = "[11,22,33]"

print(s1,type(s1))
res11 = eval(s1)
print(res11,type(res11))

res2 = eval(s2)
print(res2,type(res2))

# 注意：如果是个纯粹的字符串，那么使用eval进行转换之后就变成了一个变量名
python = 666
s4 = "python"
res4 = eval(s4)
print(res4,type(res4))

# 过滤函数：filter(参数1，参数2)
# 参数1：函数
# 参数2：过滤的数据

# 案例 li=[11,22,33,44,55,1,2,3,4,88,99]
# 过滤所有大于33的数据
li=[11,22,33,44,55,1,2,3,4,88,99]
def func(x):
    return x>33
# 方式一
new_list = []
for i in li :
    if func(i):
        new_list.append(i)
# 方式二
new_list = filter(func,li)
res = lambda x:x>33
print(list(new_list))
# 匿名函数
new_list = filter(lambda x:x>33,li)

# zip:聚合打包
li = [11,22,33,44]
li2 = [111,222,333,444]
li3 = [1111,2222,3333,4444]
res = zip(li,li2,li3)
print(list(res))

# 案例
users_title = ["name", "age", "gender"]
user_info = [["小明", 18, "男"],
             ["小李", 19, "男"],
             ["小美", 17, "女"]
             ]
# 要求：将上述数据转换为以下格式
users = [{"name":"小明","age":18,"gender":"男"},
        {"name":"小李","age":19,"gender":"男"},
        {"name":"小美","age":17,"gender":"女"}
        ]
t = ["name", "age", "gender"]
s = ["小明", 18, "男"]
res = zip(t,s)
print(dict(res))
new_users = []
for user in user_info:
    res = zip(users_title,user)
    new_users.append(dict(res))
print(new_users)

# res = zip(t,s)
# print(dict(res))