1.动态传参（形参）
1）问题描述：要给一个函数传参，但是参数个数是不确定的，即写的形参很多，此时可以使用动态传参，即在参数前加*
①位置参数的动态传参（*args）
def func(*food): print("我要吃",food) func("牛肉面","盖浇饭","炒面") 输出： 我要吃 ('牛肉面', '盖浇饭', '炒面')
注：动态参数接受到的是元组数据类型的数据
#如果要将位置参数和动态参数一起使用，应该先写位置参数，再写动态参数
def func(a,b,*food): print("我要吃",a,b,food) func("牛肉面","盖浇饭","炒面","辣条","西红柿炒蛋") 输出： 我要吃 牛肉面 盖浇饭 ('炒面', '辣条', '西红柿炒蛋')
#如果形参中不但有位置参数、动态参数，还有默认值参数，那么要将默认值参数放在最后面
def func(a,b,*food,d="汤汤汤"): print("我要吃",a,b,food,d) func("牛肉面","盖浇饭","炒面","辣条","西红柿炒蛋") 输出： 我要吃 牛肉面 盖浇饭 ('炒面', '辣条', '西红柿炒蛋') 汤汤汤
结论：位置参数----》动态参数(*args)----》默认参数
例：写一个函数，给函数传递任意个整数，返回这些整数的和
def sum(*n): s = 0 for i in n: s = s + i return s print(sum(1,2,3,4,5)) 输出： 15
②动态接受关键字参数（**args）
动态接受关键字参数，接受到的是一个字典
def func(**game): #动态接受关键字参数 print(game) #接受到的是一个字典 func(lol="英雄联盟",DNF="地下城勇士") 输出： {'lol': '英雄联盟', 'DNF': '地下城勇士'}
2.命名空间
在python解释器开始执⾏之后, 就会在内存中开辟⼀个空间, 每当遇到⼀个变量的时候, 就 把变量名和值之间的关系记录下来, 但是当遇到函数定义的时候, 解释器只是把函数名读入内存, 表⽰这个函数存在了, ⾄于函数内部的变量和逻辑, 解释器是不关⼼的. 也就是说⼀开始 的时候函数只是加载进来, 仅此⽽已, 只有当函数被调⽤和访问的时候, 解释器才会根据函数 内部声明的变量来进⾏开辟变量的内部空间. 随着函数执⾏完毕, 这些函数内部变量占⽤的空间也会随着函数执⾏完毕⽽被清空。
我们给存放名字和值的关系的空间起⼀个名字叫: 命名空间. 我们的变量在存储的时候就是存储在这片空间中的.
） 命名空间分类
①内置命名空间：存放python解释器内部运行时的变量函数，如列表、元组、字典等数据类型，print()等内置的函数
②全局命名空间：直接写在py文件中变量、函数等属于全局命名空间
③局部命名空间：定义在函数中的变量位于局部命名空间
2）命名空间加载顺序
①内置命名空间
②全局命名空间
③局部命名空间（函数被执行的时候）
3）取值顺序：即若全局变量名和局部变量名相同，优先获取局部变量的值（就近原则）
①局部命名空间
②全局命名空间
③内置命名空间
a = 10 def func(): a = 20 print(a) print(a) 输出： 20
3.作用域
作用域即作用范围，按照生效范围分为全局作用域和局部作用域
1）作用域命名空间
①全局作用域：全局命名空间+内置命名空间
②局部作用域：局部命名空间
2）查看全局作用域和局部作用域内容（若都防止在外面，显示内容相同）
①可通过函数globals()查看全局作用域中的内容
②可通过函数locals()查看当前作用域中的变量和函数信息
print(globals()) #全局作用域内容 print(locals()) #当前作用域内容
4.函数的嵌套
1）只要遇见了()就是函数的调用，如果没有()就不是函数的调用；不再()打印的是函数的地址
2）函数的嵌套调用
def func1(): print("哈哈") def func2(): func1() print("呵呵") func2() #函数的递归（自己调用自己，最多999次） func2() 输出： 哈哈 呵呵 哈哈 呵呵 。。。
3）函数的嵌套
def fun1(): print("哈哈") def func2(): print("呵呵") func2() print("吼吼") fun1() 输出： 哈哈 呵呵 吼吼
例：多次函数的嵌套定义和调用
def func1(): print("赵") def func2(): print("钱") def func3(): print("孙") print("李") func3() print("周") func2() func1() 输出： 赵 周 钱 李 孙
5.关键字global和nonlocal
1)global作用：被声明的变量，不再使用局部作用域中的内容，而是改用全局作用域中的变量
a = 10 def func(): global a a = a + 10 #使用全局变量 print(a) func() print(a) #在函数中，全局变量发生了改变 输出： 20 20
#在函数中对引入的全局变量赋值，则全局变量会发生改变
a = 100 def func(): global a # 加了个global表示不再局部创建这个变量了. ⽽是直接使⽤全局的a a = 28 #对引入的全局变量进行了赋值，即把全局中的a进行了赋值 print(a) func() print(a) #在函数内部对全局变量进行了赋值，所以值改变 输出： 28 28
2）nonlocal:对于位于局部中，但是不属于自己的，再往上找一层，即在局部作⽤域中, 调⽤⽗级命名空间中的变量（将想当于把最内层的变量值，赋值给了上一层变量）,把离他最近一层的变量拿过来，不会找全局变量
a = 10 def func1(): a = 20 def func2(): nonlocal a #若去掉，输出结果为30 20 a = 30 print(a) func2() print(a) func1() 输出： 30 30
例：
a = 1 def fun_1(): a = 2 def fun_2(): nonlocal a a = 3 def fun_3(): a = 4 print(a) print(a) fun_3() print(a) print(a) fun_2() print(a) print(a) fun_1() print(a) 输出： 1 2 3 4 3 3 1
6.练习
1）接受动态参数，并求这些参数的和
#法一
def func(*args): sum = 0 for i in args: sum = sum + i return sum print(func(1,2,3,4,5)) 输出： 15
#法二
def func(*args): return sum(args) print(func(1,2,3,4,5)) 输出： 15
2）写一个函数，传入n个数，返回字典{'max':"最大值"，'min':"最小值"}，例如min_max(2,5,7,8,4,)，返回{'max':8,'min':2}
def func(*args): return {'max':max(args),'min':min(args)} print(func(8,7,2,6)) 输出： {'min': 2, 'max': 8}
#法二
def func(*args): for i in args: m = args[0] #假设传入的第一个参数为最大值，赋值给m mi = args[0] #假设传入的第一个参数为最大值，赋值给mi if i > m: m = i elif i < mi: mi = i return {'max':m,'min':mi} print(func(10,5,8,27,1)) 输出： {'min': 1, 'max': 10}
3）写一个函数，返回一个扑克盘列表，里面有52项，每一项是一个元组。例如[('红心',2), ('草花',2), ('黑桃',2), ('方块',2)]
color = ["红心","黑桃","草花","方块"] num = ["A","K","Q","J","10","9","8","7","6","5","4","3","2"] result = [] for i in color: for j in num: result.append((i,j)) print(result) 输出： [('红心', 'A'), ('红心', 'K'), ('红心', 'Q'), ('红心', 'J')。。。
4)执行inner函数
#法一
def wapper(): def inner(): print("666") return inner #直接把函数返回 wapper()()
#法二：
def wapper(): def inner(): print("666") return inner() wapper()
5)补充：如果默认值参数是一个可变的数据类型，如果有人调用的时候改变了它，其他位置看到的也跟着改变了
def extendList(val, list=[]): list.append(val) return list list1 = extendList(10) list2 = extendList(123, []) list3 = extendList('a') # print('list1=%s' % list1) print('list2=%s' % list2) # print('list3=%s' % list3) 输出： list1=[10, 'a'] list2=[123] list3=[10, 'a']
def extendList(val, list=[]): list.append(val) return list list1 = extendList(10) print('list1=%s' % list1) list2 = extendList(123, []) print('list2=%s' % list2) # list3 = extendList('a') print('list3=%s' % list3) 输出： list1=[10] list2=[123] list3=[10, 'a']
6) 打印9*9乘法表
a = 1 while a<=9: b =1 while b<=a: print("%dx%d=%d " % (a,b,a*b),end = "") b = b + 1 print() a = a + 1 输出： 1x1=1 2x1=2 2x2=4 3x1=3 3x2=6 3x3=9 4x1=4 4x2=8 4x3=12 4x4=16 5x1=5 5x2=10 5x3=15 5x4=20 5x5=25 6x1=6 6x2=12 6x3=18 6x4=24 6x5=30 6x6=36 7x1=7 7x2=14 7x3=21 7x4=28 7x5=35 7x6=42 7x7=49 8x1=8 8x2=16 8x3=24 8x4=32 8x5=40 8x6=48 8x7=56 8x8=64 9x1=9 9x2=18 9x3=27 9x4=36 9x5=45 9x6=54 9x7=63 9x8=72 9x9=81