【Python高阶技巧】闭包、装饰器

一、闭包

  • 1、闭包的用途和用法
  • 2、nonlocal关键字的作用
  • 闭包注意事项 优缺点

二、装饰器

  • 装饰器的作用和用法

一、闭包

在编程中,闭包(Closure)是指一种函数对象,它可以访问其自身范围(词法作用域)之外的变量。换句话说,闭包允许函数访问其创建时所在的词法作用域中的变量,即使在函数执行完毕后,这些变量仍然可以被访问。

闭包通常发生在嵌套函数中。一个函数定义在另一个函数的内部,并且内部函数引用了外部函数的变量,这样的结构就形成了闭包。闭包具有以下特点:

  1. 词法作用域(Lexical Scope): 闭包允许内部函数访问外部函数的词法作用域中的变量,即使外部函数已经执行完毕。

  2. 持久性: 闭包中的变量在外部函数执行完后仍然保持活动状态,因为内部函数引用了这些变量。

下面是一个简单的例子,演示了 JavaScript 中的闭包:

function outerFunction() {
  let outerVariable = "I am from the outer function";

  // 内部函数形成闭包,可以访问外部函数的变量
  function innerFunction() {
    console.log(outerVariable);
  }

  return innerFunction;
}

// 调用外部函数,得到内部函数
let closureFunction = outerFunction();

// 执行内部函数,它可以访问外部函数的变量
closureFunction(); // 输出: I am from the outer function

在这个例子中,innerFunction 是一个闭包,它引用了外部函数 outerFunction 中的 outerVariable。即使 outerFunction 执行完毕,我们仍然可以通过调用 closureFunction 来访问 outerVariable

闭包在许多编程语言中都存在,并且在函数式编程和一些设计模式中经常被使用。在使用闭包时,需要注意内存管理,确保不会造成不必要的内存泄漏。

1、闭包的用途和用法

【Python高阶技巧】闭包、装饰器_第1张图片
【Python高阶技巧】闭包、装饰器_第2张图片

简单的示例

【Python高阶技巧】闭包、装饰器_第3张图片

2、2、nonlocal关键字的作用

【Python高阶技巧】闭包、装饰器_第4张图片
【Python高阶技巧】闭包、装饰器_第5张图片

代码

"""
演示Python的闭包特性
"""

# 简单闭包
# def outer(logo):
#
#     def inner(msg):
#         print(f"<{logo}>{msg}<{logo}>")
#
#     return inner
#
#
# fn1 = outer("黑马程序员")
# fn1("大家好")
# fn1("大家好")
#
# fn2 = outer("传智教育")
# fn2("大家好")

# 使用nonlocal关键字修改外部函数的值
# def outer(num1):
#
#     def inner(num2):
#         nonlocal num1
#         num1 += num2
#         print(num1)
#
#     return inner
#
# fn = outer(10)
# fn(10)
# fn(10)
# fn(10)
# fn(10)

# 使用闭包实现ATM小案例
def account_create(initial_amount=0):

    def atm(num, deposit=True):
        nonlocal initial_amount
        if deposit:
            initial_amount += num
            print(f"存款:+{num}, 账户余额:{initial_amount}")
        else:
            initial_amount -= num
            print(f"取款:-{num}, 账户余额:{initial_amount}")

    return atm

atm = account_create()

atm(100)
atm(200)
atm(100, deposit=False)

闭包注意事项 优缺点

优点,使用闭包可以让我们得到:

  • 无需定义全局变量即可实现通过函数,持续的访问、修改某个值
  • 闭包使用的变量的所用于在函数内,难以被错误的调用修改

缺点:

  • 由于内部函数持续引用外部函数的值,所以会导致这一部分内存空间不被释放,一直占用内存

总结

  1. 什么是闭包
    定义双层嵌套函数内层函数可以访问外层函数的变量
    将内存函数作为外层函数的返回,此内层函数就是闭包函数
  2. 闭包的好处和缺点
    • 优点:
      • 不定义全局变量,也可以让函数持续访问和修改一个外部变量
      • 闭包函数引用的外部变量,是外层函数的内部变量。作用域封闭难以被误操作修改
    • 缺点:额外的内存占用
  3. nonlocal关键字的作用
    在闭包函数(内部函数中)想要修改外部函数的变量值
    需要用nonlocal声明这个外部变量

二、装饰器

在编程中,装饰器(Decorator)是一种可以用于修改或扩展函数、方法或类行为的特殊语法。装饰器允许在不修改源代码的情况下,动态地添加或修改函数的功能。在许多编程语言中,装饰器通常以 @ 符号加上装饰器函数或类的形式使用。

下面是一个简单的 Python 装饰器的例子:

def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

# 调用被装饰的函数
say_hello()

在这个例子中,my_decorator 是一个装饰器函数,它接受一个函数作为参数,并返回一个新的函数 wrapper。通过使用 @my_decorator 语法,我们将 say_hello 函数传递给装饰器,从而将它装饰起来。当调用 say_hello() 时,实际上是调用了装饰后的 wrapper 函数,从而实现了在函数执行前后添加额外功能的效果。

Python 中还有一些内置的装饰器,例如 @property@staticmethod@classmethod 等,它们用于定义属性、静态方法和类方法。同时,Python 也支持同时应用多个装饰器,它们按照从上到下的顺序进行嵌套。

装饰器在代码重用和模块化方面提供了一种灵活而强大的机制,它使得我们可以通过简单地添加装饰器来改变函数或类的行为,而不必修改其原始实现。

装饰器的作用和用法

装饰器其实也是一种闭包, 其功能就是在不破坏目标函数原有的代码和功能的前提下,为目标函数增加新功能。

装饰器的一般写法(闭包写法)

【Python高阶技巧】闭包、装饰器_第6张图片

装饰器的语法糖写法

【Python高阶技巧】闭包、装饰器_第7张图片

代码

"""
演示装饰器的写法
"""

# 装饰器的一般写法(闭包)
# def outer(func):
#     def inner():
#         print("我睡觉了")
#         func()
#         print("我起床了")
#
#     return inner
#
# def sleep():
#     import random
#     import time
#     print("睡眠中......")
#     time.sleep(random.randint(1, 5))
#
# fn = outer(sleep)
# fn()

# 装饰器的快捷写法(语法糖)
def outer(func):
    def inner():
        print("我睡觉了")
        func()
        print("我起床了")

    return inner

@outer
def sleep():
    import random
    import time
    print("睡眠中......")
    time.sleep(random.randint(1, 5))

sleep()

总结

  1. 什么是装饰器
    装饰器就是使用创建一个闭包函数,在闭包函数内调用目标函数。
    可以达到不改动目标函数的同时,增加额外的功能。
  2. 装饰器的写法
    【Python高阶技巧】闭包、装饰器_第8张图片

补充:语法糖

语法糖(Syntactic Sugar)是指一种编程语言的语法特性,它并不提供新的功能,而是用更简洁、更易读的语法形式来表达已有的语法结构。语法糖的目的是提高代码的可读性和易用性,使得开发者能够更加方便地书写和理解代码。

以下是一些编程语言中常见的语法糖例子:

  1. 列表推导式(List Comprehensions):

    # 传统方式
    squares = []
    for x in range(10):
        squares.append(x**2)
    
    # 使用列表推导式
    squares = [x**2 for x in range(10)]
    
  2. 条件表达式(Ternary Operator):

    # 传统方式
    if x > 0:
        y = 1
    else:
        y = 0
    
    # 使用条件表达式
    y = 1 if x > 0 else 0
    
  3. 匿名函数(Lambda Expressions):

    # 传统方式
    def square(x):
        return x**2
    
    # 使用匿名函数
    square = lambda x: x**2
    
  4. 解构赋值(Destructuring Assignment):

    # 传统方式
    x = (1, 2, 3)
    a = x[0]
    b = x[1]
    c = x[2]
    
    # 使用解构赋值
    a, b, c = (1, 2, 3)
    
  5. 字符串格式化(String Formatting):

    # 传统方式
    name = "Alice"
    age = 30
    message = "Hello, {}! You are {} years old.".format(name, age)
    
    # 使用字符串格式化语法糖
    message = f"Hello, {name}! You are {age} years old."
    

语法糖并不是一种新的语言特性,而是对已有特性的更友好的表达方式。它使得代码更加简洁、清晰,提高了开发效率。然而,使用语法糖时也需要注意不要过度使用,以免影响代码的可读性。

你可能感兴趣的:(Python资料,闭包,nonlocal关键字,语法糖,outer)