# 1、为什么要用函数？ # 2、函数的定义与调用 # 3、函数的返回值 # 4、函数的参数 # 5、命名空间和作用域 # 6、函数嵌套及作用域链 # 7、函数名的本质 # 8、函数的闭包
1、为什么要用函数？
假如len方法突然不能直接用了，现在有个需求是【计算'hello world'的长度】：
s1 = "hello world" length = 0 for i in s1: length = length+1 print(length)
现在又新增了一个需求，要计算另外一个字符串的长度，"hello China"。于是，这个时候你的代码就变成了这样：
s1 = "hello world" length = 0 for i in s1: length = length+1 print(length) s2 = "hello China" length = 0 for i in s2: length = length+1 print(length)
这会造成：
首先，之前只要执行len方法就可以直接拿到一个字符串的长度了，现在为了实现相同的功能我们把相同的代码写了好多遍 —— 代码冗余
其次，之前我们只写两句话读起来也很简单，一看就知道这两句代码是在计算长度，但是刚刚的代码却不那么容易读懂 —— 可读性差
于是乎，要是能像len一样将这段代码起个名字就好了，需要的时候直接“喊名字”就可以了。
2、函数的定义与调用
把上面求字符串长度的代码封装起来：
#函数定义 def mylen(): """计算s1的长度""" s1 = "hello world" length = 0 for i in s1: length = length+1 print(length) #函数调用 mylen()
函数名：函数名只能包含字符串、下划线和数字，且不能以数字开头。虽然函数名可以随便起，但我们给函数起名字还是要尽量简短，并能表达函数功能。
3、函数的返回值
将上面函数定义里的print改成return，在函数调用的时候看需求再print
#函数定义 def mylen(): """计算s1的长度""" s1 = "hello world" length = 0 for i in s1: length = length+1 return length #函数调用 str_len = mylen() print('str_len : %s'%str_len)
3.1 return关键字的作用
划重点：一旦遇到return，就结束整个函数。
返回值有几种情况：分别是没有返回值、返回一个值、返回多个值。
3.1.1 没有返回值
# return <=> return None <=> 没有return def ret_demo(): print(111) return print(222) ret = ret_demo() print(ret) ------------------------------------------------------------------------------------ def ret_demo(): print(111) return None print(222) ret = ret_demo() print(ret) ------------------------------------------------------------------------------------ def ret_demo(): print(111) print(222) ret = ret_demo() print(ret)
3.1.2 返回一个值
# 注意：return和返回值之间要有空格，可以返回任意数据类型的值 def ret_demo(): return 111 print(222) ret = ret_demo() print(ret) # 111
3.1.3 返回多个值
# 可以返回任意多个、任意数据类型的值 def ret_demo1(): '''返回多个值''' return 1,2,3,4 def ret_demo2(): '''返回多个任意类型的值''' return 1,['a','b'],3,4 ret1 = ret_demo1() print(ret1) # (1, 2, 3, 4) ret2 = ret_demo2() # (1, ['a', 'b'], 3, 4) print(ret2)
def ret_demo2(): return 1,['a','b'],3,4 #返回多个值，用一个变量接收 ret2 = ret_demo2() print(ret2) # (1, ['a', 'b'], 3, 4) #返回几个值，就用几个变量接收 a,b,c,d = ret_demo2() print(a,"->",b,"->",c,"->",d) # 1 -> ['a', 'b'] -> 3 -> 4
#序列解压一 >>> a,b,c,d = (1,2,3,4) >>> a 1 >>> b 2 >>> c 3 >>> d 4 #序列解压二 >>> a,_,_,d=(1,2,3,4) >>> a 1 >>> d 4 >>> a,*_=(1,2,3,4) >>> *_,d=(1,2,3,4) >>> a 1 >>> d 4 #也适用于字符串、列表、字典、集合 >>> a,b = {'name':'eva','age':18} >>> a 'name' >>> b 'age'
4、函数的参数
#函数定义 def mylen(s1): """计算s1的长度""" length = 0 for i in s1: length = length+1 return length #函数调用 str_len = mylen("hello world") print('str_len : %s'%str_len)
4.1 实参和形参
我们调用函数时传递的这个“hello world”被称为实际参数，因为这个是实际的要交给函数的内容，简称实参。
定义函数时的s1，只是一个变量的名字，被称为形式参数，因为在定义函数的时候它只是一个形式，表示这里有一个参数，简称形参。
4.2 传递多个参数
参数可以传递多个，多个参数之间用逗号分割。
def mymax(x,y): the_max = x if x > y else y return the_max ma = mymax(10,20) print(ma)
4.3 位置参数
4.3.1 站在实参角度：（顺序：位置参数，默认参数，关键字参数a = ''）
对于一个形参只能赋值一次
# ①按位置传参 def mymax(x,y): #此时x=10,y=20 the_max = x if x > y else y return the_max ma = mymax(10,20) print(ma)
# ② 按照关键字传参 def mymax(x,y): #此时x = 20,y = 10 print(x,y) the_max = x if x > y else y return the_max ma = mymax(y = 10,x = 20) print(ma)
# ③ 位置、关键字形式混着用 def mymax(x,y): #此时x = 10,y = 20 print(x,y) the_max = x if x > y else y return the_max ma = mymax(10,y = 20) print(ma)
4.3.2 站在形参角度：（顺序：*args，默认参数，**kwargs）
def func(*args,default = 1,**kwargs): #形参顺序： （*args，默认参数，**kwargs） print(args,default,kwargs) func(1,2,3,default=2,a='aaaa',b='bbbbb') #实参顺序： （位置参数，默认参数，关键字参数a = ''） 运行结果： (1, 2, 3) 2 {'a': 'aaaa', 'b': 'bbbbb'}
位置参数必须传值
def mymax(x,y): print(x,y) the_max = x if x > y else y return the_max #调用mymax不传递参数 ma = mymax() print(ma) #结果 TypeError: mymax() missing 2 required positional arguments: 'x' and 'y'
4.4 默认参数
# 默认参数的值是一个可变数据类型 # 每一次调用函数的时候，如果不传值，就公用这个数据类型的资源 def stu_info(name,sex = "male"): """打印学生信息函数，由于班中大部分学生都是男生， 所以设置默认参数sex的默认值为'male' """ print(name,sex) stu_info('alex') # alex male stu_info('eva','female') # eva female
# 默认参数的陷阱 def qqxing(k,d = {}): d[k] = 'v' print(d) qqxing(1) #{1: 'v'} qqxing(2) #{1: 'v', 2: 'v'} #新执行完的都添加到默认的dict里边 qqxing(3) #{1: 'v', 2: 'v', 3: 'v'}
4.5 动态参数
# *args：按位置传值多余的参数都由args统一接收，保存成一个元组的形式 def mysum(*args): the_sum = 0 for i in args: the_sum+=i return the_sum the_sum = mysum(1,2,3,4) print(the_sum)
# **kwargs def stu_info(**kwargs): print(kwargs) print(kwargs['name'],kwargs['sex']) stu_info(name = 'alex',sex = 'male')
参数总结
5、命名空间和作用域
5.1 命名空间
【依赖倒置原则】：向上依赖
【向下选择原则】：当我自己有的时候，我就不找我的上级要了；如果我自己没有，就一层一层往上级找（找级数最低的），如果内置的命名空间里也没有，则报错
多个函数应该拥有多个独立的局部名字空间，不互相共享
命名空间
## 内置命名空间 -- python解释器 # python解释器一启动就可以使用的名字存储在内置命名空间中 # 内置的名字在其冻结时期的时候被加载进内存里 ## 全局命名空间 -- 我们写的代码，但不是函数中的代码 #是在程序从上到下被执行的过程中依次加载进内存的 #放置了我们设置的所有变量名和函数名 ## 局部命名空间 -- 函数 #就是函数内部调用的名字 #当调用函数的时候，才会产生这个名称空间，随着函数执行的结束，这个命名空间就又消失了 -------------------------------------------------------------------------------- ----##三种命名空间之间的加载与取值顺序： #加载顺序： #内置命名空间(程序运行前加载)->全局命名空间(程序运行中：从上到下加载)->局部命名空间(程序运行中：调用时才加载) # 取值顺序： # 在局部调用：局部命名空间->全局命名空间->内置命名空间 x = 1 def f(x): x=3 print(x) f(2) # 3 print(10) # 10 # 在全局调用：全局命名空间->内置命名空间 x = 10 def f(x): print(x) f(2) # 2 print(x) # 10
5.2 作用域
作用域就是作用范围，按照生效范围可以分为全局作用域和局部作用域。
5.2.1 globals() 和 locals()方法
【全局作用域】： -- globals()：永远打印全局的名字
包含内置名称空间、全局名称空间，在整个文件的任意位置都能被引用、全局有效。
【局部作用域】：-- locals()：取决于位置，在哪儿哪儿就是本地
局部名称空间，只能在局部范围内生效 。
a = 1 b = 2 def func(): x = 'aaa' y = 'bbb' print(locals()) print(globals()) #全局的：永远打印全局的名字 func() 运行结果： {'y': 'bbb', 'x': 'aaa'} {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00000219469AEF28>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'F:/Python/Project/All_Stacks/01 基础/day10/02.函数的命名空间.py', '__cached__': None, 'a': 1, 'b': 2, 'func': <function func at 0x00000219468A3E18>}
5.2.2 global关键字
a = 10 def func(): global a # 在函数（局部命名空间）中执行的是全局的变量a print('func中a的值：',a) a = 20 # 修改的是全局的a的值，生效 print('全局中a的值：',a) func() print('执行完func后全局中a的值：',a) 运行结果： 全局中a的值： 10 func中a的值： 10 执行完func后全局中a的值： 20
6、函数嵌套及作用域链
6.1 函数嵌套
内部函数使用外部函数的变量
def max2(x,y): m = x if x>y else y return m def max4(a,b,c,d): res1 = max2(a,b) res2 = max2(res1,c) res3 = max2(res2,d) return res3 ret = max4(23,-7,31,11) print(ret) # 31 -------------------------------------------------------------------------------- def f1(): def f2(): def f3(): print("in f3") # ⑤ print("in f2") # ③ f3() # ④ print("in f1") # ① f2() # ② f1() 运行结果： in f1 in f2 in f3
6.2 函数作用域链
def f1(): a = 1 def f2(): def f3(): print(a) f3() f2() f1() # 1 ------------------------------------------------------------------------------------ def f1(): a = 3 def f2(): a = 2 f2() # 并没有改变 f1函数中a的值 print('a in f1 : ',a) f1() # 3
6.3 nonlocal关键字
#定义： # 声明了一个上层的局部变量，作用域只到 上层第一个 有该变量（最低层），找上层中离当前函数最近一层的局部变量 # 声明了nonlocal的内部函数变量修改，会影响到当前函数最近一层的局部变量 #规则： # 1.外部必须有这个变量 # 2.在内部函数声明nonlocal变量之前不能再出现同名变量 # 3.内部修改这个变量如果想在外部有这个变量的第一层函数中生效 def f1(): a = 1 def f2(): nonlocal a a = 2 f2() print('a in f1 : ',a) # a in f1 : 2 f1()
6.4 综合示例
a = 1 def outer(): a = 1 #此处是局部变量 def inner(): a = 3 b = 2 print("inner中a的值：",a) print('inner') #此处只是定义，并没有调用 def inner2(): # global a #声明了一个全局变量,修改的是全局的a，不修改局部的 nonlocal a #声明了一个上层的局部变量，作用域只到 上层第一个 有该变量（最低层），找上层中离当前函数最近一层的局部变量 # 声明了nonlocal的内部函数变量修改，会影响到当前函数最近一层的局部变量 a += 1 #不可变数据类型的修改 print('inner2中的a：%d'%a) # print('inner2') inner2() inner() print('局部的a:%d'%a) outer() print('全局a:%d'%a) 运行结果： inner中a的值： 3 inner inner2中的a：4 局部的a:1 全局a:1
7、函数名的本质
函数名本质上：就是函数的内存地址
def func(): print(123) func2 = func ### 函数名可以赋值 func2() # 123
7.1 可以被引用
def func(): print('in func') f = func print(f) #<function func at 0x000001C6CF353E18>
7.2 可以被当做容器类型的元素
def func(): print(123) func2 = func # 函数名就是内存地址，可以赋值 l = [func,func2] # 函数名可以作为容器类型（如list，dict等）的元素 print(l) for i in l: # i <=> 函数名 i() # 调用函数 运行结果： [<function func at 0x0000025136343E18>, <function func at 0x0000025136343E18>] 123 123
7.3 可以当做函数的参数和返回值
def func(): print(123) def wahaha(f): f() # 执行func() return f # 函数名可以作为函数的返回值 qqxing = wahaha(func) # 函数名可以作为函数的参数 <=> qqxing = f qqxing() # 等价于执行 func() 运行结果: 123 123
8、函数的闭包
闭包发生在嵌套函数中：
# bar函数不需要传参数，就能获取到外面的变量，这是一个典型的闭包现象。 def foo(): name = "Andy" # 定义了一个foo函数内部的局部变量 def bar(): print(name) # 在bar函数内部引用了其外部函数foo的局部变量name return bar func = foo() # 相当于执行 func = bar func() # 相当于执行 bar() # Andy
8.1 闭包的定义
函数内部定义的函数，称为内部函数。这个内部函数只有使用了它外部函数的局部变量，即使外部函数返回了，这个内部函数还可以访问到外部函数的局部变量，这种现象就叫做闭包。
8.2 闭包的本质
闭包：是由函数和与它相关的引用环境组合而成的实体。
像下面的 func函数就不能称为闭包，因为它并没有使用包含它的外部函数的局部变量。
name = "Alex" # 定义了一个全局变量 def foo(): def bar(): print(name) # 在bar函数内部引用了全局变量name return bar func = foo() print(func.__closure__) # None
8.3 判断闭包函数的方法__closure__
#输出的__closure__有cell元素 ：是闭包函数 def func(): name = 'eva' def inner(): print(name) print("inner.__closure__ : ",inner.__closure__) return inner f = func() f() #运行结果： (<cell at 0x00000215E4550C48: str object at 0x00000215E46F84C8>,) eva ———————————————————————————————————— #输出的__closure__为None ：不是闭包函数 name = 'egon' def func2(): def inner(): print(name) print("inner.__closure__ : ", inner.__closure__) return inner f2 = func2() f2() #运行结果： None egon
8.4 闭包嵌套
def wrapper(): money = 1000 def func(): name = 'eva' def inner(): print(name,money) # eva 1000 return inner return func f = wrapper() i = f() i()