函数是结构化编程的核心。
函数可以提高代码的模块化和重复利用率。
1、函数的定义和调用
使用def语句定义函数。
def 函数名([参数1, 参数2, ...]):
函数体示例：
import random
def generate_random(): #定义函数，无参数
for i in range(10):
ran = random.randint(1, 20)
print(ran)
print(generate_random) #打印函数名：<function generate_random at 0x000001F03C2254C0>
generate_random() #调用函数，函数名后必须有小括号，代表引用函数体。2、函数的参数
- 在def语句中，位于函数名后面的变量称为形参，而调用函数时提供的值称为实参。
2.1、位置参数
- 位置参数：实参和形参数量一致，且一一对应。
- 参数的位置至关重要。
def 函数名(参数1, 参数2, ...):
函数体示例：
def add(a, b): #a和b是形参。形参可以有多个
sum1 = a + b
print('a + b =', sum1)
add(1, 3) #1和3是实参。实参要和形参数量一致，且一一对应
'''
定义一个登录函数，参数是username、password。
判断参数传过来的值是否正确，如果正确就打印登录成功，否则打印登录失败。
'''
def login(username, password):
name = 'admin'
pwd = '123456'
if name == username and pwd == password:
print('登录成功')
else:
print('登陆失败')
login('admin', '123456')练习：
2.2、关键字参数
- 关键字参数：使用名称指定的参数。
- 关键字参数最大的优点在于，可以指定默认值。
- 位置参数和关键字参数可以混合使用，但必须先指定所有的位置参数（位置参数必须在前面），否则解释器将不知道它们是哪个参数（即不知道参数对应的位置）。
- 通常不应混合使用位置参数和关键字参数
def func(a, b, c=6): #混合使用位置参数和关键字参数
print('a = {}, b = {}, c = {}'.format(a, b, c))
func(1, 2) #结果是：a = 1, b = 2, c = 6。位置参数必须传递实参，关键字参数可以使用默认值
func(b=2, a=1) #结果是：a = 1, b = 2, c = 6。关键字参数的位置不重要
func(1, 2, 3) #结果是：a = 1, b = 2, c = 3
func(1, 2, c=3) #结果是：a = 1, b = 2, c = 3。2.3、收集参数（装包）
- 有时候要允许用户提供任意数量的参数。
- 收集参数：定义函数时使用运算符*实现。
1、单星号(*)
- 单星号收集多余的位置参数，并存放进一个元组中。如果没有多余的位置参数，元组将是一个空元组。
- 单星号不会收集关键字参数。
def func(a, *b, c):
print('a = {}, b = {}, c = {}'.format(a, b, c))
func(1, c=2) #结果是：a = 1, b = (), c = 2。要使用关键字参数指定后面的参数
func(1, 2, c=3) #结果是：a = 1, b = (2,), c = 3。
func(1, 2, 3, 4, c=6) #结果是：a = 1, b = (2, 3, 4), c = 6。
# func(1, b=2, c=3) #报错2、双星号(**)
- 双星号仅收集多余的关键字参数，并存放进一个字典中。没有多余的将是一个空字典。
- 定义函数时，双星号参数变量必须放在最后，即在无星号和单星号参数变量之后。
def func(a, b, **c):
print('a = {}, b = {}, c = {}'.format(a, b, c))
func(1, b=2) #结果是：a = 1, b = 2, c = {}
func(1, 2, c=3, d=4) #结果是：a = 1, b = 2, c = {'c': 3, 'd': 4}3、单双星号结合使用
def func(a, b, c=6, *d, **e):
print('a = {}, b = {}, c = {}, d = {}， e = {}'.format(a, b, c, d, e))
func(1, 2) #结果是：a = 1, b = 2, c = 6, d = ()， e = {}
func(1, 2, 3) #结果是：a = 1, b = 2, c = 3, d = ()， e = {}
func(1, 2, c=3, d=4) #结果是：a = 1, b = 2, c = 3, d = ()， e = {'d': 4}。以但有星号后就与名称无关了，只是用于收集多余的位置参数或关键字参数
func(1, 2, 3, 4, d=4) #结果是：a = 1, b = 2, c = 3, d = (4,)， e = {'d': 4}。要使*d接收到值，c只能使用位置参数的形式2.4、分配参数（拆包）
- 分配参数：调用函数（而不是定义函数）时使用运算符*实现。
- 如果在定义和调用函数时都使用*或**，将只传递序列或字典。一般不建议这样使用。
- 只有在定义函数（允许可变数量的参数）或调用函数时（拆分字典或序列）使用，星号才能发挥作用。
1、单星号(*)
- 实参只能是序列。
def func(a, b, *c):
print('a = {}, b = {}, c = {}'.format(a, b, c))
hh = [1, 2]
func(*hh) #结果是：a = 1, b = 2, c = ()。传递一个列表，相当于func(1,2)
hh = [1, 2, 3]
func(*hh) #结果是：a = 1, b = 2, c = (3,)。相当于func(1,2,3)
hh = (1,2)
func(*hh) #结果是：a = 1, b = 2, c = ()。传递一个元组,相当于func(1,2)
hh = 'abcd'
func(*hh) #结果是：a = a, b = b, c = ('c', 'd')。传递一个字符串,相当于func('a','b','c','d')2、双星号(**)
- 实参只能是字典。
def func(a, b, **c):
print('a = {}, b = {}, c = {}'.format(a, b, c))
hh = {'a': 1, 'b': 2}
func(**hh) #结果是：a = 1, b = 2, c = {}。相当于func(a=1,b=2)
hh = {'a': 1, 'b': 2, 'c': 3}
func(**hh) #结果是：a = 1, b = 2, c = {'c': 3}。相当于func(a=1,b=2,c=3)
hh = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
func(**hh) #结果是：a = 1, b = 2, c = {'c': 3, 'd': 4}。3、定义和调用都使用星号
def func(a, *b, **c):
print('a = {}, b = {}, c = {}'.format(a, b, c))
hh = {'b': 2, 'c': 3, 'd': 4}
gg = [1, 2, 3]
func(*gg) #结果是：a = 1, b = (2, 3), c = {}
# func(**hh) #报错
func(3, **hh) #结果是：a = 3, b = (), c = {'b': 2, 'c': 3, 'd': 4}
func(*gg, **hh) #结果是：a = 1, b = (2, 3), c = {'b': 2, 'c': 3, 'd': 4}
func(3, 4, *gg, **hh) #结果是：a = 3, b = (4, 1, 2, 3), c = {'b': 2, 'c': 3, 'd': 4}
func(3, 4, gg, **hh) #结果是：a = 3, b = (4, [1, 2, 3]), c = {'b': 2, 'c': 3, 'd': 4}
func(3, 4, *gg, hh) #结果是：a = 3, b = (4, 1, 2, 3, {'b': 2, 'c': 3, 'd': 4}), c = {}3、函数的返回值
- 按是否有返回值，函数可分为两类：
- 有返回值的是真正意义上的函数，称为函数。
- 没有返回值的函数是不是函数的函数，称为过程式函数。
3.1、有返回值的函数
- 函数执行特定的操作并通过return返回一个值（可以是任意值，即返回什么由你决定）。
- return语句非常重要。
- 一是return语句用于从函数返回值，
- 二是return语句可以提前结束函数。
1、一个返回值的函数
def add(a, b):
sum = a + b
return sum #返回一个值
hh = add(3, 4)
print(hh) #结果是：72、多个返回值的函数
- 要返回多个返回值时，它们将被放到一个元组中，并返回这个元组。
def add(a, b):
sum = a + b
return sum, a, b, 'jhahfdah' #返回多个值
hh = add(3, 4)
print(hh) #结果是：(7, 3, 4, 'jhahfdah')。3、return语句结束函数
def add(a, b):
if a==0:
return '第一个变量是零'
sum = a + b
return sum
hh = add(0, 4)
print(hh) #结果是：第一个变量是零3.2、无返回值的函数：过程式函数
- 在Python中，什么都不返回的函数也是函数，即使它严格来说并非函数。
- 一是不包含return语句。
- 二是包含return语句，但没有在return后面指定值。
- 所有的函数都返回值。如果你没有告诉它们该返回什么，将返回None。
###示例1
def add(a, b):
sum = a + b
hh = add(0, 4)
print(hh) #结果是：None
###示例2
def add(a, b):
sum = a + b
return
hh = add(0, 4)
print(hh) #结果是：None4、变量作用域
4.1、作用域
- 每一个被声明的变量都存放在一个“看不见”的字典中，内置函数vars可以返回这个不可见的字典。
- 这种“看不见的字典”称为命名空间或作用域。
LEGB
- Python有很多名字空间，而 LEGB 则是名字空间的一种查找规则。
- LEGB 代表名字查找顺序: locals --> enclosing function --> globals --> __builtins__
- locals 是函数内的名字空间，包括局部变量和形参
- enclosing 外部嵌套函数的名字空间（闭包中常见）
- globals 全局变量，函数定义所在模块的名字空间
- builtins 内置模块的名字空间
>>> x = 1
>>> scope = vars()
>>> scope['x']
1
>>> x = 'maiheng'
>>> scope['x']
'maiheng'
>>> vars() #返回这个不可见的字典
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'x': 'maiheng', 'scope': {...}}- 除全局作用域外，每个函数调用都将创建一个局部作用域。
def func1():
x = 3
y = 4
print('func1的作用域：', vars())
def func2():
x = 5
y = 6
print('func2的作用域：', vars())
x = 1
y = 2
print('全局作用域：', vars())
func1()
func2()
<<<
全局作用域： {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001A7030B0910>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/test/python/day/test.py', '__cached__': None, 'func1': <function func1 at 0x000001A7032954C0>, 'func2': <function func2 at 0x000001A7032955E0>, 'x': 1, 'y': 2}
func1的作用域： {'x': 3, 'y': 4}
func2的作用域： {'x': 5, 'y': 6}4.2、函数使用全局变量和局部变量
- 全局变量：不是函数中的变量，就是全局变量。
- 局部变量：在函数内使用的变量称为局部变量。函数的参数类似局部变量。作用范围仅在当前函数中
- 在函数中使用或修改不可变类型的全局变量（数、字符串、元组）时，必须先用global声明。
- 在函数中使用或修改可变类型的全局变量（列表、字典、集合和类式）时，不必用global声明。
- 局部变量和全局变量同名时，在函数中局部变量生效。
1、修改不可变类型的变量（数、字符串、元组）
def func():
global x, y, z #要修改全局变量，先有global声明
x += 4
y += 'ha'
z += (4, 5, 6)
print('func的作用域：', vars())
print('x = {}, y = {}, z={}'.format(x, y, z))
x = 1
y = 'heng'
z = (1, 2, 3)
print('全局作用域：', vars())
print('x = {}, y = {}, z={}'.format(x, y, z))
func()
print('全局作用域：', vars())
print('x = {}, y = {}, z={}'.format(x, y, z))
<<<
全局作用域： {..., 'x': 1, 'y': 'heng', 'z': (1, 2, 3)} #全局作用域略写了
x = 1, y = heng, z=(1, 2, 3)
func的作用域： {}
x = 5, y = hengha, z=(1, 2, 3, 4, 5, 6)
全局作用域： {..., 'x': 5, 'y': 'hengha', 'z': (1, 2, 3, 4, 5, 6)}
x = 5, y = hengha, z=(1, 2, 3, 4, 5, 6)2、修改可变类型的变量（列表、字典、集合和类式）
def func():
a[2] = 10
b['y'] = 10
print('func的作用域：', vars())
print('a = {}, b = {}'.format(a, b))
a = [1, 2, 3]
b = {'x': 1, 'y': 2, 'z': 3}
print('全局作用域：', vars())
print('a = {}, b = {}'.format(a, b))
func()
print('全局作用域：', vars())
print('a = {}, b = {}'.format(a, b))
<<<
全局作用域： {..., 'a': [1, 2, 3], 'b': {'x': 1, 'y': 2, 'z': 3}}
a = [1, 2, 3], b = {'x': 1, 'y': 2, 'z': 3}
func的作用域： {}
a = [1, 2, 10], b = {'x': 1, 'y': 10, 'z': 3}
全局作用域： {..., 'a': [1, 2, 10], 'b': {'x': 1, 'y': 10, 'z': 3}}
a = [1, 2, 10], b = {'x': 1, 'y': 10, 'z': 3}3、局部变量遮住全局变量
def func():
x = 4 #局部变量和全局变量同名时，在函数中局部变量生效。函数中没有声明变量y，全局变量y生效
z = (4, 5, 6)
print('func的作用域：', vars())
print('x = {}, y = {}, z={}'.format(x, y, z))
x = 1
y = 'heng'
z = [1, 2, 3]
print('全局作用域：', vars())
print('x = {}, y = {}, z={}'.format(x, y, z))
func()
<<<
全局作用域： {..., 'x': 1, 'y': 'heng', 'z': [1, 2, 3]}
x = 1, y = heng, z=(1, 2, 3)
func的作用域： {'x': 4, 'z': (4, 5, 6)}
x = 4, y = heng, z=(4, 5, 6)4、解决遮住问题
- 必要时可以在函数中使用“globals()['全局变量名']”来访问全局变量。
- globals()内置函数，查看全局变量，以字典的形式输出（包含一些系统内置的变量）
- locals()内置函数，查看本地变量，以字典的形式输出。
def combine(hh2):
hh1 = 'hh3 ' #局部变量hh1,形参hh2
print(globals()['hh1'] + hh1 + globals()['hh2'] + hh2)
hh1 = 'hh1-'
hh2 = 'hh2-'
combine('hh4')5、内部函数（套嵌函数）
- 内部函数：在函数中声明的函数。
- 内部函数可以访问外部函数的变量。
- 内部函数修改外部函数中可变类型的变量，不用nonlocal提前声明。
- 内部函数修改外部函数中不可变类型的变量，要用nonloca提前声明。
- 内部函数修改全局变量中可变类型的变量，不用global提前声明。
- 内部函数修改全局变量中不可变类型的变量，要用global提前声明。
def func():
n = 100 #声明一个不可变类型的变量
list1 = [9, 1, 7, 3, 8] #声明一个可变类型的变量
def in_func(): #声明内部函数
nonlocal n #修改外部不可变类型的变量要用nonlocal提前声明，
global a #修改全局不可变类型的变量要用global提前声明
for index, i in enumerate(list1):
list1[index] = i + n #修改外部可变
for index, i in enumerate(b):
b[index] = i + n #修改全局可变
n += 11
a += 11
in_func() #调用内部函数
print('list1是：{}, n是：{}, b是：{}, a是：{}'.format(list1, n, b, a))
a = 10 #声明一个全局不可变类型的变量
b = [1, 7, 2, 9, 4] #声明一个全局可变类型的变量
func() #结果是：list1是：[109, 101, 107, 103, 108], n是：111, b是：[101, 107, 102, 109, 104], a是：216、闭包
- 闭包：是个嵌套函数（在外部函数中声明一个内部函数），内部函数中引用外部函数的变量，且外部函数的返回值是内部函数名。
- 闭包是特殊的内部函数
def func(a):
def in_func(b):
print('a是:{}, b是：{}'.format(a, b))
print(locals())
return in_func
x = func(10) #结果是：{'in_func': <function func.<locals>.in_func at 0x00000243C5B755E0>, 'a': 10}。将内部函数的内存地址引用赋值给x
print(x) #结果是：<function func.<locals>.in_func at 0x00000243C5B755E0>
x(20) #结果是：a是:10, b是：20- 闭包的作用之一，保存参数的状态。
def func(a, b):
def in_func(c):
sum = a + b + c
print('{} + {} + {} = {}'.format(a, b, c, sum))
print(locals())
return in_func
x1 = func(10, 20) #将外部函数的返回值--内部函数地址赋值给x1。 结果是：{'in_func': <function func.<locals>.in_func at 0x00000232BB5755E0>, 'a': 10, 'b': 20}。
x2 = func(100, 200) #每次引用内部函数都会开辟新的内存空间。 结果是：{'in_func': <function func.<locals>.in_func at 0x00000232BB575550>, 'a': 100, 'b': 200}
x2(300) #结果是：100 + 200 + 300 = 600
x1(30) #结果是：10 + 20 + 30 = 60示例：闭包之计数器
def generate_count():
container = [0]
def add_one():
container[0] = container[0] + 1
print('当前是第{}访问'.format(container[0]))
return add_one
counter = generate_count()
counter() #结果是：当前是第1访问
counter() #结果是：当前是第2访问
counter() #结果是：当前是第3访问示例：闭包之同级调用、内部函数的返回值
def func():
a = 100
def in_func1():
b = 200
sum = a + b
print('a + b =',sum)
def in_func2():
in_func1()
return '我是第二个内部函数' #内部函数的返回值
return in_func2 #外部函数的返回值
x = func() #将内部函数in_func2的内存引用赋值给x
y = x() #将内部函数in_func2的返回值赋值给y。 结果是：a + b = 300
print(y) # 结果是：我是第二个内部函数7、装饰器
- 装饰器：拥有闭包的特点，且只接受函数为参数。
- 装饰器是闭包，且将被装饰的函数当作实参。
- 在内部函数中调用以参数传进来的被装饰函数。
- 装饰器不改变原函数，也不改变原函数的调用方式，就可以给原函数添加新功能。
- 装饰器是特殊的闭包。
- 装饰器是python2.4引入的新语法，装饰器可用于包装任何可调用的对象，并且可用于函数和方法（类中的函数）。
7.1、装饰器的定义和使用
###定义装饰器
def 装饰器名(func): #第一层函数用于接收被装饰的函数
...
def 内部函数名(): #第二层函数用于接收被装饰函数的参数
...
func()
return 内部函数名
###使用装饰器
@装饰器名 #在程序执行到“@装饰器”和“def 被装饰函数名():”时，python解释器会自动在后台做：
def 被装饰函数名(): #1、将“被装饰函数名”当参数传递给装饰器，并调用(执行)装饰器。
... #2、将装饰器的返回值（内部函数引用的内存地址）赋值给“被装饰函数名”
###调用被装饰函数
被装饰函数名() #此时“被装饰函数名”引用的内存地址是装饰器内部函数的，而不是它自己的了示例：
def decorate(func): #声明装饰器
def in_decorate():
print("八戒在吃自己的人参果...")
print('八戒向猴哥讨要人参果，猴哥掂这八戒的大耳朵说“呆子，滚...”')
func()
print(func) #打印被装饰函数自己引用的内存地址：<function bajie at 0x0000029317E55550>
return in_decorate
@decorate #使用装饰器
def bajie(): #声明被装饰函数
print('八戒伤心的哭了...')
bajie() #调用被装饰函数
print(bajie) #打印被装饰后的被装饰函数引用的内存地址：<function decorate.<locals>.in_decorate at 0x0000029317E55670>
<<<
八戒在吃自己的人参果...
八戒向猴哥讨要人参果，猴哥掂这八戒的大耳朵说“呆子，滚...”
八戒伤心的哭了...
<function bajie at 0x0000029317E55550>
<function decorate.<locals>.in_decorate at 0x0000029317E55670>
def decorate(func):
def in_decorate():
print("八戒在吃自己的人参果...")
print('八戒向猴哥讨要人参果，猴哥掂这八戒的大耳朵说“呆子，滚...”')
func()
return in_decorate
@decorate
def bajie():
print('八戒伤心的哭了...')
bajie()
<<<
八戒在吃自己的人参果...
八戒向猴哥讨要人参果，猴哥掂这八戒的大耳朵说“呆子，滚...”
八戒伤心的哭了...View Code
7.2、被装饰函数的参数
1、参数传递的两步
- 调用被装饰函数时，此时“被装饰函数名”引用的内存地址是装饰器内部函数的，即此时的"被装饰函数名"就是装饰器内部函数，因此参数会直接传递给装饰器内部函数。
- 装饰器内部函数得到此参数后，再传递给在其内部的原被装饰函数
def decorate(func):
def in_decorate(x): #内部函数又将参数传递给原被装饰函数
print("八戒在吃自己的人参果...")
print('八戒向猴哥讨要人参果，猴哥掂这八戒的大耳朵说“呆子，滚...”')
func(x)
return in_decorate
@decorate
def bajie1(s):
print('八戒伤心的哭{}天了...'.format(s))
@decorate
def bajie2(lst):
print('八戒伤心的哭了...')
for i in lst:
print('八戒喊来了%s，要他替自己做主。' % i)
n = 9
bajie1(n) #传递一个整型作为参数。此时将参数传递给装饰器内部函数
list1 = ['师傅', '观音', '如来']
bajie2(list1) #传递一个列表作为参数
<<<
八戒在吃自己的人参果...
八戒向猴哥讨要人参果，猴哥掂这八戒的大耳朵说“呆子，滚...”
八戒伤心的哭9天了...
八戒在吃自己的人参果...
八戒向猴哥讨要人参果，猴哥掂这八戒的大耳朵说“呆子，滚...”
八戒伤心的哭了...
八戒喊来了师傅，要他替自己做主。
八戒喊来了观音，要他替自己做主。
八戒喊来了如来，要他替自己做主。2、万能装饰器
- 只要是装饰器，一般都是这种万能装饰器。
def decorate(func):
def in_decorate(*args, **kwargs): #装包，必须有*args和**kwargs
print("八戒在吃自己的人参果...")
print('八戒向猴哥讨要人参果，猴哥掂这八戒的大耳朵说“呆子，滚...”')
func(*args, **kwargs) #拆包，必须有*args和**kwargs
return in_decorate
@decorate
def bajie1():
print('八戒伤心的哭了...')
@decorate
def bajie2(s):
print('八戒伤心的哭{}天了...'.format(s))
@decorate
def bajie3(lst, t=99):
print('八戒伤心的哭%d了...' % t)
for i in lst:
print('八戒喊来了%s，要他替自己做主。' % i)
bajie1() #调用时，使用无参数
n = 9
bajie2(n) #调用时，使用单个参数
list1 = ['师傅', '观音', '如来']
bajie3(list1, t=33) #调用时，使用关键字参数
<<<
八戒在吃自己的人参果...
八戒向猴哥讨要人参果，猴哥掂这八戒的大耳朵说“呆子，滚...”
八戒伤心的哭了...
八戒在吃自己的人参果...
八戒向猴哥讨要人参果，猴哥掂这八戒的大耳朵说“呆子，滚...”
八戒伤心的哭9天了...
八戒在吃自己的人参果...
八戒向猴哥讨要人参果，猴哥掂这八戒的大耳朵说“呆子，滚...”
八戒伤心的哭33了...
八戒喊来了师傅，要他替自己做主。
八戒喊来了观音，要他替自己做主。
八戒喊来了如来，要他替自己做主。7.3、多层装饰器
- 当一个被装饰函数有多个装饰器时，先使用离得最近的装饰器，然后依次使用较近的装饰器。
def zhuang1(func): #声明第一个装饰器
print('--------> start1')
def in_1():
func() #2、这个func()就是zhuang()
print('--------> 铺地板')
print('--------> stop1')
return in_1
def zhuang2(func): #声明第二个装饰器
print('--------> start2')
def in_2():
func() #4、这个func()就是ni_1
print('--------> 买家具')
print('--------> stop2')
return in_2
@zhuang2 #离得较远的最后使用。 #3、将zhuang（此时的zhuang是in_1）作为参数传递给zhuang2,并将in_2赋值给zhuang
@zhuang1 #先使用离得最近的装饰器。 #1、将zhuang作为参数传递给zhuang1,并将in_1赋值给zhuang
def zhuang():
print('--------> 毛胚房')
zhuang() #5、调用zhuang，此时的zhuang是in_2
<<<
--------> start1
--------> stop1
--------> start2
--------> stop2
--------> 毛胚房
--------> 铺地板
--------> 买家具7.4、装饰器的参数
- 装饰器如果要带参数，装饰器外面就要再嵌套一层函数，用于接收装饰器的参数，即一共有三层函数。
1、不带参数的装饰器
def banzhuan(func): #第一层函数用于接收被装饰的函数
def in_banzhuan(*args, **kwargs): #第一层函数用于接收被装饰函数的参数
func(*args, **kwargs)
print('现在已经在铺设地板啦。。。')
return in_banzhuan
@banzhuan
def maopei(time):
print('{}买了这个毛胚房'.format(time))
maopei('2021-02-17')
<<<
2021-02-17买了这个毛胚房
现在已经在铺设地板啦。。。2、带参数的装饰器
def canshu(a): #第一层函数用于接收装饰器的参数
def banzhuan(func): #第二层函数用于接收被装饰的函数
def in_banzhuan(*args, **kwargs): #第三层函数用于接收被装饰函数的参数
func(*args, **kwargs)
print('已经铺设%d地板啦。。。' % a)
return in_banzhuan #在第二层函数中返回第三层的函数名
return banzhuan #在第一层函数中返回第二层的函数名
@canshu(100) #使用装饰器时，用的是第一层的函数名
def maopei(time):
print('{}买了这个毛胚房'.format(time))
@canshu(10000)
def road():
print('这是一条新修的小路')
maopei('2021-02-17')
road()
<<<
2021-02-17买了这个毛胚房
已经铺设100地板啦。。。
这是一条新修的小路
已经铺设10000地板啦。。。8、匿名函数
- 匿名函数简化函数的声明。
- 有些函数在代码中只用一次，且函数体比较简单，使用匿名函数可以减少代码量。
8.1、声明匿名函数
###使用关键字lambda声明匿名函数
函数名 = lambda 参数1,参数2...:返回值 #返回值是表达式示例1：
add = lambda x, y: x + y #声明匿名函数
s = add(3, 5) #调用匿名函数
print(s) #结果是：8示例2：三元运算
calc = lambda x, y: x * y if x > y else x / y
print(calc(2, 5)) #结果是：0.4
print(calc(5, 2)) #结果是：108.2、匿名函数的使用场景
- 匿名函数主要和内置函数联合使用
1、map(function, sequence, ...)
- 内置函数map()有两个参数，一个是函数func，一个是序列，map将序列中的每个元素依次传入函数func中，并将结果返回到新的序列中。
示例1：
# 一般函数
list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
for index, val in enumerate(list1):
list1[index] = val * val
print(list1) #结果是：[1, 4, 9, 16, 25, 36, 49, 64, 81]
# 匿名函数
list2 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
list2 = (map(lambda x: x * x, list2))
print(list(list2)) #结果是：[1, 4, 9, 16, 25, 36, 49, 64, 81]示例2：
list1 = [1, 3, 2, 6, 3, 8, 9, 5, 0]
result = map(lambda x: x if x % 2 == 0 else x + 1, list1)
print(list(result)) #结果是：[2, 4, 2, 6, 4, 8, 10, 6, 0]2、max(*args, key=None)
- 内置函数max()，返回最大值。
示例：
###离散值
max1 = max(3, 6, 1, 10, 44, 33)
print(max1) #结果是：44
###序列
list1 = [3, 6, 1, 10, 44, 33]
max2 = max(list1)
print(max2) #结果是：44
###字典，比较复杂的数据需要指定以那个字段作比较
dict1 = [{'name': 'mai1', 'age': 55}, {'name': 'mai2', 'age': 33}, {'name': 'mai3', 'age': 77}, {'name': 'mai3', 'age': 11}, {'name': 'mai5', 'age': 22}]
max3 = max(dict1,key=lambda x:x['age'])
print(max3) #结果是：{'name': 'mai3', 'age': 77}3、filter(function, sequence)
- 内置函数filter()有两个参数，一个是函数func，一个是序列，filter将序列中的每个元素依次传入函数func中，并根据返回结果决定是否该元素放进新的列表中。
###列表
list1 = [22, 55, 33, 1, 4, 22, 7, 99]
list2 = filter(lambda x: x > 10, list1)
print(list(list2)) #结果是：[22, 55, 33, 22, 99]
###字典
dict1 = [{'name': 'mai1', 'age': 55}, {'name': 'mai2', 'age': 33}, {'name': 'mai3', 'age': 77}, {'name': 'mai3', 'age': 11}, {'name': 'mai5', 'age': 22}]
dict2 = filter(lambda x: x['age'] > 22, dict1)
print(list(dict2)) #结果是：[{'name': 'mai1', 'age': 55}, {'name': 'mai2', 'age': 33}, {'name': 'mai3', 'age': 77}]4、sorted(iterable[, cmp][, key][, reverse])
- 返回一个排序后的列表，其中的元素来自iterable（可迭代对象）。可选参数与列表的方法sort相同
###列表
list1 = [22, 55, 33, 1, 4, 22, 7, 99]
list2 = sorted(list1)
print(list(list2)) #结果是：[1, 4, 7, 22, 22, 33, 55, 99]
###字典
dict1 = [{'name': 'mai1', 'age': 55}, {'name': 'mai2', 'age': 33}, {'name': 'mai3', 'age': 77}, {'name': 'mai3', 'age': 11}, {'name': 'mai5', 'age': 22}]
dict2 = sorted(dict1, key=lambda x: x['age'])
print(dict2) #结果是：[{'name': 'mai3', 'age': 11}, {'name': 'mai5', 'age': 22}, {'name': 'mai2', 'age': 33}, {'name': 'mai1', 'age': 55}, {'name': 'mai3', 'age': 77}]5、reduce函数
- reduce(func, seq[, initial])等价于func(func(func(seq[0], seq[1]), seq[2]), ...)
from functools import reduce
tuple1 = (1, 4, 2, 5, 9, 3)
tuple2 = reduce(lambda x, y: x + y, tuple1)
print(tuple2) #结果是：249、递归函数
- 在函数内部，可以调用其他函数。如果一个函数在内部调用自己，这个函数就是递归函数。
- 基线条件（针对最小的问题）：满足这种条件时函数将直接返回一个值。（必须有一个结束条件）
- 递归条件：包含一个或多个调用，这些调用旨在解决问题的一部分。
示例1：求n以内的正整数之和
def add(n):
if n == 0:
return 0
else:
return n + add(n - 1)
sum = add(100)
print(sum) #结果是：5050示例2、求n以内的正整数的阶乘
def factorial(n):
if n == 1:
return 1
else:
return n * factorial(n - 1)
ss =factorial(10)
print(ss) #结果是：3628800示例3：求x的n次幂
def power(x, n):
if n == 0:
return 1
else:
return x * power(x, n - 1)
ss = power(2, 10)
print(ss) #结果是：1024
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
