学Django前要补哪些Python基础：装饰器与类的使用

很多初学者在掌握了 Python 的变量、循环、列表和简单函数后，便直接开始阅读 Django 官方教程或搭建项目。然而在接触到路由保护、ORM 数据库模型以及通用类视图（CBV）时，往往会陷入一种“照着文档敲代码能运行，但稍微改动就报错且完全不知道底层在做什么”的困境。这种障碍通常不是因为 Django 框架本身晦涩，而是由于对 Python 进阶核心特性的理解出现了断层。在进入 Django 开发之前，最需要夯实的两个核心语法基础正是装饰器（Decorator）与面向对象中的类（Class）。

一、为什么装饰器和类是学 Django 的前置刚需

Django 是一个典型的“约定优于配置”且高度面向对象的现代 Web 框架。它并没有发明新的语法，而是把 Python 本身的高阶特性运用到了极致：

• 权限与切面控制依赖装饰器：在编写处理网络请求的视图函数时，登录鉴权（@login_required）、请求方式限定（@require_POST）、访问频率限制以及缓存控制，全部以装饰器形式挂载在视图上方。如果不理解装饰器的本质是函数包装与拦截，就无法灵活编写自定义的鉴权逻辑。
• 数据建模与视图扩展依赖类与继承：Django 的 ORM 核心是让每个数据库表对应一个 Python 类（继承自 models.Model）；而在处理复杂业务流程时，基于类的视图（CBV，继承自 View 或其子类）更是通过继承和重写父类钩子方法来复用通用逻辑。不清楚类属性与实例属性的区别、不熟悉 super() 的调用机制，就无法正确扩展 Django 内置功能。

二、装饰器必备功底：从闭包到权限拦截

在 Python 中，函数是“第一类对象”（First-class Object），这意味着函数可以像普通变量一样作为参数传递给其他函数，也可以作为另一个函数的返回值。理解装饰器，需要逐步打通以下三个层级：

1. 掌握闭包（Closure）的形成与变量捕获

闭包是指在一个内部函数中引用了外部作用域（但非全局）的变量，并且外部函数返回了这个内部函数。闭包能够让内部函数保存定义时的上下文环境：

def make_checker(allowed_role):
    # 外部函数接收参数
    def checker(user_role):
        # 内部函数引用了外部变量 allowed_role
        return user_role == allowed_role
    return checker

is_admin = make_checker("admin")
print(is_admin("admin"))  # 输出: True
print(is_admin("guest"))  # 输出: False

2. 编写标准装饰器与保留元数据

装饰器的语法糖 @decorator 本质上就是执行 func = decorator(func)。在编写装饰器时，必须使用 functools.wraps，否则原函数的名称（__name__）和文档（__doc__）会被内层 wrapper 替换，这在 Django 依据视图函数名生成反向解析 URL 时会引发严重隐患：

from functools import wraps

def time_it(view_func):
    """统计视图执行耗时的装饰器示例"""
    @wraps(view_func)
    def wrapper(request, *args, **kwargs):
        import time
        start_time = time.time()
        # 必须把原始参数无损传递给被装饰的函数
        response = view_func(request, *args, **kwargs)
        duration = time.time() - start_time
        print(f"视图 [{view_func.__name__}] 耗时: {duration:.4f}s")
        return response
    return wrapper

@time_it
def article_list(request):
    return "渲染文章列表"

3. 理解 Django 自定义权限装饰器

Django 自带的 @login_required 底层也是一个带参数的装饰器。如果在学 Django 前能够自己写出一个简单的权限检查装饰器，在实际开发中面对“特定 VIP 才能查看文章”或“限制特定 IP 访问”的需求时便能游刃有余：

from functools import wraps

def require_role(role_name):
    """带参数的装饰器：用于校验用户角色"""
    def decorator(view_func):
        @wraps(view_func)
        def wrapper(request, *args, **kwargs):
            # 模拟 Django request.user 的权限判断
            user = getattr(request, 'user', None)
            if not user or user.get('role') != role_name:
                return "403 Forbidden: 权限不足"
            return view_func(request, *args, **kwargs)
        return wrapper
    return decorator

三、面向对象进阶：从基础类到 Django 核心架构

很多 Python 基础教程在讲解类时，仅仅停留在“定义一个 Dog 类并调用 bark 方法”的阶段。但在 Django 中，类是组织数据结构和复杂业务流的核心骨架。你必须熟练掌握以下面向对象机制：

1. 深刻理解“类属性”与“实例属性”

很多新手会疑惑：为什么在普通 Python 代码中，属性都是在 __init__ 里面通过 self.name = ... 赋值，但在 Django 的 Model 中，字段却是直接写在类体下面的？

# Python 原生机制对比
class Book:
    # 这是类属性：属于整个类，所有实例共享同一份定义
    category = "IT"

    def __init__(self, title):
        # 这是实例属性：属于具体某个对象
        self.title = title

# Django ORM 正是利用类属性来声明数据表结构
from django.db import models

class Article(models.Model):
    # 类属性：Django 的元类会在类创建时扫描这些字段，生成数据库列结构
    title = models.CharField(max_length=100)
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

在 Django 中，字段对象并不是单篇文章的数据本身，而是用来定义表的列规则的描述符。只有当实例化具体对象时（如 article = Article(title="Python基础")），实例才拥有具体的字段数据。分不清类属性和实例属性，就会对 ORM 的声明式语法感到困惑。

2. 继承与重写：正确使用 super()

在 Django 中，无论是自定义 ORM 模型的保存逻辑，还是使用类视图处理请求，都需要在子类中重写父类的方法。而调用 super() 是保证框架原有逻辑正常执行的关键：

class Article(models.Model):
    title = models.CharField(max_length=100)
    slug = models.SlugField(blank=True)

    def save(self, *args, **kwargs):
        # 扩展自定义业务：在保存前自动生成 slug
        if not self.slug:
            from django.utils.text import slugify
            self.slug = slugify(self.title)
        
        # 必须调用父类的 save 方法，真正写入数据库
        super().save(*args, **kwargs)

如果不调用 super().save(*args, **kwargs)，Django 底层的真正持久化代码就不会被执行，数据根本无法存入数据库。在类视图中也是如此，重写 get_context_data 时必须先调用 super().get_context_data(**kwargs) 获取基础上下文字典，再在上面追加自己的键值。

四、关键结合点：在类视图中使用装饰器的正确方式

当装饰器遇上面向对象的类视图（CBV），许多初学者会犯同一个直觉性错误：直接把普通函数装饰器加在类视图的方法或者类定义上，结果导致报错。

1. 为什么普通函数装饰器不能直接挂在类方法上？

普通的视图函数装饰器接收的第一个参数是 request：

def my_decorator(func):
    def wrapper(request, *args, **kwargs):
        ...
        return func(request, *args, **kwargs)
    return wrapper

但是类视图中的方法（如 def get(self, request, *args, **kwargs)）的第一个参数是实例对象 self，第二个参数才是 request。如果直接把 @my_decorator 挂在 get 方法上，装饰器内的 request 实际上接到的会是 self，从而引发参数错位异常。

2. Django 官方方案：method_decorator

为了抹平函数装饰器与类方法之间参数签名的差异，Django 提供了专用的工具 method_decorator。它能把针对函数的装饰器无缝转变为适合类方法调用的装饰器：

在类视图中，所有请求都会先经过 dispatch() 方法，再由该方法分发给具体的 get()、post()。因此，将装饰器挂载在 dispatch 上是最通用且优雅的做法：

from django.views import View
  from django.utils.decorators import method_decorator
  from django.contrib.auth.decorators import login_required
  from django.http import HttpResponse

  # 方式 1：直接在类上声明并指定目标方法为 dispatch
  @method_decorator(login_required, name='dispatch')
  class ProtectedProfileView(View):
      def get(self, request):
          return HttpResponse(f"欢迎你，{request.user.username}")

      def post(self, request):
          return HttpResponse("更新资料成功")

五、学前自测对照清单

在正式开启 Django 项目之前，可以通过以下对照清单来检查自己的 Python 进阶技能是否已经就绪：

只要花上一到两天时间，针对上述四个模块亲手编写几个最小可运行的原生 Python 脚本，再去读 Django 的官方文档，就会发现原本晦涩的框架黑魔法，本质上不过是严谨优美的 Python 面向对象与高阶函数设计。打牢这两大基石，才能在后续的 Web 开发中真正做到游刃有余。