1.2.2 高级特性详解——AI教你学Django

1.2.2 高级特性详解（Django 基础学习细节）

Python 的高级特性如装饰器、生成器、迭代器和上下文管理器，是提升代码复用性、灵活性和可维护性的利器。Django 中间件、视图、ORM等大量用到这些技术。下面详细讲解每一项，并给出丰富代码示例。

一、装饰器（Decorator）

装饰器是对函数或类进行"包装"以增强功能的语法，常用于日志、权限、缓存、性能统计等场景。

1. 函数装饰器

1.1 基本函数装饰器

def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("函数开始执行")
        result = func(*args, **kwargs)
        print("函数执行结束")
        return result
    return wrapper

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

greet("Alice")
# 输出:
# 函数开始执行
# Hello, Alice
# 函数执行结束

1.2 多个装饰器（从下往上执行）

def deco1(func):
    def wrapper(*args, **kwargs):
        print("deco1")
        return func(*args, **kwargs)
    return wrapper

def deco2(func):
    def wrapper(*args, **kwargs):
        print("deco2")
        return func(*args, **kwargs)
    return wrapper

@deco1
@deco2
def foo():
    print("foo body")

foo()
# 输出:
# deco1
# deco2
# foo body

1.3 保持原函数元数据（推荐用 functools.wraps）

import functools

def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print(f"call {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

@log
def add(a, b):
    "Adds two numbers"
    return a + b

print(add.__name__)      # add
print(add.__doc__)       # Adds two numbers

2. 参数化装饰器（带参数的装饰器）

def repeat(n):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(n):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat(3)
def hi():
    print("Hi!")

hi()
# 输出三次 Hi!

3. 类装饰器

• 用类实现装饰器，适合复杂状态管理

class Counter:
    def __init__(self, func):
        self.func = func
        self.count = 0

    def __call__(self, *args, **kwargs):
        self.count += 1
        print(f"调用次数: {self.count}")
        return self.func(*args, **kwargs)

@Counter
def show(name):
    print(f"Hello, {name}")

show("Tom")  # 调用次数: 1
show("Ann")  # 调用次数: 2

二、生成器与 yield、迭代器

1. 生成器函数（yield）

• 用 yield 返回一个生成器对象，能"惰性"产出数据，节省内存。

def count_up(n):
    i = 1
    while i <= n:
        yield i
        i += 1

gen = count_up(3)
print(next(gen))  # 1
print(next(gen))  # 2
print(next(gen))  # 3
# next(gen)  # StopIteration异常

1.1 用 for 遍历生成器

for num in count_up(5):
    print(num)
# 输出 1 2 3 4 5

2. 列表生成 vs 生成器表达式

lst = [x*x for x in range(1000)]     # 占用大量内存
gen = (x*x for x in range(1000))     # 生成器，内存高效

for val in gen:
    print(val)

3. 自定义迭代器

• 实现 __iter__ 和 __next__ 方法

class MyRange:
    def __init__(self, start, end):
        self.cur = start
        self.end = end

    def __iter__(self):
        return self

    def __next__(self):
        if self.cur < self.end:
            val = self.cur
            self.cur += 1
            return val
        else:
            raise StopIteration

for i in MyRange(10, 13):
    print(i)
# 输出: 10 11 12

三、上下文管理器（with 语法）、自定义

1. 内建上下文管理器：文件操作

with open("test.txt", "w") as f:
    f.write("hello world")
# 自动关闭文件，无需手动 f.close()

2. 自定义上下文管理器（类实现）

• 需实现 __enter__ 和 __exit__ 方法

class MyContext:
    def __enter__(self):
        print("进入上下文")
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("离开上下文")

with MyContext():
    print("处理中")
# 输出:
# 进入上下文
# 处理中
# 离开上下文

3. 异常处理

• __exit__ 接收异常信息，能决定是否吞掉异常

class SafeOpen:
    def __init__(self, filename):
        self.filename = filename
        self.file = None

    def __enter__(self):
        self.file = open(self.filename, "w")
        return self.file

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.file.close()
        if exc_type:
            print(f"发生异常: {exc_val}")
        return True  # 异常不再向外抛出

with SafeOpen("demo.txt") as f:
    f.write("Hello")
    raise Exception("测试异常")
# 输出: 发生异常: 测试异常

4. 使用 contextlib 简化上下文管理器

from contextlib import contextmanager

@contextmanager
def tag(name):
    print(f"<{name}>")
    yield
    print(f"</{name}>")

with tag("div"):
    print("这是内容")
# 输出:
# <div>
# 这是内容
# </div>

四、实用小结

• 装饰器让函数/类扩展更灵活，Django 中间件、权限控制大量用到
• 生成器和迭代器能处理大数据流，节省内存，Django QuerySet 就是惰性迭代器
• 上下文管理器保证资源安全释放，是处理文件、数据库连接等场景的最佳选择
• 推荐掌握各类高级特性，可在实际项目中写出更优雅、可维护的代码