python (六)函数
一、函数的形成
需求1:来测试一下‘hello word’ 的长度
# 在没有函数的时候,我们可以用for循环实现 s1 = "hello world" length = 0 for i in s1: length = length+1 print(length)
再增加一个需求2:再来测试一下另外一个字符串的长度:‘hello china’
然后需求1和需求2的代码就变成下边这样
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)
上边的代码确实可以实现需求,但是有缺点:代码重复,可读性差。 我们将上面的代码称之为面向过程的方式
为了解决这种问题就出现了函数
函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。
二、函数的格式和调用
def mylen(): # 定义一个函数mylen
'''计算s1的长度''' s1 = "hello world" length = 0 for i in s1: length = length+1 print(length) mylen() # 函数调用
def 关键词开头,空格之后接函数名称和圆括号(),最后还有一个":"。 def 是固定的,不能变,他就是定义函数的关键字。 空格 为了将def关键字和函数名分开,必须空(四声) 函数名:函数名只能包含字符串、下划线和数字且不能以数字开头。虽然函数名可以随便起,但我们给函数起名字还是要尽量简短,并能表达函数功能 括号:是必须加的 注释:每一个函数都应该对功能和参数进行相应的说明,应该写在函数下面第一行。以增强代码的可读性。 调用:就是 函数名()
二、函数的返回值
1、什么是函数的返回值
在使用内置函数len()方法时,得到的结果会赋值给一个变量,然后得到结果:
str_len = len('hello,world') print(str_len)
但是自己写的这个函数mylen(),并不会得到这样的结果,如何让他和len函数一样,有返回值呢?
那就是在函数的最后加上一个return,return 后面写你需要的返回值就可以了。
#函数定义 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) return返回值
2、return关键字的作用
1、函数中遇到return终止函数。
2、返回值 返回给了函数的调用者
3、return返回值的的三种情况
第一种:没有return 返回None
def mylen(): s1 = "hello world" length = 0 for i in s1: length = length+1 str_len = mylen() print(str_len) # 因为没有返回值,此时的str_len为None
第二种:return后没有返回值
return的其他用法,就是一旦遇到return,结束整个函数。
def ret_demo(): print(111) # 此行代码执行 return # 直接种植代码 print(222) # 此行不会输出 ret = ret_demo() print(ret) # 因为return后没有任何值, 所以此处结果为None
第三种:单个值 返回单个值
#函数定义 def mylen(): """计算s1的长度""" s1 = "hello world" length = 0 for i in s1: length = length+1 return length #函数调用 str_len = mylen() print(str_len) # 返回这个字符串的长度,结果为11
第四种:多个值 返回一个由这多个值组成的元组
可以返回任意多个、任意数据类型的值
def ret_demo1(): '''返回多个值''' return 1, 2, 3, 4 def ret_demo2(): '''返回多个任意类型的值''' return 1, ['a', 'b'], 3, 4 print(ret_demo1()) # 结果为(1, 2, 3, 4) print(ret_demo2()) # 结果为(1, ['a', 'b'], 3, 4)
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 = ret_demo2() print(a, b, c, d) # 1 ['a', 'b'] 3 4
四、函数的参数
1.什么是参数
之前我们使用len函数的时候得是length = len("hello world"),但是这个函数,只能计算一个“hello world”的长度,换一个字符串就需要写多个函数,很不方便
def mylen(s1): # 定一个一个参数s1 """计算s1的长度""" length = 0 for i in s1: length = length+1 return length str_len = mylen("hello world") # 将hello world传递给s1 print(str_len)
我们告诉mylen函数要计算的字符串是谁,这个过程就叫做 传递参数,简称传参,我们调用函数时传递的这个“hello world”和定义函数时的s1就是参数。
2.认识实参和形参
我们调用函数时传递的这个“hello world”被称为实际参数,因为这个是实际的要交给函数的内容,简称实参。
定义函数时的s1,只是一个变量的名字,被称为形式参数,因为在定义函数的时候它只是一个形式,表示这里有一个参数,简称形参。
3.参数的传递
第一种:可以传递字符串,前边已经举例
第二种:可以传递列表
l1 = [1, 2, 34, 55, 66] def my_len(s): # 形參s接收到实参l1的值 c = 0 for i in s: c += 1 return c ret = my_len(l1) # 将字符串l1传递给函数 print(ret)
4.按照实参角度传參
第一种:位置参数:从前至后 一一对应
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 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 the_max = x if x > y else y return the_max ma = mymax(10, y = 20) # 位置参数一定要在关键字参数前面 print(ma)
小总结:位置参数必须在关键字参数的前面
对于一个形参只能赋值一次
5.按照形參角度传參
第一种:位置传参: 按照顺序,一一对应,未给形參传值会报错
def func1(a, b, c, d): print(a, b, c) func1(1, 2, 3) # 结果会报错, 没有给位置参数d传值
第二种:默认传参: 如果不传,则默认使用默认参数,传参则覆盖。
为什么要有默认参数:将变化比较小的值设置成默认参数
def func2(name, age, sex='男'): # sex接收传来的参数'女' print(name, age, sex) func2('大锤', 18, sex='女') # 结果:大锤 18 女
利用默认传參可以设置默认输入
def wfile(name, age, sex='男'): # 定义函数wfile,形參name、age,默认参数sex """建立登记表函数,由于班中大部分学生都是男生, 所以设置默认参数sex的默认值为'男' """ with open('登记表', encoding='utf-8', mode='a') as f1: f1.write('{}|{}|{}\n'.format(name, age, sex)) # 格式化输入三个参数 while 1: # 可以循环输入 name = input('姓名(输入Q/q退出):') if name.upper() == 'Q':break # 如果输入Q/q退出程序 age = input('年龄:') if name.startswith('王'): # 设置一个规则,如果姓名以'王'开头 wfile(name, age) # 函数只执行 name和age。sex无需执行,直接记录默认值'男' else: # 否则(即:如果姓名不是以'王'开头) 就需要输入sex,并且执行name, age, sex sex = input('性别:') wfile(name, age, sex) # 这一步会把输入的sex覆盖默认值的值
默认参数是一个可变的数据类型
def func(a, l=[]): # 定义形參a,实参l=[] l.append(a) # 将a的值添加至列表l中 print(l) func('aaa') # ['aaa'], func('bbb') # ['aaa', 'bbb'] func('ccc') # ['aaa', 'bbb', 'ccc']
6.万能参数
万能参数也叫动态参数:*args **kwargs 也叫不定长传参
需要传给函数的参数很多,不定个数,那这种情况下,你就用*args,**kwargs接收
l1 = [1, 2, 3] l2 = [11, 22, 33] l3 = (55, 66, 77) dic = {'name': 'alex'} dic1 = {'age': '12'} def func4(*args, **kwargs): print(args) print(kwargs) func4(*l1, *l2, *l3, **dic, **dic1) # (1, 2, 3, 11, 22, 33, 55, 66, 77) {'name': 'alex', 'age': '12'} func4(l1, l2, l3, dic, dic1) # ([1, 2, 3], [11, 22, 33], (55, 66, 77), {'name': 'alex'}, {'age': '12'}) {}
注意1:args是元祖形式,接收除去键值对以外的所有参数,kwargs接收的只是键值对的参数,并保存在字典中。
如果未接收到传来的参数,那么就会输出空值
def func4(*args, **kwargs): print(args) # ([1, 2, 3], [11, 22, 33], (55, 66, 77)) print(kwargs) # {},**kwargs未接收到键值对的参数,所有输出的结果是一个空的字典 func4([1, 2, 3], [11, 22, 33], (55, 66, 77))
7.位置参数、默认参数、万能参数混合使用
# 默认参数未被更改 def func5(a, b, *args, sex='男'): print(a) # 1 位置参数a接收第一个参数1 print(b) # 2 位置参数b接收第二个参数2 print(sex) # 男 默认参数未被更改,还是默认的值 print(args) # (4, 5, 6, 7, 8, 9) 剩下的全部使用*args接收 func5(1, 2, 4, 5, 6, 7, 8, 9) # 默认参数已被更改 def func5(a, b, *args, sex='男', **kwargs): print(a) # 1 位置参数a接收第一个参数1 print(b) # 2 位置参数b接收第二个参数2 print(sex) # 女 默认参数已被更改,所以输出新值 print(args) # (4, 5, 6, 7, 8, 9) 剩下的全部使用*args接收 func5(1, 2, 4, 5, 6, 7, 8, 9, sex='女')
五、名称空间
先认识一下什么叫名称空间
def func1(): m = 1 print(m) func1() print(m) # 报错 NameError: name 'm' is not defined
上面为什么会报错呢?
函数被调用的时候,python解释器会再开辟一块内存来储存这个函数里面的内容,函数中的变量会储存在新开辟出来的内存中,函数中的变量只能在函数内部使用
当函数执行完毕,这块内存中的所有内容也会被清空。
存放名字与值的关系的空间起了一个名字-------名称空间。
python中的名称空间:
全局名称空间:代码在运行开始,创建的存储“变量名与值的关系”的空间
临时(局部)名称空间:在函数的运行中开辟的临时的空间
内置名称空间: len print 等内置函数等等。
加载顺序: 内置名称空间 ---> 全局名称空间 ---> 函数执行时:临时(局部)名称空间
取值顺序: 函数执行时:临时(局部)名称空间 ---> 全局名称空间 ----> 内置名称空间
( 取值顺序满足就近原则 )
六、函数的作用域和嵌套
1、什么是作用域
作用域: 作用域就是作用范围
全局作用域:包含内置名称空间、全局名称空间,在整个文件的任意位置都能被引用、全局有效
局部作用域:局部名称空间,只能在局部范围内生效
a = 1 print(a) # 1 def func1(): a = 99 print(a) # 99 满足就近原则,取最近的值 func1()
2、作用域中会遇到的坑
局部只能引用全局的变量但是不能修改,修改就会报错
a = 1 print(a) # 1 def func1(): a += 1 print(a) # 会报错,不能引用全部变量a func1()
global
可以修改全局变量
在局部空间可以声明一个全局变量
可变数据类型(list,dict,set)可以直接引用不用通过global。
# 修改全局变量
a = 1 print(a) # 1 def func1(): global a # 引用全局变量a,此时a的值为1 a += 1 print(a) # 2 func1()
# 声明全局变量
def func(): global a # 没有全局变量的时候也可以使用,在函数内部直接声明了全局变量 a = 1 func() print(a) # 1
# 引用可变的数据类型,无需global
li = [1, 2, 3] dic = {'a': 'b'} def change(): li.append('a') # 无需global,可以直接引用 dic['q'] = 'g' # # 无需global,可以直接引用 print(dic) # {'a': 'b', 'q': 'g'} print(li) # [1, 2, 3, 'a'] change() print(li) # [1, 2, 3, 'a'] print(dic) # {'a': 'b', 'q': 'g'}
nonlocal
不能操作全局变量
在局部作用域中,对父级作用域(或者更外层作用域非全局作用域)的变量进行引用和修改,且引用的哪层,从那层及以下此变量全部发生改变。
子名称空间只能引用父名称空间的变量,但是不能修改,如果修改就会报错
#只引用未修改 def func1(): # 父名称空间 a = 1 def inner(): # 子名称空间 print(a) # 结果:1 函数执行的第二步输出 print(a) # 结果:1 函数执行的第一步输出 inner() print(a) # 结果:1 函数执行的第三步输出 func1() # 未使用nonlocal,引用并且修改,会报错 def func1(): # 父名称空间 a = 1 def inner(): # 子名称空间 a += 1 # 修改变量a print(a) # 会报错:local variable 'a' referenced before assignment inner() print(a) func1() # 使用nonlocal后既可引用,也可修改 def func1(): # 父名称空间 a = 1 def inner(): # 子名称空间 nonlocal a # 引用父名称空间的变量a a += 1 # 修改变量a,这层及以下此变量全部发生改变 print(a) # 结果:2 函数执行的第二步输出 print(a) # 结果:1 函数执行的第一步输出 inner() print(a) # 结果:2 函数执行的第三步输出 func1() # 不能修改全局变量 b = 3 def func1(): # 父名称空间 a = 1 def inner(): # 子名称空间 nonlocal a # 引用父名称空间的变量a a += 1 # 修改变量a,这层及以下此变量全部发生改变 b += 1 # 会报错,不能修改全局变量:local variable 'a' referenced before assignment print(a) # 结果:2 函数执行的第二步输出 print(a) # 结果:1 函数执行的第一步输出 inner() print(a) # 结果:2 函数执行的第三步输出 func1()
3.函数的嵌套
# 第一种函数嵌套 def func1(): # 第二步执行func1 print(111) # 第三步,输出111 def func2(): # 第六步执行func2 print(222) # 第七步 输出222 print(333) # 第四步,读到这一行,输出333 func2() # 第五步执行func2 print(444) # 第八步,输出444 func1() # 函数执行时先读这一行 # 第二种函数嵌套 def func1(): # 第七步 执行func1 print(111) # 第八步 输出111 def func2(): # 第四步 执行func2 print(222) # 第五步 输出222 func1() # 第六步 读到这一行 def func3(): # 第二步 执行func3 func2() # 第三步,读到这一行 print(333) # 第九步,输出333,因为其余内嵌的函数已经全部执行完了 func3() # 函数执行时先读到这一行
4.函数的作用域
小范围作用域可以使用大范围的变量,但是反之不行,他是单向的。
# 大范围的作用域不能使用小范围的变量 # 第一种 大作用域f1中未定义变量,试着使用小作用域f2中的a的值,会报错 def f1(): def f2(): a = 2 print(a) f2() print(a) # 第二步,f1中未定义变量a,无法取f2中的值,所以会报错 name 'a' is not defined f1() # 修改上边的报错:在大作用域f1中定义a def f1(): a = 1 def f2(): a = 2 print(a) # 先输出a的值为2 f2() print(a) # 再输出a的值为1,此a是f1中的a,与f2中的a无关,只是名字相同 f1() # 第二种 小范围的作用域能使用大范围的变量 def f1(): a = 1 def f2(): print(a) # 取的是f1中的a的值1 f2() f1()
七、函数名的运用
1、直接输出函数名(输出函数的内存地址)
def func1(): print(111) print(func1) # 输出函数func1的内存地址 <function func1 at 0x10fdf31e0> f1 = func1 # 将func1的函数名传给f1 f2 = f1 # 将f1的值赋值给f2 print(f2) # 输出f2,既输出f1,即输出func1的内存地址,<function func1 at 0x10fdf31e0> f2() # ,执行f2,即执行f1,即执行func1,结果为 111
2、函数名可以作为函数的参数
def func1(): # 第五步 执行此函数 print(111) # 第六步 输出111 def func2(x): # 第二步 x接收传来的值func1 print(x) # 第三步 输出func1的内存地址 x() # 第四步 执行x函数,即执行func1 func2(func1) # 第一步,代码读到这一行,将func1传给x
3、函数名可以作为函数的返回值
# 当作函数的返回值 # 第一种 def f1(): # 第四步 执行f1函数 print(111) # 第五步 输出111 def func1(argv): # 第二步 argv 接收到函数名f1 argv() # 第三步 执行argv(),即执行f1(),第五步执行完的结果为111 return argv # 第六步 将argv的函数名返回给func1 f = func1(f1) # 第一步 将函数名f1传给argv,第六步执行完,func1(f1) = argv f() # 第七步 f()本质上就是argv(),执行argv() # 从第三步得知,执行argv()即执行f1,最后输出结果为111 # 第二种 def func1(): # 第五步,执行func1 print(111) # 第六步 输出111 def func2(x): # 第二步 执行func2,x接收到函数名func1, x = func1 return x # 第三步 将x返回给函数的调用者func2,即将函数名func1返回给函数func2 ret = func2(func1) # 第一步 执行等号后的func2(func1),将函数名func1传给x # 并将函数func2的值传给ret # 第三步执行完,此时func2(func1)的值为func1,这个等式可以写成ret = func1 ret() # 第四步 执行ret(),其实就是执行func1()
4、函数名可以作为容器类数据类型的参数
# 函数名作为列表中的元素 # 第一种 直接调用 def func1(): # 第三步 执行此函数 print(111) # 第四步 输出111 def func2(): print(222) def func3(): print(333) li = [func1, func2, func3] # 第一步,先读到这行,函数名作为列表的元素 li[0]() # 第二步 li的0号元素是func1,li[0]()本质上就是func1() # 第二种 循环调用 def func1(): print(111) def func2(): print(222) def func3(): print(333) li = [func1, func2, func3] # 第一步,先读到这行,函数名作为列表的元素 for i in li: # 循环执行三个函数 i() # 函数名作为字典中键的值 # 第一种 直接调用 def f1(): print('111') def f2(): # 第三步,代码读到这行,执行此函数 print('222') # 第四步输出222 def f3(): print('333') dic = {'x': f1, 'y': f2, 'z': f3} # 第一步 读到这行,函数作为了字典中键的值 dic['y']() # 第二步 dic中'y'键的值是f2,dic['y']()本质上就是f2() # 第二种循环输出 def func1(): print(111) def func2(): print(222) def func3(): print(333) def func4(): print(444) dic = { # 第一步先读到这行 1: func1, # 输入哪个数字,就执行哪个数字对应的函数 2: func2, 3: func3, 4: func4, } while 1: # 第二步 读到这行 choice = int(input('请输入数字:')) # 第三步将输入的数字转化成int类型 dic[choice]() # 第四步 dic[choice]()本质上就是执行输入的数字对应的 键的值 对应的函数
八、闭包
1、什么是闭包
1、闭包是嵌套在函数中的
2、闭包是内层函数对外层函数的变量(非全局变量)的引用(改变)
3、闭包需要将其作为一个对象返回,而且必须逐层返回直至最外层函数的返回值
2、闭包的格式
# 闭包的基本格式 def func(): name = '大锤' def inner(): print(name) # 引用外部函数func的变量name return inner f = func() f() # 闭包举例 # 第一个 这步是闭包 def func1(): ''' 此函数满足前闭包定义的前两个条件,但还不是闭包 因为没有返回值return ''' name = '太白' def func2(): print(name) # 第二个 这也不是闭包 ame = 'alex' def wrapper(): def inner(): print(name) # 调用的是全部变量,非外层函数变量 return inner # 第三个 这是闭包 def wrapper(): name = '太白' def inner(): print(name) return inner # 第四个 这个也是闭包 def wrapper(name): def inner(): print(name) return inner n1 = 'wusir' wrapper(n1)
3、 怎么样判断是不是闭包
# 输出的__closure__有cell元素 :是闭包函数 def func(): name = '大锤' def inner(): print(name) print(inner.__closure__) return inner f = func() f() # 输出的__closure__为None :不是闭包函数 name = '大锤' def func2(): def inner(): print(name) print(inner.__closure__) return inner f2 = func2() f2()
4、闭包的作用
# 非闭包函数 随着函数的结束临时空间关闭 def func1(s1): n = 1 n += s1 print(n) func1(5) # 6 func1(5) # 6 func1(5) # 6 # 闭包函数 def wrapper(s1): n = 1 def inner(): nonlocal n n += s1 print(n) return inner ret = wrapper(5) ret() # 6 ret() # 11 ret() # 16
小总结:
闭包的机制:python遇到闭包,产生一个空间,这个空间不会随着函数的结束而消失。
5、闭包的嵌套
def wrapper(): # 第二步 执行此韩式 money = 100 # 第三步 def func(): # 第四步执行此函数 name = '大锤' def inner(): print(name, money) return inner return func # 第五步 将函数名func返回给上层函数wrapper f = wrapper() # 第一步 代码读到这,第五步执行完,f=func i = f() # 第六步 执行f(),即执行func(),执行完func()后将函数名func再次传给i,此时i=func i() # 第七步 i()即func(),执行func,输出结果: 大锤 100