python高级函数（匿名函数和装饰器）_python匿名函数

一、匿名函数

1. Python lambda（匿名函数）

Python 使用 lambda 来创建匿名函数。
lambda 函数是一种小型、匿名的、内联函数，它可以具有任意数量的参数，但只能有一个表达式。
匿名函数不需要使用 def 关键字定义完整函数。
lambda 函数通常用于编写简单的、单行的函数，通常在需要函数作为参数传递的情况下使用，例如在 map()、filter()、reduce() 等函数中。
lambda 函数特点：
    lambda 函数是匿名的，它们没有函数名称，只能通过赋值给变量或作为参数传递给其他函数来使用。
    lambda 函数通常只包含一行代码，这使得它们适用于编写简单的函数。
    lambda 语法格式：
lambda arguments: expression
    lambda是 Python 的关键字，用于定义 lambda 函数。
    arguments 是参数列表，可以包含零个或多个参数，但必须在冒号(:)前指定。
        lambda 函数也可以设置多个参数，参数使用逗号 , 隔开：
    expression 是一个表达式，用于计算并返回函数的结果。
注意：
    lambda 函数通常与内置函数如 map()、filter() 和 reduce() 一起使用，以便在集合上执行操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

二、装饰器

1. 装饰器概念

装饰器（decorators）是 Python 中的一种高级功能，它允许你动态地修改函数或类的行为。
装饰器是一种函数，它接受一个函数作为参数，并返回一个新的函数或修改原来的函数。
装饰器的语法使用 @decorator_name 来应用在函数或方法上。
Python 还提供了一些内置的装饰器，比如 @staticmethod 和 @classmethod，用于定义静态方法和类方法。
装饰器的应用场景：
    日志记录: 装饰器可用于记录函数的调用信息、参数和返回值。
    性能分析: 可以使用装饰器来测量函数的执行时间。
    权限控制: 装饰器可用于限制对某些函数的访问权限。
    缓存: 装饰器可用于实现函数结果的缓存，以提高性能。
1
2
3
4
5
6
7
8
9

2. 基本语法

Python 装饰允许在不修改原有函数代码的基础上，动态地增加或修改函数的功能，装饰器本质上是一个接收函数作为输入并返回一个新的包装过后的函数的对象。
    def decorator_function(original_function):
        def wrapper(*args, **kwargs):
            # 这里是在调用原始函数前添加的新功能
            before_call_code()

            result = original_function(*args, **kwargs)

            # 这里是在调用原始函数后添加的新功能
            after_call_code()

            return result
        return wrapper

    # 使用装饰器
    @decorator_function
    def target_function(arg1, arg2):
        pass  # 原始函数的实现
解析：decorator 是一个装饰器函数，它接受一个函数 func 作为参数，并返回一个内部函数 wrapper，在 wrapper 函数内部，你可以执行一些额外的操作，然后调用原始函数 func，并返回其结果。
    decorator_function 是装饰器，它接收一个函数 original_function 作为参数。
    wrapper 是内部函数，它是实际会被调用的新函数，它包裹了原始函数的调用，并在其前后增加了额外的行为。
    当我们使用 @decorator_function 前缀在 target_function 定义前，Python会自动将 target_function 作为参数传递给 decorator_function，然后将返回的 wrapper 函数替换掉原来的 target_function。

使用装饰器
    装饰器通过 @ 符号应用在函数定义之前
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

3. 带参数的装饰器

    装饰器函数也可以接受参数
1

4. 类装饰器

    除了函数装饰器，Python 还支持类装饰器。类装饰器是包含 __call__ 方法的类，它接受一个函数作为参数，并返回一个新的函数
1

三、代码概览（匿名函数）

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-
# @Date : 2024/4/7 14:16
# @Author : water
# @Description : 匿名函数

"""
Python lambda（匿名函数）
    Python 使用 lambda 来创建匿名函数。
    lambda 函数是一种小型、匿名的、内联函数，它可以具有任意数量的参数，但只能有一个表达式。
    匿名函数不需要使用 def 关键字定义完整函数。
    lambda 函数通常用于编写简单的、单行的函数，通常在需要函数作为参数传递的情况下使用，例如在 map()、filter()、reduce() 等函数中。
    lambda 函数特点：
        lambda 函数是匿名的，它们没有函数名称，只能通过赋值给变量或作为参数传递给其他函数来使用。
        lambda 函数通常只包含一行代码，这使得它们适用于编写简单的函数。
        lambda 语法格式：
    lambda arguments: expression
        lambda是 Python 的关键字，用于定义 lambda 函数。
        arguments 是参数列表，可以包含零个或多个参数，但必须在冒号(:)前指定。
            lambda 函数也可以设置多个参数，参数使用逗号 , 隔开：
        expression 是一个表达式，用于计算并返回函数的结果。
注意：
    lambda 函数通常与内置函数如 map()、filter() 和 reduce() 一起使用，以便在集合上执行操作

"""
from functools import reduce

f = lambda a, b: a + b
print(f(1, 2))

# lambda 函数通常与内置函数如 map()、filter() 和 reduce() 一起使用，以便在集合上执行操作
l = [1, 2, 3, 4, 5]
print(list(map(lambda x: x * 2, l)))  # [2, 4, 6, 8, 10]

# 使用 lambda 函数与 filter() 一起，筛选偶数
print(list(filter(lambda x: x % 2 == 0, l)))

# 使用 reduce() 和 lambda 表达式演示如何计算一个序列的累积乘积
# 在下面的实例中，reduce() 函数通过遍历 l 列表，并使用 lambda 函数将累积的结果不断更新，最终得到了 1 * 2 * 3 * 4 * 5 = 120 的结果。
print(reduce(lambda x, y: x * y, l))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

四、代码概览（装饰器）

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-
# @Date : 2024/4/10 10:37
# @Author : water
# @Description : 装饰器
"""
装饰器
    装饰器（decorators）是 Python 中的一种高级功能，它允许你动态地修改函数或类的行为。
    装饰器是一种函数，它接受一个函数作为参数，并返回一个新的函数或修改原来的函数。
    装饰器的语法使用 @decorator_name 来应用在函数或方法上。
    Python 还提供了一些内置的装饰器，比如 @staticmethod 和 @classmethod，用于定义静态方法和类方法。
    装饰器的应用场景：
        日志记录: 装饰器可用于记录函数的调用信息、参数和返回值。
        性能分析: 可以使用装饰器来测量函数的执行时间。
        权限控制: 装饰器可用于限制对某些函数的访问权限。
        缓存: 装饰器可用于实现函数结果的缓存，以提高性能。
    基本语法
    Python 装饰允许在不修改原有函数代码的基础上，动态地增加或修改函数的功能，装饰器本质上是一个接收函数作为输入并返回一个新的包装过后的函数的对象。
        def decorator_function(original_function):
            def wrapper(*args, **kwargs):
                # 这里是在调用原始函数前添加的新功能
                before_call_code()

                result = original_function(*args, **kwargs)

                # 这里是在调用原始函数后添加的新功能
                after_call_code()

                return result
            return wrapper

        # 使用装饰器
        @decorator_function
        def target_function(arg1, arg2):
            pass  # 原始函数的实现
    解析：decorator 是一个装饰器函数，它接受一个函数 func 作为参数，并返回一个内部函数 wrapper，在 wrapper 函数内部，你可以执行一些额外的操作，然后调用原始函数 func，并返回其结果。
        decorator_function 是装饰器，它接收一个函数 original_function 作为参数。
        wrapper 是内部函数，它是实际会被调用的新函数，它包裹了原始函数的调用，并在其前后增加了额外的行为。
        当我们使用 @decorator_function 前缀在 target_function 定义前，Python会自动将 target_function 作为参数传递给 decorator_function，然后将返回的 wrapper 函数替换掉原来的 target_function。

    使用装饰器
        装饰器通过 @ 符号应用在函数定义之前
    带参数的装饰器
        装饰器函数也可以接受参数
    类装饰器
        除了函数装饰器，Python 还支持类装饰器。类装饰器是包含 __call__ 方法的类，它接受一个函数作为参数，并返回一个新的函数
"""


# 装饰器（可以带参数，也可以不带参数）
def decorator_function(original_function):
    def wrapper(*args, **kwargs):
        # 这里是在调用原始函数前添加的新功能
        print("Before calling the original function")
        result = original_function(*args, **kwargs)
        # 这里是在调用原始函数后添加的新功能
        print("After calling the original function")
        return result

    return wrapper


@decorator_function
def target_function(arg1, arg2):
    print(f"Target function called with arguments: {arg1}, {arg2}")


target_function("sanduo", "water")

print("*" * 20)


# 带参数的装饰器
def decorator_function_with_arguments(decorator_arg):
    def decorator_function(original_function):
        def wrapper(*args, **kwargs):
            print(f"Decorator argument: {decorator_arg}")
            result = original_function(*args, **kwargs)
            return result

        return wrapper

    return decorator_function


@decorator_function_with_arguments("Hello, World!")
def target_function_with_arguments(arg1, arg2):
    print(f"Target function with arguments called with arguments: {arg1}, {arg2}")


target_function_with_arguments("zhangsan", "lisi")

print("*" * 20)


# 类装饰器
class DecoratorClass:
    def __init__(self, original_function):
        self.original_function = original_function

    def __call__(self, *args, **kwargs):
        print("Before calling the original function")
        result = self.original_function(*args, **kwargs)
        print("After calling the original function")
        return result


@DecoratorClass
def target_function_with_class_decorator(arg1, arg2):
    print(f"Target function with class decorator called with arguments: {arg1}, {arg2}")


target_function_with_class_decorator("王五", "马贝")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114