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('{}|{}|{}
'.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