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 = 0for i in s1:length = length+1print(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 = 0for i in s1:length = length+1return 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 = 0for 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 = 0for i in s1:length = length+1return length#函数调用
str_len = mylen()
print(str_len)  # 返回这个字符串的长度，结果为11

 

第四种：多个值  返回一个由这多个值组成的元组

　　　　可以返回任意多个、任意数据类型的值

def ret_demo1():'''返回多个值'''return 1, 2, 3, 4def ret_demo2():'''返回多个任意类型的值'''return 1, ['a', 'b'], 3, 4print(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 = 0for i in s1:length = length+1return lengthstr_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 = 0for i in s:c += 1return cret = my_len(l1)  # 将字符串l1传递给函数
print(ret)

 

　　4.按照实参角度传參　　

第一种：位置参数：从前至后 一一对应

def mymax(x, y):  # x接收10，y接收20the_max = x if x > y else yreturn the_maxma = mymax(10, 20)
print(ma)

第二种：关键字传參：不用按照顺序，按变量名一一对应

def mymax(x, y):  # 此时x = 20,y = 10the_max = x if x > y else yreturn the_maxma = mymax(y = 10, x = 20)
print(ma)

第三种：混合传參：位置参数一定在前面

def mymax(x, y):  # 此时x = 10,y = 20the_max = x if x > y else yreturn the_maxma = 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, sexsex = 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接收第一个参数1print(b)  # 2 位置参数b接收第二个参数2print(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接收第一个参数1print(b)  # 2 位置参数b接收第二个参数2print(sex)  # 女 默认参数已被更改，所以输出新值print(args)  # (4, 5, 6, 7, 8, 9) 剩下的全部使用*args接收func5(1, 2, 4, 5, 6, 7, 8, 9, sex='女')

 

五、名称空间

　　先认识一下什么叫名称空间　　

def func1():m = 1print(m)
func1()print(m)  # 报错 NameError: name 'm' is not defined

上面为什么会报错呢？

　　函数被调用的时候，python解释器会再开辟一块内存来储存这个函数里面的内容，函数中的变量会储存在新开辟出来的内存中，函数中的变量只能在函数内部使用

　　当函数执行完毕，这块内存中的所有内容也会被清空。

 

存放名字与值的关系的空间起了一个名字-------名称空间。

 

python中的名称空间：　　

　　全局名称空间：代码在运行开始，创建的存储“变量名与值的关系”的空间
　　临时（局部）名称空间：在函数的运行中开辟的临时的空间
　　内置名称空间: len print 等内置函数等等。

加载顺序： 内置名称空间  ---> 全局名称空间 ---> 函数执行时：临时（局部）名称空间

取值顺序:   函数执行时：临时（局部）名称空间 ---> 全局名称空间 ----> 内置名称空间
　　　　　（ 取值顺序满足就近原则 ）

 

 六、函数的作用域和嵌套

　　1、什么是作用域　　

 

　　作用域：  作用域就是作用范围

 

　　全局作用域：包含内置名称空间、全局名称空间，在整个文件的任意位置都能被引用、全局有效

 

　　局部作用域：局部名称空间，只能在局部范围内生效

 

 

a = 1
print(a)  # 1
def func1():a = 99print(a)  # 99 满足就近原则，取最近的值
func1()

 

　　2、作用域中会遇到的坑　　

　　局部只能引用全局的变量但是不能修改，修改就会报错

a = 1
print(a)  # 1
def func1():a += 1print(a)  # 会报错，不能引用全部变量a
func1()

　　global     
　　　　可以修改全局变量
　　　　在局部空间可以声明一个全局变量

　　　　可变数据类型（list，dict，set）可以直接引用不用通过global。

# 修改全局变量
a = 1
print(a)  # 1
def func1():global a  # 引用全局变量a,此时a的值为1a += 1print(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 = 1def inner():  # 子名称空间print(a)  # 结果：1  函数执行的第二步输出print(a)  # 结果：1 函数执行的第一步输出
    inner()print(a)  # 结果：1 函数执行的第三步输出
func1()# 未使用nonlocal,引用并且修改,会报错
def func1():  # 父名称空间a = 1def inner():  # 子名称空间a += 1  # 修改变量aprint(a)  # 会报错：local variable 'a' referenced before assignment
    inner()print(a)
func1()# 使用nonlocal后既可引用，也可修改
def func1():  # 父名称空间a = 1def inner():  # 子名称空间nonlocal a  # 引用父名称空间的变量aa += 1  # 修改变量a，这层及以下此变量全部发生改变print(a)  # 结果：2  函数执行的第二步输出print(a)  # 结果：1 函数执行的第一步输出
    inner()print(a)  # 结果：2 函数执行的第三步输出
func1()# 不能修改全局变量
b = 3
def func1():  # 父名称空间a = 1def inner():  # 子名称空间nonlocal a  # 引用父名称空间的变量aa += 1  # 修改变量a，这层及以下此变量全部发生改变b += 1  # 会报错，不能修改全局变量：local variable 'a' referenced before assignmentprint(a)  # 结果：2  函数执行的第二步输出print(a)  # 结果：1 函数执行的第一步输出
    inner()print(a)  # 结果：2 函数执行的第三步输出
func1()

 

 　　3.函数的嵌套　　

# 第一种函数嵌套
def func1():  # 第二步执行func1print(111) # 第三步，输出111def func2():  # 第六步执行func2print(222)  # 第七步 输出222print(333)  # 第四步，读到这一行,输出333
    func2()  # 第五步执行func2print(444)  # 第八步，输出444
    
func1()  # 函数执行时先读这一行# 第二种函数嵌套
def func1():  # 第七步 执行func1print(111)  # 第八步 输出111def func2():  # 第四步 执行func2print(222)  # 第五步 输出222func1()  # 第六步 读到这一行def func3():  # 第二步 执行func3func2()  # 第三步，读到这一行print(333)  # 第九步，输出333，因为其余内嵌的函数已经全部执行完了

func3()  # 函数执行时先读到这一行

 

　　4.函数的作用域　　

　　小范围作用域可以使用大范围的变量，但是反之不行，他是单向的。

# 大范围的作用域不能使用小范围的变量
# 第一种  大作用域f1中未定义变量，试着使用小作用域f2中的a的值，会报错
def f1():def f2():a = 2print(a)f2()print(a)  # 第二步，f1中未定义变量a,无法取f2中的值，所以会报错 name 'a' is not defined

f1()# 修改上边的报错：在大作用域f1中定义a
def f1():a = 1def f2():a = 2print(a)  # 先输出a的值为2
    f2()print(a)  # 再输出a的值为1,此a是f1中的a,与f2中的a无关，只是名字相同

f1()# 第二种  小范围的作用域能使用大范围的变量
def f1():a = 1def 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)  # 第六步 输出111def func2(x):  # 第二步 x接收传来的值func1print(x)  # 第三步 输出func1的内存地址x()  # 第四步 执行x函数，即执行func1
func2(func1)  # 第一步，代码读到这一行，将func1传给x

 

　　3、函数名可以作为函数的返回值　　

# 当作函数的返回值
# 第一种
def f1():  # 第四步 执行f1函数print(111)  # 第五步 输出111def func1(argv):  # 第二步 argv 接收到函数名f1argv()  # 第三步 执行argv()，即执行f1()，第五步执行完的结果为111return argv  # 第六步 将argv的函数名返回给func1

f = func1(f1)  # 第一步 将函数名f1传给argv，第六步执行完，func1(f1) = argv
f()  # 第七步 f()本质上就是argv(),执行argv()# 从第三步得知，执行argv()即执行f1，最后输出结果为111# 第二种    
def func1():  # 第五步，执行func1print(111)  # 第六步 输出111def func2(x):  # 第二步 执行func2，x接收到函数名func1， x = func1return 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)  # 第四步 输出111def 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')  # 第四步输出222def 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的变量namereturn innerf = 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 innerf = func()
f()# 输出的__closure__为None ：不是闭包函数
name = '大锤'
def func2():def inner():print(name)print(inner.__closure__)return innerf2 = func2()
f2()

 

　　4、闭包的作用　　

# 非闭包函数 随着函数的结束临时空间关闭
def func1(s1):n = 1n += s1print(n)func1(5)  # 6
func1(5)  # 6
func1(5)  # 6# 闭包函数
def wrapper(s1):n = 1def inner():nonlocal nn += s1print(n)return innerret = wrapper(5)
ret()  # 6
ret()  # 11
ret()  # 16

小总结：

　　闭包的机制：python遇到闭包，产生一个空间，这个空间不会随着函数的结束而消失。

 

　　5、闭包的嵌套　　

def wrapper():  # 第二步 执行此韩式money = 100  # 第三步def func():  # 第四步执行此函数name = '大锤'def inner():print(name, money)return innerreturn func  # 第五步 将函数名func返回给上层函数wrapper

f = wrapper()  # 第一步 代码读到这，第五步执行完，f=func
i = f()  # 第六步 执行f()，即执行func()，执行完func()后将函数名func再次传给i，此时i=func
i()  # 第七步 i()即func()，执行func,输出结果： 大锤 100