函数中变量的作用域

函数中变量的作用域

全局变量：声明在函数外边的变量

a = 100


def test_01():
    a = 0
    b = 110
    print(a)
    print(b)


# test_01()
# print(a)
# print(b)
def test_02():
    print(a)

# 局部变量的作用范围仅限于函数内部


# test_02()


def test_03():
    # 函数内部可以使用全局变量但是无法修改全局变量,如果要进行修改，使用globle关键字
    global a
    a += 100
    print(a)
    
test_03()

函数注释

定义函数时的补充

def sum_01(a,b):
    '''
    a:int
    b:int
    :return 两数之和
    '''
    return a+b


sum_01(1,2)

值传递和引用传递

值传递：

在传递参数时，仅仅是把值拷贝一份传递给参数的函数，变量的值不发生变化。

引用传递：

在传递参数的时候，传地址，函数形参获取的值，也是同一块内存。

def test02(nums):
    print(id(nums))
    nums.append(10)
    nums.append(100)
    print(nums)


list1 = [1, 2, 3]
print(id(list1))
test02(list1)

匿名函数

let a = function(){}
python中，如果要将函数作为参数传到另外一个函数里边去
python中函数参数的数据类型：只要是对象就可以
python ：函数本身就是一个对象

def test01(fn):
    a = fn(1,2)
    print(a)


# test01(compute)

test01(lambda a, b: a + b)

# python中，存在函数作为参数传递给函数，并且不想被外界访问，而且参数函数足够简单，即可以定义为匿名函数(lambda 表达式)

'''
lambda [a,b]:代码块
'''

偏函数

偏函数（Partial function）是指固定一个函数的部分参数，从而创建一个新的函数。这个新函数接收剩余的参数并执行原函数。在 Python 中，可以使用 functools 模块中的 partial 函数来创建偏函数。

偏函数的作用主要有两个方面：

1. 固定函数的部分参数：通过偏函数，可以将一个函数的某些参数固定下来，形成一个新的函数。这样做的好处是可以简化函数的调用过程，减少重复的代码。
2. 自定义默认参数：偏函数可以用于自定义默认参数的值。通常情况下，函数的默认参数只能在函数定义时指定一次，而通过偏函数，可以在多次调用函数时自定义不同的默认参数值。

以下是创建偏函数的示例：

from functools import partial

# 原函数
def power(base, exponent):
    return base ** exponent

# 创建偏函数，固定 base 参数为 2
square = partial(power, base=2)

# 调用偏函数，只需要传入 exponent 参数
result = square(3)
print(result)  # 输出 2^3 = 8

在上述示例中，我们首先定义了一个原函数 power，它接收两个参数 base 和 exponent，返回 base 的 exponent 次方。然后，我们使用 partial 函数创建一个偏函数 square，该偏函数固定了 base 参数为 2。接着，我们通过调用偏函数 square 并传入 exponent 参数值为 3 来计算 2 的 3 次方。

值得注意的是，偏函数创建后可以像普通函数一样调用，并且可以根据需要自定义其他未固定的参数值。通过使用偏函数，我们可以根据情况灵活地生成新的函数，提高代码的复用性和可读性。

函数的嵌套

在 Python 中，函数可以嵌套定义在另一个函数中，也就是所谓的函数嵌套。

示例：

def outer_func(x):
    def inner_func(y):
        return x + y

    return inner_func

# 创建一个函数对象 f1，它相当于 inner_func(x) 函数
f1 = outer_func(10)

# 调用 f1 函数
result = f1(20)
print(result)  # 输出 30

在上述示例中，我们首先定义了一个外部函数 outer_func，该函数内部定义了一个嵌套函数 inner_func。外部函数返回内部函数的函数对象，并使用外部函数的参数 x 绑定到内部函数中。然后我们使用 outer_func 函数创建了一个函数对象 f1，这个函数对象实际上就是 inner_func 函数。最后我们调用 f1 函数并传入参数 20，输出结果为 30。

在实际编程中，函数嵌套可用于隐藏实现细节，提高代码的可读性和可维护性。但同时也要注意，在过度嵌套的情况下，代码可能会变得复杂难懂，而且每一层函数调用都会带来额外的开销。所以，在编写嵌套函数时，需要根据具体情况权衡利弊，避免滥用和过度设计。

闭包

函数可以作为参数进行传递
函数名本质上就是变量名，指向函数所在的内存地址。

闭包：一个函数嵌套另一个函数，内层函数用到外层函数的局部变量，内层函数即为闭包。

def outer():
    a = 10
    def inner():
        nonlocal a
        a += 100
    return inner


a = outer()
'''
1、可以让一个变量常驻在内存中
2、可以避免全局变量被修改

'''

装饰器

装饰器（Decorator）是Python中一种用于修改、扩展或包装函数或类的功能的特殊语法。装饰器本质上是一个函数，它接收一个函数作为参数，并返回一个新的函数或类。

装饰器的作用是在不修改原函数或类源码的情况下，通过包装原函数或类来实现额外的功能。常见的应用场景包括日志记录、性能分析、权限验证、缓存等。

以下是一个简单的装饰器示例：

def decorator(func):
    def wrapper(*args, **kwargs):
        # 在调用被装饰函数之前的额外操作
        print("Before function execution")

        # 调用被装饰的函数
        result = func(*args, **kwargs)

        # 在调用被装饰函数之后的额外操作
        print("After function execution")

        # 返回被装饰函数的结果
        return result

    return wrapper

@decorator
def greet(name):
    print(f"Hello, {name}!")

# 调用被装饰函数
greet("Alice")

在上述示例中，我们定义了一个装饰器函数 decorator，它接收一个函数作为参数，并返回一个新的函数 wrapper。在 wrapper 函数中，我们可以在调用被装饰函数之前和之后执行额外的操作。然后，我们使用 @decorator 语法将装饰器应用到 greet 函数上，相当于执行了 greet = decorator(greet)。最后，调用 greet("Alice") 时，实际上是调用了装饰器包装后的函数 wrapper，从而实现了在函数执行前后打印额外信息的功能。

需要注意的是，装饰器可以有多个，并且可以叠加使用。装饰器的执行顺序是从上到下的，即先应用最底层的装饰器。

装饰器提供了一种简洁而灵活的方式来修改现有函数或类的行为，同时保持代码的可读性和可维护性。理解装饰器的原理和使用方法对于编写高效、模块化的代码非常重要。