函数
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