python 函数与生成器

函数

Python函数

​ 由若干语句组成的语句块、函数名称、参数列表构成，它是组织代码的最小单元

​ 完成一定的功能

函数的作用

​ 结构化编程对代码的最基本的封装，一般按照功能组织一段代码

​ 封装的目的为了复用，减少冗余代码

​ 代码更加简洁美观、可读易懂

函数定义

def 函数名(参数列表):

​ 函数体（代码块）

​ [return 返回值]

​ 函数名就是标识符，命名要求一样

​ 语句块必须缩进，约定4个空格

​ Python的函数若没有return语句，会隐式返回一个None值

​ 定义中的参数列表称为形式参数，只是一种符号表达（标识符），简称形参

函数调用

​ 函数定义，只是声明了一个函数，它不能被执行，需要调用执行

​ 调用的方式，就是函数名后加上小括号，如有必要在括号内填写上参数

​ 调用时写的参数是实际参数，是实实在在传入的值，简称实参

def add( x, y): # 函数定义
    result = x + y # 函数体
    return result  # 返回值

out = add(4,5) # 函数调用，可能有返回值，使用变量接收这个返回值
print(out) # print函数加上括号也是调用，out也是实参

函数参数

函数在定义是要定义好形式参数，调用时也提供足够的实际参数，一般来说，形参和实参个数要一致（可变参数除外）

实参传参方式

1、位置传参

定义时def f(x, y, z)，调用使用 f(1, 3, 5)，按照参数定义顺序传入实参

2、关键字传参

定义时def f(x, y, z)，调用使用 f(x=1, y=3, z=5)，使用形参的名字来传入实参的方式，如果使用了形参名字，那么传参顺序就可和定义顺序不同

要求位置参数必须在关键字参数之前传入，位置参数是按位置对应的

def add( x, y):
    print(x)
    print(y)
    print('-'* 30)
add(4, 5)
add(5, 4) # 按顺序对应，反过来x和y值就不同

add(x=[4], y=(5,))
add(y=5.1, x=4.2) # 关键字传参，按名字对应，无所谓顺序

add(4, y=5) # 正确
add(y=5, 4) # 错误传参
#位置参数一定要写在关键字参数之前

形参缺省值

缺省值也称为默认值，可以在函数定义时，为形参增加一个缺省值。其作用：

​ 参数的默认值可以在未传入足够的实参的时候，对没有给定的参数赋值为默认值

​ 参数非常多的时候，并不需要用户每次都输入所有的参数，简化函数调用

def add(x=4,y=5):
    return x+y

可变参数

需求：写一个函数，可以对多个数累加求和

def sum(*nums):
    sum = 0
    for x in nums:
        sum += x
    return sum

print(sum(1, 3, 5))
print(sum(1, 2, 3)) 

1、可变位置参数

​ 在形参前使用 * 表示该形参是可变位置参数，可以接受多个实参

​ 它将收集来的实参组织到一个tuple中

2、可变关键字参数

​ 在形参前使用 ** 表示该形参是可变关键字参数，可以接受多个关键字参数

​ 它将收集来的实参的名称和值，组织到一个dict中

def showconfig(**kwargs):
    for k, v in kwargs.items():
        print('{}={}'.format(k, v), end=', ')


showconfig(host='127.0.0.1', port=8080, username='wayne', password='magedu')

混合使用

def showconfig(username, password, *args)
def showconfig(username, password, **kwargs)
def showconfig(username, *args, **kwargs)
def showconfig(*args, **kwargs)

总结：

​ 有可变位置参数和可变关键字参数

​ 可变位置参数在形参前使用一个星号*

​ 可变关键字参数在形参前使用两个星号**

​ 可变位置参数和可变关键字参数都可以收集若干个实参，可变位置参数收集形成一个tuple类型对象，可变关键字参数收集形成一个dict类型对象

​ 混合使用参数的时候，普通参数需要放到参数列表前面，可变参数要放到参数列表的后面，可变位置参数需要在可变关键字参数之前

keyword-only参数

def fn(*args, x, y, **kwargs):
    print(x, y, args, kwargs, sep='\n', end='\n\n'

这里的x,y 就是仅关键字传参

因为前面有可变位置参数

Positional-only参数

Python 3.8 开始，增加了最后一种形参类型的定义：Positional-only参数。

def fn(a, /,b):
    print(a,b, sep='\n')

fn(3,4)#可以
fn(3,b=4)#可以
fn(a=4,b=2) # 错误，仅位置参数，不可以使用关键字传参

斜杠前面只能位置传参，斜杠后面随便！

参数规则

参数列表参数一般顺序是：positional-only参数、普通参数、缺省参数、可变位置参数、keyword-only参数（可带缺省值）、可变关键字参数。

注意：

​ 代码应该易读易懂，而不是为难别人

​ 请按照书写习惯定义函数参数

​ 定义最常用参数为普通参数，可不提供缺省值，必须由用户提供。注意这些参数的顺序，最常用的先定义

​ 将必须使用名称的才能使用的参数，定义为keyword-only参数，要求必须使用关键字传参

​ 如果函数有很多参数，无法逐一定义，可使用可变参数。如果需要知道这些参数的意义，则使用可变关键字参数收集

参数解构

def add( x, y):
    print(x, y)
    return x + y

add(4, 5)
add((4,5)) # 错误，元组相当于单个参数
t = 4,5
add(t[0], t[1])
add(*t)   #带*，解构t
add(*(4, 5))
add(*[4, 5])
add(*{4, 5}) # 解构集合，顺序是不确定的
add(*range(4, 6))
add(*{'a':10,'b':11}) #单个*解构字典，相当于解构key，此处解构错误，函数不期待a,b两个参数
add(**{'a':10,'b':11}) #函数不期待a，b参数
add(**{'x':100, 'y':110}) #解构成功，给x传参100，给y传参110

参数解构：

​ 在给函数提供实参的时候，可以在可迭代对象前使用 * 或者 ** 来进行结构的解构，提取出其中所有元素作为函数的实参

​ 使用 * 解构成位置传参

​ 使用 ** 解构成关键字传参

​ 提取出来的元素数目要和参数的要求匹配

函数返回值

​ Python函数使用return语句返回“返回值”

​ 所有函数都有返回值，如果没有return语句，隐式调用return None

​ return 语句并不一定是函数的语句块的最后一条语句

​ 一个函数可以存在多个return语句，但是只有一条可以被执行。如果没有一条return语句被执行到，隐式调用return None

​ 如果有必要，可以显示调用return None，可以简写为return

​ 如果函数执行了return语句，函数就会返回，当前被执行的return语句之后的其它语句就不会被执行了

​ 返回值的作用：结束函数调用、返回“返回值”

​ 函数不能同时返回多个值

​ return 1, 3, 5 看似返回多个值，隐式的被python封装成了一个元组

​ x, y, z = showlist()使用解构提取返回值更为方便

函数作用域

作用域

一个标识符的可见范围，这就是标识符的作用域。一般常说的是变量的作用域

注意：每一个函数都会开辟一个作用域

作用域分类

全局作用域

​ 在整个程序运行环境中都可见

​ 全局作用域中的变量称为全局变量

局部作用域

​ 在函数、类等内部可见

​ 局部作用域中的变量称为局部变量，其使用范围不能超过其所在局部作用域

​ 也称为本地作用域local

一般来讲外部作用域变量可以在函数内部可见，可以使用

反过来，函数内部的局部变量，不能在函数外部看到

函数嵌套

def outer(): 
    def inner():
        print("inner")
    print("outer")
    inner()
outer() # 可以调用
#结果
outer
inner

inner() # 不可以调用
#结果
Traceback (most recent call last):
  File "C:/Users/Administrator/Desktop/学习笔记/Python/代码/test.py", line 7, in <module>
    inner() # 不可以调用
NameError: name 'inner' is not defined

内部函数inner不能在外部直接使用，会抛NameError异常，因为它在函数外部不可见。

其实，inner不过就是一个标识符，就是一个函数outer内部定义的变量而已

一个赋值语句的问题

1、

x = 1
def test():
    x =x + 1#这句报错，显示本地变量为定义
    y=x+1
    print(x)
test()

2、

x = 1
def test():
    x =100
    y=x+1
    print(x)
test()
#可以运行

3、

x = 1
def test():
    y=x+1
    x =100 #这句报错
    print(x)
test()

总结

只要函数中出现x=变量赋值语句，且此变量不加任何语句的修饰

那么此变量就一定是当前函数的局部变量

在此函数中所有的x都使用内部定义的x

1中报错，是因为x=x+1中，出现了x的赋值行为，而等号后面的x并未找到局部变量的x定义，所以报错

3中报错，是因为x=100，对x进行了赋值行为，所以强制将函数中未加修饰的所有x变量都变成了本地变量，而y=x+1中引用了未定义的本地变量x，所以报错

global语句

对上面1的代码就行修改

x = 1
def test():
    global x
    x =x + 1#此时就不会出错了
    y=x+1
    print(x)
test()

​ 使用global关键字的变量，将foo内的x声明为使用外部的全局作用域中定义的x

​ 全局作用域中必须有x的定义

def foo():
    global x
    x = 10
    x += 1
    print(x)
    
foo()
print(x)

函数中申明了全局变量，对变量的计算影响的就是全局的变量

global使用原则

​ 外部作用域变量会在内部作用域可见，但也不要在这个内部的局部作用域中直接使用，因为函数的目的就是为了封装，尽量与外界隔离

​ 如果函数需要使用外部全局变量，请尽量使用函数的形参定义，并在调用传实参解决

​ 一句话：不用global。学习它就是为了深入理解变量作用域

闭包

自由变量：未在本地作用域中定义的变量。例如定义在内层函数外的外层函数的作用域中的变量

闭包：就是一个概念，出现在嵌套函数中，指的是内层函数引用到了外层函数的自由变量，就形成了闭包。很多语言都有这个概念，最熟悉就是JavaScript

def counter():
    c = [0]

    def inc():
        c[0] += 1  # 因为c为列表，所以可以使用
        return c[0]

    return inc


foo = counter()  
print(foo(), foo())  
c = 100
print(foo())

def counter():
    count = 0
    def inc():
        count += 1 #此时就无法通过，提示本地变量为定义
        return count
    return inc
foo = counter()
print(foo(), foo())

改进

​ 要么使用global使用全局变量，但是也无法使用外层函数中的本地变量

​ 要么使用nonlocal使用外层本地变量，但是无法使用全局变量

def counter():
    count = 0
    def inc():
        nonlocal count
        count += 1
        return count
    return inc
foo = counter()
print(foo(), foo())

nonlocal语句

nonlocal：将变量标记为不在本地作用域定义，而是在上级的某一级局部作用域中定义，但不能是全局作用域中定义

count 是外层函数的局部变量，被内部函数引用。

内部函数使用nonlocal关键字声明count变量在上级作用域而非本地作用域中定义。

代码中内层函数引用外部局部作用域中的自由变量，形成闭包。

默认值的作用域

def foo(xyz=[]):#因为
    print('1、',xyz)
    xyz.append(1)
    print('2、',xyz)

print(id(foo), foo.__defaults__)
foo() 
print('---'*10)
print(id(foo), foo.__defaults__)
foo()
#运行结果为
2564903648520 ([],)
1、 []
2、 [1]
------------------------------
2564903648520 ([1],)
1、 [1]
2、 [1, 1]

​ xyz是局部变量，不可以在函数外访问，这个默认值不可能保存在这个局部变量上

​ 因为函数也是对象，每个函数定义被执行后，就生成了一个函数对象，和函数名这个标识符关联

​ 函数是对象，有属性。python把函数的默认值放在了函数对象的属性中，这个属性就伴随着这个函数对象的整个生命周期

​ 查看foo.__defaults__属性，它是个元组

对比简单类型（简单赋值）和引用类型（列表）

def foo(xyz=[], m=123, n='abc'):
    xyz.append(1)
    m += 20
    n += '+'
    print(xyz, m, n)


print(id(foo), foo.__defaults__)
foo()
print(id(foo), foo.__defaults__)
foo()
print(id(foo), foo.__defaults__)

#运行结果
1920398966024 ([], 123, 'abc')
[1] 143 abc+
1920398966024 ([1], 123, 'abc')
[1, 1] 143 abc+
1920398966024 ([1, 1], 123, 'abc')

​ 函数地址并没有变，就是说foo这个函数对象的没有变过，调用它，它的属性__defaults__中使用元组保存默认值

​ xyz默认值是引用类型，引用类型的元素变动，并不是元组的变化。

​ m、n都是非引用类型，它们保存在缺省值属性元组中，将不能再改变了。

​ 属性__defaults__中使用元组保存所有位置参数默认值，它不会因为在函数体内改变了局部变量（形参）的值而发生改变

def foo(xyz, m=123, *, n='abc', t=[1, 2]):
    m = 456
    n = 'def'
    t.append(300)
    print(xyz, m, n, t)


print(foo.__defaults__, foo.__kwdefaults__)
foo('magedu')
print(foo.__defaults__, foo.__kwdefaults__)
foo('magedu')
print(foo.__defaults__, foo.__kwdefaults__)

#运行结果
(123,) {'n': 'abc', 't': [1, 2]}
magedu 456 def [1, 2, 300]
(123,) {'n': 'abc', 't': [1, 2, 300]}
magedu 456 def [1, 2, 300, 300]
(123,) {'n': 'abc', 't': [1, 2, 300, 300]}

属性__defaults__中使用元组保存所有位置参数默认值

属性__kwdefaults__中使用字典保存所有keyword-only参数的默认值

def x(a=[]):
    a += [5]
    print(a)


print(x.__defaults__)
x()
x()
print(x.__defaults__)
print('---'*10)

def y(a=[]):
    a = a + [5]
    print(a)


print(y.__defaults__)
y()
y()
print(y.__defaults__)

#运行结果
([],)
[5]
[5, 5]
([5, 5],)
------------------------------
([],)
[5]
[5]
([],)

+= 和+的结果是不一样的

​ +表示两个列表合并并返回一个全新的列表

​ +=表示，就地修改前一个列表，在其后追加后一个列表。就是extend方法

对比简单类型和引用类型的+=和+的区别

print('简单类型+=')
x = 1
print(1, id(x), x)
x += 1
print(2, id(x), x)
print('---' * 10)
print('简单类型+')
y = 1
print(1, id(y), y)
y = y + 1
print(2, id(y), y)
print('---' * 10)
#运行结果
简单类型+=
1 1599373424 1
2 1599373456 2
------------------------------
简单类型+
1 1599373424 1
2 1599373456 2
------------------------------


print('引用类型+=')
z = []
print(1, id(z), z)
z += [1]
print(2, id(z), z)
print('---' * 10)
print('引用类型+')
z = []
print(1, id(z), z)
z = z + [1]
print(2, id(z), z)
print('---' * 10)
#运行结果
引用类型+=
1 2818240587400 []
2 2818240587400 [1]
------------------------------
引用类型+
1 2818240587528 []
2 2818240587592 [1]
------------------------------

可以看出

​ 对于普通类型，+和+=没有区别

​ 对于引用类型，

​ z = z + [1]相当于产生了新列表赋给z

​ z += [1]相当于在z中追加

变量名解析原则LEGB

Local，本地作用域、局部作用域的local命名空间。函数调用时创建，调用结束消亡

Enclosing，Python2.2时引入了嵌套函数，实现了闭包，这个就是嵌套函数的外部函数的命名空间

Global，全局作用域，即一个模块的命名空间。模块被import时创建，解释器退出时消亡

Build-in，内置模块的命名空间，生命周期从python解释器启动时创建到解释器退出时消亡。例如print(open)，print和open都是内置的变量

函数的销毁

定义一个函数就是生成一个函数对象，函数名指向的就是函数对象。

可以使用del语句删除函数，使其引用计数减1。

可以使用同名标识符覆盖原有定义，本质上也是使其引用计数减1。

Python程序结束时，所有对象销毁。

函数也是对象，也不例外，是否销毁，还是看引用计数是否减为0

匿名函数

匿名：隐藏名字，即没有名称

匿名函数：没有名字的函数。

def fn(x,y):
    return x+y

可以改写成匿名函数

lambda x, y: x + y

lambda中不能出现=，更不能出现return，多个变量用，隔开，冒号后是一个表达式，表达式的结果是整个函数的返回值

使用匿名函数

print((lambda x, y: x + y)(1, 2))
print((lambda x, y=1: x + y)(x=1, y=2))
print((lambda x=2, y=3: x + y)(1, y=2))

应用

sorted([1,'a',2,'w'],key=lambda x:str(x))
Out[7]: [1, 2, 'a', 'w']

递归函数

递归求斐波那契数列

def fib(n):
    if n == 2 or n == 1:
        return 1
    return fib(n - 1) + fib(n - 2)


print(f'第10个数为{fib(10)}')

查询递归最大深度

import sys

print(sys.getrecursionlimit())
#运行结果
1000

递归要求

​ 递归一定要有退出条件，递归调用一定要执行到这个退出条件。没有退出条件的递归调用，就是无限调用

​ 递归调用的深度不宜过深

​ Python对递归调用的深度做了限制，以保护解释器

​ 超过递归深度限制，抛出RecursionError： maxinum recursion depth exceeded 超出最大深度

​ sys.getrecursionlimit()

对循环进行改进

def fib(n, v1=1, v2=0):
    c = v1 + v2
    # print(c)
    if n == 1 or n == 2:
        return c
    return fib(n - 1, c, v1)


print(f'第10个数为{fib(10)}')
#运行结果
第10个数为55

递推一下

def fib(n, v1=1, v2=0):
    c = v1 + v2
    # print(c)
    return c if n == 1 or n == 2 else fib(n - 1, c, v1)


print(f'第10个数为{fib(10)}')

总结

​ 递归是一种很自然的表达，符合逻辑思维

​ 递归相对运行效率低，每一次调用函数都要开辟栈帧

​ 递归有深度限制，如果递归层次太深，函数连续压栈，栈内存很快就溢出了

​ 如果是有限次数的递归，可以使用递归调用，或者使用循环代替，循环代码稍微复杂一些，但是只要不是死循环，可以多次迭代直至算出结果

​ 绝大多数递归，都可以使用循环实现

​ 即使递归代码很简洁，但是能不用则不用递归

生成器

生成器generator

​ 生成器指的是生成器对象，可以由生成器表达式得到，也可以使用yield关键字编写一个生成器函数，调用这个函数得到一个生成器对象

​ 生成器对象，是一个可迭代对象，是一个迭代器

​ 生成器对象，是延迟计算、惰性求值的

生成器函数

​ 函数体中包含yield语句的函数，就是生成器函数，调用后返回生成器对象

m = (i for i in range(5)) # 生成器表达式
print(type(m))
print(next(m))
print(next(m))
#运行结果
<class 'generator'>
0
1

修改成函数

def inc():  # 生成器函数    
    for i in range(5): 
        yield i
        
print(type(inc))
print(type(inc()))#因为有yield，所以调用函数返回的是一个生成器
#运行结果
<class 'function'>
<class 'generator'>

g = inc()
print(type(g))
print(next(g))
#结果
<class 'generator'>
0

print('--------------------')
for x in g:
    print(x)
print('--------------------')
#结果
--------------------
1
2
3
4
--------------------

for y in g:  #上面已经遍历完，这里已经没有元素了
    print(y)

普通函数调用，函数会立即执行直到执行完毕。

生成器函数调用，并不会立即执行函数体，而是返回一个生成器对象，需要使用next函数来驱动这个生成器对象，或者使用循环来驱动。

生成器表达式和生成器函数都可以得到生成器对象，只不过生成器函数可以写更加复杂的逻辑

生成器函数的执行

def gen():
    print(1)
    yield 2
    print(3)
    yield 4
    print(5)
    return 6
    yield 7#上句已经return了，这句永远不会执行


next(gen())
#结果1
next(gen())
#结果1
#每次调用函数都会生成新的生成器，所以执行结果都为1
g = gen()
print(next(g))
#结果
1
2
#函数中打印1，yield返回2

print(next(g))
#结果
3
4

print(next(g))
#结果
5
#打印完5就报错，return 的6返回到了报错中
Traceback (most recent call last):
  File "C:/Users/Administrator/Desktop/学习笔记/Python/代码/test.py", line 16, in <module>
    print(next(g))
StopIteration: 6
#函数中打印5，return返回6 结束整个生成器函数

print(next(g, 'End'))
#next如果没有值，会报错，如果不想看到报错信息，就在后面加个返回值，例如'end'

在生成器函数中，可以多次yield，每执行一次yield后会暂停执行，把yield表达式的值返回

再次执行会执行到下一个yield语句又会暂停执行

函数返回

​ return语句依然可以终止函数运行，但return语句的返回值不能被获取到

​ return会导致当前函数返回，无法继续执行，也无法继续获取下一个值，抛出StopIteration异常

​ 如果函数没有显式的return语句，如果生成器函数执行到结尾（相当于执行了return None），一样会抛出StopIteration异常

生成器应用

1、无限循环

def counter():
    i = 0
    while True:
        i += 1
        yield i


c = counter()
print(next(c))
print(next(c))
print(next(c))
#执行结果
1
2
3

2、计数器

def inc():
    def counter():
        i = 0
        while True:
            i += 1
            yield i
    c = counter()
    return next(c)


print(inc())
print(inc())
print(inc())
#运行结果
1
1
1

因为返回的是next(c),而c=conuter()函数，以为每次调用完都会销毁，所以相当于每次都重新调用counter函数

利用闭包进行改进

def inc():
    def counter():
        i = 0
        while True:
            i += 1
            yield i

    c = counter()

    def fn():
        return next(c)

    return fn
	#可以将函数fn写成匿名函数、
	#return lambda: next(c)
foo = inc()
print(foo())
print(foo())
print(foo())
#结果
1
2
3

3、斐波那契数列

函数版

def fib():
    a=0
    b=1
    yield b
    while True:
        a,b=b,a+b
        yield b

x=fib()
for i in range(101):
    print(next(x))

改造成闭包

def fib():
    def foo():
        a = 0
        b = 1
        yield b
        while True:
            a, b = b, b + a
            yield b

    c = foo()
   	return lambda : next(c)


x = fib()
for i in range(101):
    print(x())

4 、生成器交互

python提供了一个和生成器对象交互的方法send，该方法可以和生成器沟通

# 重置功能的计数器
def inc():
    def counter():
        i = 0
        while True:
            i += 1
            response = yield i
            if response is not None:
                i = response

    c = counter()
    # def fn(reset=False):
    #     if reset:
    #         c.send(0)
    #     else:
    #         next(c)
    return lambda reset=False: c.send(0) if reset else next(c)


foo = inc()
print(foo())
print(foo())
print(foo())
print('---'*10)
print(foo(True))
print(foo())
print(foo())
print(foo())
#运行结果
1
2
3
------------------------------
1
2
3
4

send可以给yield发送参数

调用send方法，就可以把send的实参传给yield语句做结果，这个结果可以在等式右边被赋值给其它变量

send和next一样可以推动生成器启动并执行

yield from语法

从Python 3.3开始增加了yield from语法，使得yield from iterable等价于for item in iterable: yield item。

yield from就是一种简化语法的语法糖

def inc():
    for x in range(1000):
        yield x


# 使用yield from 简化
def inc():
    yield from range(1000)  # 注意这个函数出现了yield，也是生成器函数


foo = inc()
print(next(foo))
print(next(foo))
print(next(foo))

本质上yield from的意思就是，从from后面的可迭代对象中拿元素一个个yield出去