函数
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出去
标签：return,函数,python,生成器,参数,print,foo,def From： https://www.cnblogs.com/guangdelw/p/16946056.html