1、 匿名函数lambda的使用
问题1：定义函数时首先先想一个函数的名字，最好与内置函数、内置方法不重名
问题2：若一个函数的功能很简单，就两行代码，我还写一个完整的函数
这两个问题都可以通过匿名函数解决
匿名函数：顾名思义就是没有名字的函数，这种函数只使用一次，一般函数体只有一条语句一个返回值，用于实现简单功能。
语法格式
lambda 参数1, 参数2, 参数3, .... : 表达式
print((lambda x:x+2)(2))
fun1 = lambda x : x+2
print(fun1(4))
fun2 = lambda : print("我是匿名函数")
fun2()
fun3 = lambda : 3
print(fun3())
fun4 = lambda *num : sum(num)
print(fun4(1,2,3,4,5))
fun5 = lambda **stus : stus
print(fun5(zhangsan=18, lisi=20, wangwu=19))
fun6 = lambda a,b=1 : a+b
print(fun6(3))
print(fun6(3,8))
# 使用匿名函数接收两个参数a和b，返回a、b的较大值
fun7 = lambda a, b: max(a,b)
print(fun7(10,20))
# python中的三元运算符
# 结果1 if 条件 else 结果2
fun8 = lambda a, b : a if a>b else b
print(fun8(13,10))lambda函数的特性
- lambda函数是匿名的，即它是没有名字的函数，并且自带return。
- lambda函数可以使用任意数量的参数，但只能包含一个表达式。
- lambda函数返回一个值，这个值就是表达式的结果。
- lambda函数的生命周期很短，调用后立即被回收。
2、高阶函数
数学中的高阶函数：y = g(f(x))
Python中的高阶函数：将一个或多个函数作为函数的参数
2.1 map 函数
用于将一个函数应用到一个序列的每一个元素，并返回一个包含结果的迭代器。
map语法格式：
map(函数，可迭代对象)
input_num = (1,2,3,4,5)
# 内置函数：str() int() float()
ret = map(str, input_num)
print(ret)
print(list(ret))
ls = [1,2,3,4,5]
ret = list(map(lambda x : x*10, ls))
print(ret)
2.2 reduce函数
reduce 函数用于对序列进行累计运算，它通常需要从 functools 模块中导入
reduce语法格式：
from functools import reduce
reduce(函数，可迭代对象)
from functools import reduce
ls = [1,2,3,4,5]
ret_sum = reduce(lambda x, y: x+y, ls)
print(ret_sum)
ret_pro = reduce(lambda x, y: x*y, ls)
print(ret_pro)2.3 filter函数
用于遍历序列中的每个元素，根据条件进行筛选，返回一个包含被筛选后结果的迭代器。
filter语法格式：
filter(函数, 可迭代对象)
import random
ls = [random.randint(10,30) for _ in range(10)]
print(ls)
ret = filter(lambda x : x%2==0, ls)
print(ret)
print(list(ret))2.4 排序函数
menu = [['h红烧牛肉面', 18], ['x香辣牛肉面', 16], ['a安徽板面', 15], ['c重庆小面', 20]]
# 排序
menu.sort()
print(menu)
# 按单价排序 —— itemgetter——获取多维数组中某个维度的元素值
import operator
menu.sort(key=operator.itemgetter(1), reverse=True)
print(menu)
# 按单价排序 —— 使用匿名函数
menu.sort(key=lambda x:x[1], reverse=False)
print(menu)3、装饰器⭐（重难点）
3.1 装饰器的概念
在python中，装饰器本质是一个特殊的嵌套函数，它接收一个函数【被装饰的函数】做参数，并返回一个新的函数【装饰后的函数】
装饰器的最大作用：在不改变原有函数【被装饰的函数】的基础上给它添加新的功能
# 装饰器
def out_fun(function):
def in_fun():
print("挂上一颗星星")
function()
print("挂上一个礼物盒")
return in_fun
# 被装饰函数
def my_tree():
print("简简单单一棵树")
# 第一种调用方式
out_fun(my_tree)()
# 问：第一种调用方式，被装饰函数真的装饰了吗
my_tree() # 并没有新增功能
# 第二种调用方式
my_tree = out_fun(my_tree)
# 问：第二种调用方式，被装饰函数真的装饰了吗
my_tree()3.3 装饰器语法糖
语法糖是由编程语言提供的，可以让代码更加简洁、高效、易读和易写。语法糖不改变不会带来新的功能，也不会改变编程的结果，但是使用它会更加方便。
python中有很多语法糖，已用的有：
- 列表推导式
- 集合推导式
- 字典推导式
- f-string print(f"{}")
- 解包
- 装饰器
语法格式：
@装饰器函数名
def 被装饰函数名:
代码块
其实就是在被装饰函数的上面加一句话——@装饰器
# 装饰器
def out_fun(function):
def in_fun():
print("挂上一颗星星")
function()
print("挂上一个礼物盒")
return in_fun
# 被装饰函数
@out_fun
def my_tree():
print("简简单单一棵树")
my_tree()3.4 被装饰函数有参数
若被装饰函数有参数，那么装饰器的内部函数也需要有参数，保证在内部调用被装饰函数的时候能正确传参。
3.4.1 被装饰函数有一个参数
# 装饰器
def out_fun(function):
def in_fun(x):
print("挂上一颗星星")
function(x)
print("挂上一个礼物盒")
return in_fun
# 被装饰函数
@out_fun
def my_tree(x):
print(f"简简单单{x}棵树")
my_tree(3)3.4.2 被装饰函数有未知个参数
import time
# 装饰器
def out_fun(function):
def in_fun(*args, **kwargs):
start = time.time()
function(*args, **kwargs)
end = time.time()
print(end - start)
return in_fun
# 被装饰函数1
@out_fun
def fun1(x):
time.sleep(1)
print(x)
fun1(1)
# 被装饰函数2
@out_fun
def fun2(x, y, z):
time.sleep(1)
print(x + y + z)
fun2(1,2,3)3.5 装饰器带参数（装饰器外部套函数）
上面3.4是被装饰函数带有参数，我们在装饰器内部函数设置参数，以保证参数的正确传递。
现在装饰器要带有参数，而且装饰器的外部函数要接收被装饰函数的函数名，内部函数要接收被装饰函数的参数，那么为了保证装饰器参数、被装饰函数参数的正确传递，我们在装饰器外部函数再嵌套一层函数，用于接收装饰器参数
# 装饰器
def decoration(dec_arg):
def out_fun(function):
def in_fun(x):
print(dec_arg)
print("挂上一颗星星")
function(x)
print("挂上一个礼物盒")
return in_fun
return out_fun
# 被装饰函数
@decoration("我是装饰器的参数")
def my_tree(x):
print(f"简简单单{x}棵树")
my_tree(3)3.6 装饰器嵌套
已学的嵌套：列表、字符串、元组、集合、字典、函数、循环、选择
装饰器嵌套就是被装饰函数 可以 被多个装饰器装饰。
# 装饰器1
def out_fun_1(function):
def in_fun_1(*args, **kwargs):
print("装饰器1开始调用")
function(*args, **kwargs)
print("装饰1结束调用")
return in_fun_1
# 装饰器2
def out_fun_2(function):
def in_fun_2(*args, **kwargs):
print("装饰器2开始调用")
function(*args, **kwargs)
print("装饰2结束调用")
return in_fun_2
# 嵌套装饰 被装饰函数
@out_fun_1
@out_fun_2
def my_tree(x):
print(f"{x}棵树")
my_tree(3)
3.7 类装饰器（了解即可）
除了可以自定义一个新的函数用作装饰器之外，也可以将一个类作为装饰器，为被装饰的函数添加新的功能。类装饰器通过实现类的__call__方法，使得类的实例可以被当作函数来调用，丛而实现对其他函数的装饰。
3.8、装饰器的常见应用【了解即可】
3.8.1 记录日志
装饰器可以用来记录函数调用的详细信息，包括调用时间、参数、返回值等
import logging
def log_decorator(func):
def wrapper(*args, **kwargs):
logging.basicConfig(filename='./app.log', level=logging.INFO, filemode='a',
format='%(name)s - %(levelname)s - %(asctime)s - %(message)s')
logging.warning(f"calling function:{func.__name__} with args:{args} and "
f"kwargs:{kwargs}")
ret = func(*args, **kwargs)
logging.warning(f"function {func.__name__} returned: {ret}")
return ret
return wrapper
@log_decorator
def test():
print('123')
test()3.8.2 性能检测
装饰器可以用来测量函数执行所需的时间，帮助识别性能瓶颈。
import time
def timer(func):
def wrapper(*args, **kwargs):
start_time = time.time()
ret = func(*args, **kwargs)
end_time = time.time()
print(f"{func.__name__} took {(end_time - start_time):.10f} seconds to run")
return ret
return wrapper
@timer
def process_list(my_list):
for i in my_list:
pass
my_list = list(range(10000))
process_list(my_list)3.8.3 权限验证
装饰器可以用来检查用户是否有权限执行特定的函数或方法。
class User:
def __init__(self, username, role):
self.username = username
self.role = role
# 装饰器：检查用户是否具有管理员权限
def admin_only(func):
def wrapper(user, *args, **kwargs):
if user.role != 'admin':
raise PermissionError(f"User {user.username} is not "
f"authorized to perform this action")
return func(user, *args, **kwargs)
return wrapper
@admin_only
def delete_user(user, user_to_delete):
"""只有管理员可以删除用户"""
print(f'User {user_to_delete.username} has been deleted by {user.username}')
# 测试代码
admin_user = User('Alice', 'admin')
normal_user = User('Bob', 'user')
# 尝试以管理员身份删除用户
delete_user(admin_user, normal_user)
# 尝试以普通用户身份删除用户
delete_user(normal_user, admin_user)
扫一扫
572
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
