Python——函数
1. 函数
（1）特点
可读性强、复用性强
（2）定义
def funcname():
funcbody
return
（3）调用
funcname()
（4）注释
def func(): ''' 这个函数实现了什么功能 参数1：解释 参数2：解释 ... :return: 返回值类型 ''' #funcbody函数体
（5）注意事项
只定义不调用就一定不执行
先定义后调用
2. 返回值
返回的重要性---不能使用函数调用结束的结果进行其他操作
函数名()——不接收返回值
返回值 = 函数名()——接收返回值
（1）没有返回值：
默认返回None
<1>不写return：函数内的代码执行完毕，自动结束
def func(): l = ['xc','gx'] for i in l: print(i) #xc gx if i=='gx': pass print('lalala') #lalala rt = func() print(rt) #None
<2>只写return：结束一个函数
def func(): l = ['xc','gx'] for i in l: print(i) #xc gx if i=='gx': return print('lalala') #return之后函数结束，不再继续执行这句话 rt = func() print(rt) #None
<3>return None——不常用
def func(): l = ['xc','gx'] for i in l: print(i) #xc gx if i=='gx': return None print('lalala') #return之后函数结束，不再继续执行这句话 rt = func() print(rt) #None
（2）返回一个值
结束了函数且返回一个值，可以是任意的值
<1>可以返回任何数据类型
<2>只要返回就可以接收到
<3>如果在一个程序中有多个return，只执行第一个
def func(): return print(func()) #None def func1(): return [1,2,3,4] print(func1()) #[1, 2, 3, 4] def func2(): return {'k','v'} return 1 #在前一个return已经结束函数了，此条语句不执行 print(func2()) #{'v', 'k'}
（3）返回多个值
多个值之间用逗号隔开，可以用一个(返回元祖)或者等量的多个变量接收
def func(): return 1,2 rt1,rt2 = func() print(rt1,rt2) #1 2 r = func() print(r) #(1, 2)
3. 参数
没有参数——定义和调用函数的时候，括号里不写内容
有一个参数——传什么就是什么
有多个参数——位置参数
（1）形参和实参
def my_len(s): #接收参数——形式参数，形参 i = 0 for k in s: i += 1 return i s = '金老板小护士' rt = my_len(s) #传递参数(传参)——实际参数，实参 rt1 = my_len('班主任星儿最好看') print(rt) #6 print(rt1) #8
（2）形参——定义函数的时候
<1>位置参数：必须传，且有几个参数传几个值
<2>默认参数：可以不传，不传就使用默认的，传什么用什么
默认参数的陷阱：
默认参数的值是可变数据类型,那么每一次调用函数的时候,如果不传值就公用这个数据类型的资源
#(1) def qqxing(l = []): l.append(1) print(l) qqxing() #[1] qqxing([]) #[1] qqxing() #[1, 1] qqxing() #[1, 1, 1] qqxing([]) #[1] #(2) def qqxing(l = {}): l['k'] = 'v' print(l) qqxing() #{'k': 'v'} qqxing({}) #{'k': 'v'} qqxing() #{'k': 'v'} qqxing({}) #{'k': 'v'} #(3) def qqxing(k,l = {}): l[k] = 'v' print(l) qqxing(1) #{1: 'v'} qqxing(5,l = {'k3':'v3'}) #{'k3': 'v3', 5: 'v'} qqxing(2) #{1: 'v', 2: 'v'} qqxing(22) #{1: 'v', 2: 'v', 22: 'v'} qqxing(6,l = {'k3':'v3'}) #{'k3': 'v3', 6: 'v'} qqxing(3) #{1: 'v', 2: 'v', 3: 'v'} qqxing(33) #{1: 'v', 2: 'v', 22: 'v', 3: 'v', 33: 'v'} qqxing(333) #{1: 'v', 2: 'v', 22: 'v', 3: 'v', 33: 'v', 333: 'v'} qqxing(7,l = {'k3':'v3'}) #{'k3': 'v3', 7: 'v'} qqxing(3,l = {'k3':'v3'}) #{'k3': 'v3', 3: 'v'} qqxing(8,l = {'k3':'v3'}) #{'k3': 'v3', 8: 'v'}
<3>动态参数：可以接收任意个参数
*args：接收的是按照位置传参的值，组织成一个元祖
**kwargs：接收的是按照关键字传参的值，组织成一个字典
args必须在kwargs之前
# 动态传参（*args） def func00(*args): #站在形参的角度，给变量加上*，就是组合所有的值 print(args) func00(1,2,3,4,5) #(1, 2, 3, 4, 5) l = [1,2,3,4,5] func00(*l) #(1, 2, 3, 4, 5) 站在实参的角度，给一个序列加上*，就是将这个序列按照顺序打散 def func1(**kwargs): #可以接收任意多个按关键字传的参数 print(kwargs) func1(a=1,b=2,c=3) #{'a': 1, 'b': 2, 'c': 3} func1(a=1,b=2) #{'a': 1, 'b': 2} func1(a=1) #{'a': 1} def func11(**kwargs): print(kwargs) func11(a=1,b=2) #{'a': 1, 'b': 2} d = {'a':1,'b':2} func11(**d) #{'a': 1, 'b': 2} def func2(*args,**kwargs): print(args,kwargs) func2(1,2,3,a = 'addc', b = 'csdsv') #(1, 2, 3) {'a': 'addc', 'b': 'csdsv'}
<4>混合使用
# 位置参数+默认参数 def classmate(name,sex='男'): print('%s:%s'%(name,sex)) classmate('二哥') #二哥:男——位置参数+默认参数（未传值） classmate('小梦','女') #小梦:女——位置参数+默认参数（传值） classmate('大猛') #大猛:男——位置参数+默认参数（未传值） # 动态参数（*args）+关键字参数 def func0(*args,l=[]): print(args,l) func0() #() [] func0(1,2,'str',['lst',1]) #(1, 2, 'str', ['lst', 1]) [] func0(1,2,'str',l = ['lst',1]) #(1, 2, 'str') ['lst', 1]
特点：
<1>位置参数：必须传
<2>*args：动态参数，可以接收任意多个按位置传的参数
<3>默认参数：可以不传——陷阱
<4>**kwargs：动态参数，可以接收任意多个按关键字传的参数
定义函数的时候
位置参数：直接定义参数
默认参数：关键字参数，参数名 = ‘默认的值’
动态参数：可以接收任意多个参数
定义方式：*变量名（习惯用*args）
**变量名（习惯用**kwargs）
顺序：位置参数，*args，默认参数，**kwargs
（3）实参——调用函数的时候
<1>按照位置传参数
<2>按照关键字传参数
def my_sum(a,b): print(a,b) #1 2 res = a+b return res rt = my_sum(1,2) #按照位置传参 rt1 = my_sum(b = 2,a = 1) #按照关键字传参 rt2 = my_sum(1,b = 2) #混合使用（位置传参在前，关键字传参在后） print(rt) #3 print(rt1) #3 print(rt2) #3
特点：
可以混用 位置必须在关键字之前
不能对一个参数重复赋值
调用函数的时候：
按照位置传：直接写参数的值
按照关键字传：关键字 = 值
4. 命名空间（3种）
（1）内置命名空间——python解释器
python解释器一启动就可以使用的名字
内置的名字在启动解释器的时候被加载进内存中
（2）全局命名空间——我们写的代码，但不是函数中的代码
是在程序从上到下执行的过程中依次加载进来的
放置了我们设置的所有变量名和函数名
（3）局部命名空间——函数
是函数内部定义的名字
当调用函数的时候才会产生这个名字空间，随着函数的结束而消失
多个函数应该拥有多个独立的名字空间，不互相共享
（4）加载与取值的顺序
加载顺序：内置命名空间 > 全 局 命 名 空 间 > 局 部 命 名 空 间
程序运行前加载 程序运行中：从上到下 程序运行中：调用时才加载
（5）名字空间的使用
在内置：不能使用全局和局部的名字
在全局：可以使用内置的名字，但不能使用局部的名字
在局部：可以使用内置和全局的名字
局部有就用局部的，局部没有就找全局的；
全局有就用全局的，全局没有就找内置的；
内置的有就用内置的，内置没有就报错
def max(): print('in max func') max() #in max func def input(): print('in input now') def func(): input = 1 print(input) #<function input at 0x0000012CB1761D08> #func() #func---->函数的内存地址 #func()---->函数的调用 #函数的内存地址()---->函数的调用
5. 作用域（2种）
（1）全局作用域
作用在全局——包含内置和全局名字空间中的名字
（2）局部作用域
作用在局部——包含局部名字空间（）函数中的名字
对于不可变数据类型：在局部可以查看全局作用域中的名字
不能直接修改
想要修改，则需要在函数开始添加globle
6. 关键字：global、local、nonlocal
（1）global
如果在一个局部（函数）内声明了global变量，在局部的所有操作对这个变量有效
a = 1 def func(): global a a += 1 func() print(a) #2
尽量少使用global，涉及到安全问题——用传参替代
a = 1 def func(a): a += 1 return a a = func(a) print(a) #2
(2) global和locals的区别
查看局部作用域中的所有名字——globals()全局的——在局部和全局永远都打印全局的名字
查看全局作用域中的所有名字——locals()本地的——在局部就打印局部的名字，在全局就打印全局的名字
a = 1 b = 2 def func(): x = 'aaa' y= 'bbb' print(locals()) #局部{'y': 'bbb', 'x': 'aaa'} func() print(locals()) #全局+内置（同下） print(globals()) #全局+内置 #{'__name__': '__main__', '__doc__': '\na = 1\ndef func():\n global a\n # a += 1\n # a = 2\nfunc()\nprint(a)\n', '__package__': None, # '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000002028799B518>, # '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, # '__file__': 'E:/Python/day10/03 函数的命名空间.py', '__cached__': None, 'a': 1, 'b': 2, # 'func': <function func at 0x0000020287A71D08>}
（3）nonlocal
只能用于局部变量，找最近的上一层的局部变量
声明了nonlocal的内部函数的变量的修改，回影响到上一层局部变量的值
对全局无效，对局部最近的一层有影响
def outer(): a = 1 def inner(): a = 2 def inner2(): nonlocal a print(a) inner2() inner() outer() #2
7. 函数的嵌套
（1）嵌套调用
def max(a,b): return a if a>b else b print(max(5,2)) #5 def the_max(x,y,z): c = max(x,y) return max(c,z) print(the_max(1,5,3)) #5
（2）嵌套定义
a = 1 def outer(): #定义inner a = 1 def inner(): #定义inner1 b = 2 print(a) #1 print('inner') #inner def inner2(): #定义inner2 # global a #声明了一个全局变量a,只对函数外的全局变量有效 nonlocal a #声明了一个上层的局部变量a,只找上面第一层 a += 1 #没有上面两句中任意一句,则报错：不可变数据类型的修改 print(a,b) #2 2 print('inner2') #inner2 inner2() #调用inner2 print('###a###: ',a) ####a###: 2 inner() #调用inner1——若没有这句话来调用inner()，则运行不输出任何结果 print('***a***: ',a) #***a***: 2 outer() #调用inner print(a) #1
8. 闭包
（1）闭包定义
嵌套函数，且内部函数要调用外部函数的变量
def outer(): a = 1 def inner(): print(a) inner() outer()
（2）判断是否是闭包
def outer(): a = 1 def inner(): print(a) print(inner.__closure__) #是闭包：(<cell at 0x0000017AAEAC6678: int object at 0x000000005F8E60E0>,) outer() print(outer.__closure__) #不是闭包：None
（3）使用闭包的好处
在函数的外部使用内部函数
def outer(): a = 1 def inner(): print(a) return inner inn = outer() inn() #1
（4）闭包的应用
import urllib #模块 from urllib.request import urlopen def get_url(): url = 'http://www.baidu.com' def get(): ret = urlopen(url).read() print(ret) return get get_func = get_url() get_func()
