20180713 (函数参数:动态传参,函数的命名空间,作用域,嵌套,global和nonlocal)
一.函数参数
动态传参(形参) (*位置参数)
顺序: 位置参数--------*args(动态位置参数)----------默认值参数---------------**kwargs(关键字参数)
(1)动态接收位置参数 (位置参数要放在动态参数之前) (如果动态参数放在位置参数之前的时候,在程序运行的时候会报错,因为前面传递进去的位置参数都被动态参数接收到了,并不会执行后面的a,b)
例如:
def chi(*food): #可以传入任意的位置参数
print("我要吃",food) #动态位置参数接收到的是元组(tuple)类型的数据
chi("红烧肉","炸酱面") ====>我要吃 ("红烧肉","炸酱面")
(2)默认值参数 (动态参数要放在默认值参数之前) (如果动态参数放在默认值参数的后面,程序在执行的时候,会直接跳过默认值参数,输入的内容会被动态参数全部接收,不会执行默认值参数)
例如:
def func(a,b,c,*args,d = 5)
print(a,b,c,d,args)
func(1,2,3,4,5,6,7) ===>1 2 3 5 (4,5,6,7)
(3)动态接收关键字参数 (**关键字参数) (一定要放在位置参数的后面)
例如:
def func(**food): #**food 动态接收关键字参数 接受到的是字典(dict)类型
print(food)
func(good_food="红烧肉",bad_food="香菜") ===>{"good_food":"红烧肉","bad_food":"香菜"}
(4)无敌形式 (这个函数可以接收所有的参数)
例如:
def func(*args,**kwargs)
print(args)
print(kwargs)
func(1,2,3,4,5,name="某某某",age=22,sex="女") =====>(1,2,3,4,5) {"name":"某某某","age":22,"sex"="女"}
(5) * 在形参的位置表示聚合,将所有的位置参数聚合成元组
* 在实参的位置上表示打散 (是通过迭代产生的)
例如:把列表中的每一个元素作为参数,传递给函数,一次都传递过去
def func(*args):
print(args)
lst = ["AB","CD","EF"]
func(*lst) =====>("AB","CD","EF") 在实参的位置把打散, 是以元组的形式执行出来
print(*lst) ======> AB CD EF 打印出来的是字符串
例如:
def func(*kwargs):
print(kwargs)
dic={"name":"太白","alex":"wuse"}
print(dic) ====>{"name":"太白","alex":"wuse"} 在实参的位置打散 是以字典的形式执行
(6)函数的注释
例如:
def func(a,b):
'' '' ''
计算a+b的和,返回一个数
:param a:第一个数
:param b:第二个数 ===>pycharm自己会生成
:return :返回计算后的和
" " "
return a + b
二.命名空间
(1)内置命名空间 :python解释内部运行时的变量函数(list,tuple,str,int,type)
(2)全局命名空间:我们在Python文件中直接声明出来的变量函数
(3)局部命名空间:在函数内部声明的变量
加载顺序: 内置命名空间 ==== 全局命名空间 ======局部命名空间(函数被执行的时候)
取值顺序: 局部命名空间 ======全局命名空间 =======内置命名空间
例如:
a = "123" 全局命名空间
b = 30 全局命名空间
def func(): 全局命名空间
c = "ABC" 局部命名空间
def hab(): 局部命名空间
pass 局部命名空间
取值顺序:
a = 10
def func():
a = 20 如果函数局部空间中存在a = 20 就输出20,不存在的时候就找全局空间里的值,所以输出10
print(a) (就近原则)
func() =====>20
三.作用域
作用域命名空间:
(1),全局作用域:全局命名空间 + 内置命名空间 globals() 函数在查看全局作用域中的内容
(2).局部作用域:局部命名空间 locals() 查看当前作用域中的所有内容
四.函数的嵌套 按顺序进行执行
(1)只要遇见了()就是函数的调用,如果没有()就不是函数的调用
(2)函数的执行顺序
例如:
def func1():
print("哈哈")
def func2():
print("呵呵")
func1() ===>如果这个位置是func2 则代表的是递归 一直调用自己,无限循环 最大(998)
func2() ====>呵呵,哈哈
例如: (按顺序)
def func1():
print("呵呵")
def func2():
print("哈哈")
func2()
print("哄哄")
func1() ====>呵呵,哈哈,哄哄
五.global 和 nonlocal
global 表示 不再使用局部作用域的内容,而是该用全局作用域中的变量,将全局作用域中的变量拿过来,当变量的值改变的时候,全局作用域中的也跟着改变
nonlocal 表示在局部作用域中,调用离他最近的一层的变量,将变量拿过来使用,这个时候拿过来的变量也会跟着改变, 但是不会找全局作用域中的变量
例如:
a = 10
def func():
a = 20 在自己的作用域中使用a,是全新的变量a 当当前作用域中没有变量.则会取全局作用域中的变量
print(a)
func() ====>20
print(a) =====>10
例如:
a = 10
def func():
global a a 不再是局部变量,而是将全局变量拿过来,这个时候全局变量也会改变
a = a +10
print(a)
func() ===>20
print(a) =====>20
例如: nonlocal (在局部作用域中,将离他最近的一层的值拿过来使用,这个时候被拿过来的值也会被改变)
def func():
a = 10
def func2();
a = 20 如果没有这个变量a 换成nonlocal a ======>输出的结果是20,20
print(a) =====>20,10
func2()
print(a)
func()
作业题
1.写函数，接收n个数字，求这些参数数字的和。（动态传参）
def func(*args)
return sum(args)
print(func(1,2,3,4,5,6))
2.写函数，传入n个数，返回字典{‘max’:最大值,’min’:最小值}
例如:min_max(2,5,7,8,4) 返回:{‘max’:8,’min’:2}(此题用到max(),min()内置函数)
def func(*args)
m = args[0]
mi =args[0]
for el in args:
if el > m:
m = el
if el < mi:
mi = el
return("最大值":m,"最小值":mi)
print(func())
3.写函数，返回一个扑克牌列表，里面有52项，每一项是一个元组
例如：[(‘红心’，2),(‘草花’，2), …(‘黑桃’，‘A’)]
def func():
yanse = ["红心","方块","梅花","黑桃"]
dianshu = ["2","3","4","5","6","7","8","9","10","J","Q","K","A"]
lis = []
for el in yanse:
for a in dianshu:
lis.append((el,a))
return lis
ret = func()
print(ret)
4.(此题有坑)下面代码打印的结果分别是_[10,"a"]_,_[123]_,_[10,"a"]_.
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)
如果默认值参数是一个可变的数据类型,如果有人调用的时候改变了他,其他位置看到也跟着改变
5.写代码完成99乘法表.
做法1:
a = 1 #行号
while a <= 9:
print(a)
b = 1 #行数
while b <= a:
print("%d*%d=%d\t" % (a,b,a*b),end = "")
b = b + 1
print() #换行
a = a + 1
做法2:
for a in range(1,10):
for b in range(1,a+1):
print("%d * %d = %d"\t% (a,b,a*b),end="")
print()
