Python 高级特性汇总

最新推荐文章于 2024-09-12 16:40:50 发布

我算是程序猿

最新推荐文章于 2024-09-12 16:40:50 发布

阅读量859

点赞数 27

分类专栏： Python脚本文章标签： python 前端开发语言

本文链接：https://blog.csdn.net/Trb201013/article/details/137832893

版权

Python脚本专栏收录该内容

27 篇文章 1 订阅

订阅专栏

1 装饰器

装饰器（Decorator）

定义：装饰器是一个接受函数作为参数的高阶函数，并返回一个新的函数对象。它主要用于修改或增强原始函数的行为，而不需要修改其源代码。装饰器在Python中是通过@符号来应用的。

作用：

修改函数行为：装饰器可以在不修改原始函数代码的情况下，增加额外的功能或改变函数的行为。增强功能：通过装饰器，可以轻松地为函数添加日志记录、性能测试、缓存、权限校验等功能。代码重用：通过装饰器，可以将通用的功能（如日志记录、性能分析）抽象出来，并在多个函数之间重用。简化代码：装饰器可以使代码更加简洁，避免在多个地方重复相同的代码逻辑。

应用场景：

日志记录：在函数调用前后添加日志记录，以便跟踪函数的执行情况。性能分析：通过装饰器记录函数的执行时间，以便进行性能调优。权限校验：在函数调用前进行权限验证，确保用户有权限执行该函数。缓存：通过装饰器实现函数的缓存功能，提高程序的执行效率。

代码示例：

下面是一个简单的装饰器示例，用于记录函数的执行时间：

import time

def timer_decorator(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"Function {func.__name__} took {end_time - start_time:.6f} seconds to execute.")
        return result
    return wrapper

@timer_decorator
def say_hello(name):
 time.sleep(1) # 模拟耗时操作
 print(f"Hello, {name}!")

say_hello("World")

在这个例子中，timer_decorator 是一个装饰器函数，它接受一个函数 func 作为参数，并返回一个新的函数 wrapper。wrapper 函数会记录 func 的执行时间，并在执行结束后打印出来。通过 @timer_decorator 语法，我们将 say_hello 函数装饰起来，这样每次调用 say_hello 时，都会执行 wrapper 函数，从而实现了对函数执行时间的记录。

运行上面的代码，你会看到输出中包含了 say_hello 函数的执行时间。

2 生成器

生成器（Generator）

定义：生成器是Python提供的一种可以迭代的对象，但它不是通过列表或元组等数据结构来实现的，而是通过函数来实现。一个生成器函数看起来就像一个普通的函数，但它在需要返回值的地方使用yield关键字代替return。当生成器函数被调用时，它并不执行，而是返回一个迭代器，这个迭代器可以用来遍历函数中的yield语句产生的值。

作用：

节省内存：生成器允许你声明一个函数，这个函数可以一次返回一个值，而不是一次性地在内存中生成所有的值。这对于大数据集或无限序列来说特别有用，因为它不会占用过多的内存。惰性求值：生成器使用惰性求值的方式，只有在需要时才计算下一个值，而不是一开始就计算所有值。简化代码：生成器提供了一种简洁的方式来处理迭代逻辑，特别是当迭代逻辑比较复杂时。

应用场景：

大数据处理：当处理大量数据时，使用生成器可以逐步处理数据，而不是一次性加载所有数据到内存中。无限序列：生成器可以用来生成无限序列，例如斐波那契数列，因为生成器只在需要时才计算下一个值，所以不会导致内存溢出。简化迭代逻辑：当迭代逻辑比较复杂，使用传统的for循环不方便时，可以使用生成器来简化代码。

代码示例：

下面是一个简单的生成器函数示例，用于生成一个无限递增的序列：

def infinite_sequence():
    num = 0
    whileTrue:
        yield num
        num += 1

# 创建一个生成器对象
seq = infinite_sequence()

# 使用next()函数获取生成器的下一个值
print(next(seq))  # 输出 0
print(next(seq))  # 输出 1
print(next(seq))  # 输出 2
# 以此类推...

在这个例子中，infinite_sequence函数是一个生成器函数，它使用yield语句来产生序列中的下一个值。当我们调用infinite_sequence()时，并没有立即执行函数体中的代码，而是返回了一个生成器对象seq。通过调用next(seq)，我们可以逐个获取生成器产生的值。

需要注意的是，由于生成器函数在每次调用yield时都会暂停并保存当前的状态，所以生成器函数可以在多次调用之间保持状态。这也是生成器能够逐个产生值的关键所在。

3 迭代器

迭代器（Iterator）

定义：迭代器是一个可以记住遍历的位置的对象。迭代器对象必须实现两个方法，iter() 和 next()。字符串、列表或元组等数据类型都是可迭代对象，但它们不是迭代器，因为它们不具有 next() 方法。迭代器对象用于遍历可迭代对象（如集合、列表等）的元素。

作用：

遍历数据：迭代器提供了一种统一的、不依赖于索引的遍历数据的方式。解耦数据与遍历逻辑：迭代器将数据的存储和数据的遍历操作分离，使得两者可以独立地改变。支持多种遍历方式：迭代器不仅支持线性遍历，还支持其他复杂的遍历方式（如回溯、深度优先搜索等）。

应用场景：

遍历集合：迭代器常用于遍历列表、元组、字典、集合等数据结构。自定义遍历逻辑：可以通过实现迭代器接口来定义自己的数据结构和遍历逻辑。

代码示例：

下面是一个简单的迭代器示例，用于遍历一个自定义的集合：

class MyNumbers:
    def __iter__(self):
        self.a = 1
        return self

    def __next__(self):
        x = self.a
        self.a += 1
        return x

myclass = MyNumbers()
myiter = iter(myclass)

print(next(myiter))  # 输出 1
print(next(myiter))  # 输出 2
print(next(myiter))  # 输出 3

在这个例子中，MyNumbers 类实现了 iter() 和 next() 方法，因此它是一个迭代器。当我们调用 iter(myclass) 时，返回了一个迭代器对象 myiter。通过调用 next(myiter)，我们可以逐个获取迭代器产生的值。

迭代器和生成器的区别：

实现方式：

迭代器：是遵循迭代器协议的对象，它们实现了 iter() 和 next() 方法。迭代器可以遍历任何集合，无论集合的大小。生成器：是一种特殊的迭代器，使用 yield 关键字而不是 return 来返回值。当生成器函数被调用时，它返回一个迭代器，这个迭代器按需生成值。

使用场景：

迭代器：通常用于遍历已经存在的集合（如列表、元组等）。生成器：通常用于创建需要在迭代过程中逐个计算值的情况，如无限序列或大数据集。

内存效率：

迭代器：如果集合很大，迭代器可能需要消耗较多的内存来存储整个集合。生成器：生成器只在需要时生成下一个值，因此更加内存高效，特别是对于大数据集或无限序列。

灵活性：

迭代器：迭代器的实现相对固定，通常用于遍历已存在的数据结构。

4 上下文管理器

上下文管理器（Context Manager）

定义：上下文管理器是Python中用于管理资源的一种机制，它允许你定义在进入和退出某个代码块时需要执行的逻辑。最常见的上下文管理器是使用with语句，它可以确保即使在代码块执行过程中发生异常，资源也能被正确地释放或清理。

作用：

资源管理：上下文管理器可以自动管理资源，如文件、网络连接、锁等，确保它们在使用后被正确关闭或释放。异常处理：即使在代码块中发生异常，上下文管理器也能确保资源被正确清理。代码简洁性：使用with语句可以使代码更加简洁和易读。

应用场景：

文件操作：使用上下文管理器可以确保文件在使用后被正确关闭，即使在读取或写入过程中发生错误。线程锁：在多线程编程中，可以使用上下文管理器来管理锁的获取和释放，确保线程安全。自定义资源管理：你可以自定义上下文管理器来管理任何需要显式初始化和清理的资源。

代码示例：

文件操作：

with open('example.txt', 'r') as file:
    content = file.read()
    print(content)
# 文件在with语句块结束后自动关闭

# 自定义上下文管理器：

class MyContext:
    def __enter__(self):
        print("Entering the block")
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("Exiting the block")
        if exc_type isnotNone:
            print("An exception occurred:", exc_type, exc_val)

with MyContext() as x:
    print("Inside the block")
    raise ValueError("Test exception")
# 输出:
# Entering the block
# Inside the block
# An exception occurred: <class 'ValueError'> Test exception
# Exiting the block

在这个示例中，我们定义了一个名为MyContext的上下文管理器类。当进入with语句块时，__enter__方法被调用；当退出with语句块时，__exit__方法被调用。如果在块中发生异常，__exit__方法会接收异常的相关信息。

5 元类和元编程

元类（Metaclasses）

定义：元类在Python中是用来创建类的“类”。通常，我们定义类来创建对象实例，但元类是用来创建这些类的。元类定义了如何创建和修改类。在Python中，所有的类都是类型（type）的实例，而type本身也是一个元类。

作用：

控制类的创建：元类允许你在类被创建时执行自定义逻辑。修改类的行为：元类可以修改类的属性、方法或行为。创建复杂的类结构：元类可以用来创建复杂的类继承结构或动态地添加属性和方法。

应用场景：

ORM框架：对象关系映射（ORM）框架使用元类来动态地创建模型类，这些类代表数据库中的表。单例模式：元类可以用来实现单例模式，确保一个类只有一个实例。元编程：元类是实现元编程（编程的编程）的重要工具，允许你操作类本身而不是类的实例。

代码示例：

class Meta(type):
    def __new__(cls, name, bases, attrs):
        print(f"Creating class {name}")
        return super().__new__(cls, name, bases, attrs)

class MyClass(metaclass=Meta):
    pass

# 输出: Creating class MyClass

在这个例子中，我们定义了一个名为Meta的元类，它重写了__new__方法。当我们创建MyClass时，Meta的__new__方法会被调用，从而输出创建类的信息。

元编程（Metaprogramming）

定义：元编程指的是在运行时操作或修改程序本身的结构或行为。在Python中，元编程通常涉及对类、函数、模块等对象的动态创建、修改和调用。

作用：

动态性：元编程允许程序在运行时动态地改变其结构，以适应不同的需求。代码重用：通过元编程，可以创建通用的代码结构，减少重复劳动。灵活性：元编程提供了更大的灵活性，允许在运行时决定程序的行为。

应用场景：

装饰器：装饰器是元编程的一个常见应用，它们允许在不修改函数代码的情况下添加额外的功能。框架：很多Python框架，如Django、Flask等，都使用了元编程技术来动态地创建和管理路由、数据库模型等。测试工具：元编程可以用于动态生成测试用例和测试数据。

代码示例：

def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("Before function call")
        result = func(*args, **kwargs)
        print("After function call")
        return result
    return wrapper

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

greet("Alice")
# 输出:
# Before function call
# Hello, Alice!
# After function call

在这个例子中，我们定义了一个名为my_decorator的装饰器。这个装饰器接受一个函数作为参数，并返回一个新的函数wrapper，它会在调用原始函数之前和之后打印消息。通过@my_decorator语法，我们可以动态地修改greet函数的行为，而不需要修改其源代码。

6 单例模式

单例模式（Singleton Pattern）

定义：单例模式是一种设计模式，它确保一个类只有一个实例，并提供一个全局访问点来获取这个唯一实例。这意味着无论你尝试创建类的多少个实例，始终都会得到相同的单个实例。

作用：

节省资源：单例模式可以避免反复创建相同的对象，从而节省系统资源。全局访问点：提供了一个全局访问点，使得客户端可以轻松地访问该类的唯一实例。控制实例数量：在某些情况下，你可能想要限制某个类的实例数量，单例模式就是一个很好的选择。

应用场景：

配置管理：管理应用程序的配置信息，确保配置信息的一致性。线程池：创建和管理线程池，确保线程池中的线程数量是有限的。数据库连接：数据库连接通常很昂贵，使用单例模式可以确保整个应用程序只有一个数据库连接实例。日志记录：确保日志记录器只有一个实例，以避免重复记录或配置冲突。

代码示例：

在Python中，有几种实现单例模式的方法，下面是一个使用__new__方法的经典实现：

class Singleton:
    _instance = None

    def __new__(cls, *args, **kwargs):
        ifnot cls._instance:
            cls._instance = super().__new__(cls)
        return cls._instance

# 创建单例实例
instance1 = Singleton()
instance2 = Singleton()

# 检查两个实例是否相同
print(instance1 is instance2)  # 输出: True

在这个例子中，Singleton类有一个类变量_instance用来存储类的唯一实例。__new__方法被重写，在创建新实例之前检查_instance是否已经存在。如果存在，则直接返回该实例；如果不存在，则调用父类的__new__方法创建一个新实例，并将其存储在_instance中。

另外，从Python 3.7开始，可以使用__class_getitem__方法实现一个更简洁的基于元类的单例模式：

class SingletonType(type):
    _instances = {}

    def __call__(cls, *args, **kwargs):
        if cls notin cls._instances:
            cls._instances[cls] = super().__call__(*args, **kwargs)
        return cls._instances[cls]

class Singleton(metaclass=SingletonType):
    pass

# 创建单例实例
instance1 = Singleton()
instance2 = Singleton()

# 检查两个实例是否相同
print(instance1 is instance2)  # 输出: True

在这个例子中，我们定义了一个元类SingletonType，它有一个_instances字典来存储每个类的单例实例。__call__方法被重写，在调用类时检查该类的实例是否已经在_instances字典中。如果是，则返回现有实例；否则，创建一个新实例并将其存储在_instances字典中。

这些是实现单例模式的常见方法，但请注意，单例模式的使用应该谨慎，因为它可能导致代码难以测试和调试。在决定使用单例模式之前，最好先考虑是否真的需要它。

8 Lambda函数

Lambda函数

定义：Lambda函数，也称为匿名函数，是一种简洁的表示单行函数的方法。Lambda函数可以接收任意数量的参数，但只能有一个表达式。这个表达式的结果就是函数的返回值。

语法：

lambda arguments: expression

其中arguments是函数的参数，用逗号分隔；expression是函数体，只能有一个表达式，不需要return语句。

特点：

匿名性：Lambda函数没有名字，它们是匿名的。简洁性：Lambda函数主要用于编写简单的函数，通常只包含一行代码。即用即弃：Lambda函数不需要像普通函数那样先定义后使用，它们可以在定义的同时被使用。一行代码限制：由于Lambda函数的主体只能有一个表达式，所以它们不能包含复杂的逻辑。

作用：

作为简短函数使用：当需要一个简单的函数作为参数传递给其他函数时，Lambda函数非常有用。作为排序或过滤函数的键：在sorted()和filter()等函数中，可以使用Lambda函数作为排序或过滤的标准。

应用场景：

排序：使用sorted()函数时，可以传递一个Lambda函数作为排序的键。过滤：使用filter()函数时，可以传递一个Lambda函数作为过滤的条件。内联函数：在需要临时使用函数的地方，可以用Lambda函数替代定义完整函数。

代码示例：

排序：

# 使用Lambda函数对列表中的字符串按长度排序
words = ['apple', 'banana', 'cherry', 'date']
sorted_words = sorted(words, key=lambda word: len(word))
print(sorted_words)  # 输出: ['date', 'apple', 'cherry', 'banana']

过滤：

# 使用Lambda函数过滤出列表中的偶数
numbers = [1, 2, 3, 4, 5, 6]
even_numbers = filter(lambda num: num % 2 == 0, numbers)
print(list(even_numbers))  # 输出: [2, 4, 6]

内联函数：

# 使用Lambda函数计算列表中每个元素的平方
squared = map(lambda x: x**2, [1, 2, 3, 4, 5])
print(list(squared))  # 输出: [1, 4, 9, 16, 25]

虽然Lambda函数在很多情况下非常有用，但它们并不适合所有场景。对于复杂的逻辑和需要多行代码的函数，使用传统的函数定义方式可能更为清晰和易于维护。Lambda函数主要适用于简短、临时的函数定义。

9 列表推导式

列表推导式（List Comprehension）

列表推导式是Python中一种简洁而强大的构造列表的方法。它允许你通过一行代码来生成一个列表，而不需要使用传统的for循环和append()方法。列表推导式结合了for循环、if语句和可选的else语句，以及表达式，来创建列表。

基本语法：

[expression for item in iterable]

这里，expression是对item进行操作的表达式，item是从iterable（如列表、元组、字符串、字典、集合或生成器等）中逐个取出的元素。

带条件的列表推导式：

[expression for item in iterable if condition]

你可以通过if语句添加一个条件，只有当condition为True时，expression的结果才会被添加到列表中。

带else语句的列表推导式：

[expression1 if condition else expression2 for item in iterable]

如果提供了else语句，当condition为False时，expression2的结果会被添加到列表中。

示例：

生成一个平方列表：

squares = [x**2for x in range(10)]
print(squares)  # 输出: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

生成一个偶数列表：

even_numbers = [x for x in range(10) if x % 2 == 0]
print(even_numbers)  # 输出: [0, 2, 4, 6, 8]

使用else语句：

numbers = [x**2if x % 2 == 0else x**3for x in range(10)]
print(numbers)  # 输出: [0, 1, 4, 9, 16, 49, 343, 256, 729, 1000]

在这个例子中，如果x是偶数，则计算x的平方；如果x是奇数，则计算x的立方。

嵌套列表推导式：

你还可以使用嵌套for循环来创建更复杂的列表。

# 生成一个二维列表，其中每个子列表包含三个连续的数字
matrix = [[i, i+1, i+2] for i in range(5)]
print(matrix)
# 输出: [[0, 1, 2], [1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 6]] q

优点：

简洁性：列表推导式通常比等效的for循环和append()方法更简洁。可读性：虽然一开始可能看起来不太直观，但一旦习惯了列表推导式的语法，你会发现它们其实非常易读。性能：在某些情况下，列表推导式可能比传统的循环方法更快，因为它们是编译成单个字节码指令的。

注意事项：

列表推导式在处理大数据集时可能会消耗大量内存，因为它们会立即生成整个列表。在这种情况下，考虑使用生成器表达式可能是一个更好的选择。列表推导式在语法上要求严格，任何小的语法错误都可能导致整个表达式无法正常工作。

生成器表达式：

生成器表达式与列表推导式非常相似，但它们生成的是一个生成器对象，而不是一个列表。这意味着元素是按需生成的，而不是一次性生成所有元素，这有助于节省内存。生成器表达式使用圆括号()而不是方括号[]。

# 生成器表达式
squares_generator = (x**2for x in range(10))

# 打印生成器对象的内容
for square in squares_generator:
    print(square)

生成器表达式在需要迭代大型数据集但不需要一次性存储所有数据时非常有用。

10 字典推导式

字典推导式（Dictionary Comprehension）

定义：字典推导式是Python中的一种语法结构，用于快速创建字典。它允许你通过一个表达式和可迭代对象来生成字典的键值对。

作用：字典推导式的主要作用是简化字典的创建过程，使得在构建字典时能够更加简洁、直观和高效。

应用场景：

当需要从其他可迭代对象（如列表、元组、集合等）中生成字典时。当需要过滤字典中的元素，只保留满足特定条件的键值对时。当需要转换已有字典的键或值时。

代码示例：

从列表创建字典：

keys = ['a', 'b', 'c']
values = [1, 2, 3]

# 使用zip函数将键和值组合起来，然后使用字典推导式创建字典

dictionary = {key: value for key, value in zip(keys, values)}
print(dictionary) # 输出: {'a': 1, 'b': 2, 'c': 3}

过滤字典中的元素：

original_dict = {'a': 1, 'b': 2, 'c': 3, 'd': 4}

# 过滤出值大于2的键值对

filtered_dict = {k: v for k, v in original_dict.items() if v > 2}
print(filtered_dict) # 输出: {'c': 3, 'd': 4}

转换字典的键或值：

original_dict = {'a': 1, 'b': 2, 'c': 3}

# 将键转换为大写，并将值翻倍

transformed_dict = {k.upper(): v * 2for k, v in original_dict.items()}
print(transformed_dict) # 输出: {'A': 2, 'B': 4, 'C': 6}

使用enumerate获取索引和值：

items = ['apple', 'banana', 'cherry']

# 获取每个元素的索引和值，并创建字典

indexed_dict = {idx: item for idx, item in enumerate(items)}
print(indexed_dict) # 输出: {0: 'apple', 1: 'banana', 2: 'cherry'}

字典推导式提供了一种非常简洁和高效的方式来创建和操作字典。它们特别适用于在数据处理和转换任务中快速构建或转换字典结构。

11 闭包

闭包（Closure）

定义：

在Python中，闭包是一个非常重要的概念。当一个内部函数引用了其外部函数的变量（非全局变量），并且该内部函数被返回或者在其他地方被引用时，就形成了一个闭包。简言之，闭包就是一个能够访问和操作其外部函数作用域变量的内部函数。

作用：

数据隐藏和封装：闭包可以隐藏某些数据，只通过特定的接口来访问或修改这些数据。实现回调函数和装饰器：闭包常常被用作回调函数，因为它们可以记住自己的词法环境，包括外部变量和this对象。此外，闭包也是实现装饰器的基础。实现函数柯里化（Currying）：闭包可以用于创建新的函数，这些函数具有预设的某些参数值。

应用场景：

计数器：使用闭包可以创建一个简单的计数器，每次调用返回函数时，计数器都会增加。数据验证：闭包可以用于创建验证函数，这些函数可以记住验证规则并在需要时应用它们。延迟计算：闭包可以用于实现延迟计算或懒加载，只有在真正需要结果时才进行计算。

示例代码：

下面是一个简单的闭包示例，它实现了一个计数器：

def counter():
    count = 0# 这是一个外部函数的变量

    def increment():
        nonlocal count  # 声明我们要修改的是外部函数的变量
        count += 1
        return count

    return increment  # 返回内部函数，这样就形成了一个闭包

# 使用闭包
c = counter()
print(c())  # 输出：1
print(c())  # 输出：2
print(c())  # 输出：3

在这个例子中，counter函数返回了increment函数，而increment函数引用了counter函数作用域中的count变量。因此，每次调用c()时，count都会增加，并且由于闭包的存在，count的值在函数调用之间得以保持。

12 协程

协程（Coroutine）

定义：

协程是一种用户态的轻量级线程，它的执行完全由用户程序控制。协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈，直接操作栈则基本没有内核切换的开销，可以不加锁的访问全局变量，所以上下文的切换非常快。

作用：

非阻塞性 I/O：协程允许你以同步的方式编写异步代码，从而避免了回调地狱（Callback Hell）和复杂的线程管理。

轻量级并发：协程比线程轻量，创建和销毁协程的开销非常小，因此可以创建大量的协程来处理并发任务。

高并发性能：由于协程在用户态运行，切换不需要陷入内核态，因此协程的切换速度非常快，可以实现高并发的处理能力。

代码简洁性：协程可以使用同步的写法实现异步的逻辑，代码看起来更像同步代码，易于理解和维护。

应用场景：

网络编程：协程常用于处理高并发的网络请求，如 Web 服务器、客户端网络库等。

异步 I/O：协程可以用于处理异步 I/O 操作，如文件读写、数据库查询等。

任务调度：协程可以用于实现任务调度系统，将任务分配给不同的协程执行，实现高效的并发处理。

示例代码：

在 Python 中，可以使用 asyncio 库来创建协程。下面是一个简单的协程示例，用于模拟异步的网络请求：

import asyncio

asyncdef fetch_data(url):
    print(f"Fetching {url}...")
    await asyncio.sleep(1)  # 模拟网络请求延迟
    returnf"Data from {url}"

asyncdef main():
    task1 = asyncio.create_task(fetch_data("https://example.com/1"))
    task2 = asyncio.create_task(fetch_data("https://example.com/2"))

    # 等待两个任务完成
    data1 = await task1
    data2 = await task2

    print(data1)
    print(data2)

# 运行协程
asyncio.run(main())