Advanced Python Features: Generators, Context Managers, Metaclasses, and More

Python is a high‑level programming language that provides many powerful features to help developers write efficient, concise, and maintainable code.

1. Generators are special iterators defined with the yield keyword; they produce items one at a time, saving memory for large or infinite sequences.

def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b
fib = fibonacci()
for _ in range(10):
    print(next(fib), end=' ')  # 输出前10个斐波那契数

2. Context Managers define a resource usage scope that automatically runs setup and teardown code (e.g., opening and closing files) via the with statement.

with open('example.txt', 'w') as file:
    file.write('Hello, world!')
    # 文件会在此处自动关闭

3. Metaclasses are “classes of classes” that control class creation; they let you customize class behavior such as adding methods or modifying inheritance.

class Meta(type):
    def __new__(cls, name, bases, dct):
        print("Creating class:", name)
        return super().__new__(cls, name, bases, dct)

class MyClass(metaclass=Meta):
    pass

4. Descriptors implement the protocol __get__ , __set__ , and __delete__ to manage attribute access on other objects.

class Descriptor:
    def __init__(self, initial_value=None):
        self.value = initial_value
    def __get__(self, instance, owner):
        return self.value
    def __set__(self, instance, value):
        self.value = value

class MyClass:
    descriptor = Descriptor()

obj = MyClass()
obj.descriptor = 10
print(obj.descriptor)  # 输出: 10

5. Coroutines form the basis of asynchronous programming; the async / await syntax introduced in Python 3.5 makes them easy to write.

import asyncio
async def main():
    print('Hello')
    await asyncio.sleep(1)
    print('World')
asyncio.run(main())

6. Data Classes (available from Python 3.7) simplify the creation of classes that primarily store data by automatically generating __init__ , __repr__ , and other methods.

from dataclasses import dataclass

@dataclass
class Point:
    x: float
    y: float

p = Point(1.0, 2.0)
print(p)  # 输出: Point(x=1.0, y=2.0)

7. Type Annotations let you specify expected data types for variables, function parameters, and return values, improving readability and enabling static analysis tools like mypy .

def greet(name: str) -> str:
    return f"Hello, {name}!"
result: str = greet("Alice")

8. Multiple Inheritance and Mixins allow a class to inherit from several parents; mixins are a design pattern used to add specific functionality without complex inheritance hierarchies.

class FlyMixin:
    def fly(self):
        print("Flying...")

class Bird(FlyMixin):
    pass

bird = Bird()
bird.fly()  # 输出: Flying...

9. Exception Chaining preserves the original exception when re‑raising a new one, making debugging easier.

try:
    # some code that may raise an exception
    raise ValueError("A value error occurred")
except Exception as e:
    raise RuntimeError("Something went wrong") from e

10. Modules and Packages organize code; a module is a single file of definitions, while a package groups multiple modules for better reuse.

# my_module.py

def say_hello():
    print("Hello from module!")

# 使用模块
import my_module
my_module.say_hello()

11. Itertools provides efficient iterator building blocks such as permutations , useful for combinatorial tasks.

from itertools import permutations
for p in permutations(['a', 'b', 'c']):
    print(p)

12. Regular Expressions (module re ) enable pattern matching, searching, and substitution in strings.

import re
pattern = r'\d+'  # 匹配一个或多个数字
text = "There are 123 apples and 456 oranges."
matches = re.findall(pattern, text)
print(matches)  # 输出: ['123', '456']

These advanced features demonstrate Python's flexibility and power, making it an ideal choice for a wide range of applications; mastering them helps you write more robust, scalable, and expressive code.