Django Web开发入门与实践指南-代码聚汇网

Django Web开发入门与实践指南

星空链结

1. 为什么选择Django作为Web开发起点

第一次接触Web开发的新手常会陷入框架选择的困境。作为一个从零开始搭建过十几个生产级项目的开发者，我强烈推荐Django作为入门首选。这不仅因为它"自带电池"的特性，更因为其设计哲学能帮你建立正确的Web开发思维。

Django采用MTV（Model-Template-View）模式，与传统的MVC稍有不同。模型层处理数据逻辑，模板层负责展示，视图层作为中间协调者。这种清晰的分离让初学者能快速理解Web应用的核心组件。我曾用Flask和Express做过对比项目，发现Django这种"约定优于配置"的方式，能减少新手在项目结构上的决策负担。

关键提示：Django的admin后台是它最被低估的功能。只需几行代码就能获得完整的数据管理界面，这对快速验证业务逻辑至关重要。

2. 开发环境搭建实战指南

2.1 Python环境配置陷阱

很多人会直接使用系统自带的Python，这是第一个要避免的坑。我推荐使用pyenv管理多版本Python环境。以下是经过验证的安装流程：

bash复制# 在Ubuntu系统下的安装示例
sudo apt-get update
sudo apt-get install -y make build-essential libssl-dev zlib1g-dev \
libbz2-dev libreadline-dev libsqlite3-dev wget curl llvm \
libncursesw5-dev xz-utils tk-dev libxml2-dev libxmlsec1-dev libffi-dev liblzma-dev

curl https://pyenv.run | bash
echo 'export PYENV_ROOT="$HOME/.pyenv"' >> ~/.bashrc
echo 'command -v pyenv >/dev/null || export PATH="$PYENV_ROOT/bin:$PATH"' >> ~/.bashrc
echo 'eval "$(pyenv init -)"' >> ~/.bashrc
exec "$SHELL"

pyenv install 3.10.6  # 选择Django官方推荐的Python版本
pyenv global 3.10.6

2.2 Django安装与项目创建

使用虚拟环境是Python开发的黄金准则。这是我总结的最佳实践：

bash复制python -m venv venv
source venv/bin/activate  # Linux/Mac
# venv\Scripts\activate  # Windows

pip install --upgrade pip
pip install django==4.2.3  # 使用LTS版本

# 创建项目时这个细节很重要
django-admin startproject core .  # 注意最后的点号，表示当前目录

经验之谈：永远不要在项目名称中使用连字符(-)，这会导致后续部署时出现各种诡异问题。使用下划线(_)或者驼峰命名。

3. 项目结构深度解析

3.1 标准目录结构及其演变

初始生成的Django项目结构看似简单，但蕴含着深思熟虑的设计：

code复制.
├── core/           # 项目配置目录
│   ├── __init__.py
│   ├── asgi.py     # 异步服务器网关接口
│   ├── settings.py # 核心配置文件
│   ├── urls.py     # URL路由入口
│   └── wsgi.py     # Web服务器网关接口
├── manage.py       # 项目管理脚本
└── venv/           # 虚拟环境目录

随着项目发展，我通常会进行这样的结构调整：

code复制.
├── apps/           # 自定义应用目录
│   ├── accounts/   # 用户系统
│   └── products/   # 业务模块
├── config/         # 拆分后的配置
│   ├── settings/
│   │   ├── base.py
│   │   ├── dev.py
│   │   └── prod.py
│   └── __init__.py
├── static/         # 静态资源
├── templates/      # 全局模板
└── requirements/   # 依赖管理
│   ├── base.txt
│   ├── dev.txt
│   └── prod.txt

3.2 settings.py关键配置详解

新手最常犯的错误是直接修改默认配置而不理解其影响。以下是必须掌握的配置项：

python复制# core/settings.py

# 安全警告：实际部署时必须修改！
SECRET_KEY = 'django-insecure-your-secret-key-here' 

# 调试模式开关
DEBUG = True  # 开发时开启，生产环境必须关闭！

# 允许的主机/域名
ALLOWED_HOSTS = []  # 开发时可留空，生产环境必须设置

# 应用注册顺序影响中间件执行顺序
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    # 你的自定义应用放在系统应用之后
]

# 数据库配置（SQLite为默认）
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}

# 静态文件配置
STATIC_URL = 'static/'
STATICFILES_DIRS = [BASE_DIR / "static"]  # 开发时静态文件目录

避坑指南：永远不要将DEBUG=True和ALLOWED_HOSTS=[]用于生产环境。我曾因此导致服务器遭受CSRF攻击。

4. 第一个Django应用的完整实现

4.1 创建博客应用

让我们通过一个博客系统来实践Django的核心功能：

bash复制python manage.py startapp blog

然后需要在settings.py中注册这个应用：

python复制INSTALLED_APPS = [
    ...
    'blog.apps.BlogConfig',  # 完整引用方式
]

4.2 模型设计实战

模型是Django最强大的部分之一。这是经过生产验证的博客模型设计：

python复制# blog/models.py
from django.db import models
from django.contrib.auth import get_user_model
from django.utils.text import slugify

User = get_user_model()

class Category(models.Model):
    name = models.CharField(max_length=50, unique=True)
    slug = models.SlugField(max_length=60, unique=True, blank=True)
    description = models.TextField(blank=True)

    def save(self, *args, **kwargs):
        if not self.slug:
            self.slug = slugify(self.name)
        super().save(*args, **kwargs)

    def __str__(self):
        return self.name

class Post(models.Model):
    DRAFT = 'draft'
    PUBLISHED = 'published'
    STATUS_CHOICES = [
        (DRAFT, 'Draft'),
        (PUBLISHED, 'Published'),
    ]
    
    title = models.CharField(max_length=200)
    slug = models.SlugField(max_length=220, unique_for_date='publish_date')
    content = models.TextField()
    author = models.ForeignKey(User, on_delete=models.CASCADE, related_name='blog_posts')
    category = models.ForeignKey(Category, on_delete=models.SET_NULL, null=True, blank=True)
    status = models.CharField(max_length=10, choices=STATUS_CHOICES, default=DRAFT)
    publish_date = models.DateTimeField(null=True, blank=True)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    
    class Meta:
        ordering = ['-publish_date']
        indexes = [
            models.Index(fields=['-publish_date']),
        ]
    
    def __str__(self):
        return self.title

创建并应用迁移：

bash复制python manage.py makemigrations
python manage.py migrate

4.3 视图与URL配置

Django的视图处理有多种方式，这是最灵活的类视图实现：

python复制# blog/views.py
from django.views.generic import ListView, DetailView
from .models import Post

class PostListView(ListView):
    model = Post
    template_name = 'blog/post_list.html'
    context_object_name = 'posts'
    paginate_by = 10
    
    def get_queryset(self):
        return Post.objects.filter(status=Post.PUBLISHED).select_related('author', 'category')

class PostDetailView(DetailView):
    model = Post
    template_name = 'blog/post_detail.html'
    context_object_name = 'post'
    
    def get_queryset(self):
        return super().get_queryset().select_related('author', 'category')

URL配置需要同时在项目和应用层面设置：

python复制# core/urls.py
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('blog/', include('blog.urls')),
]

python复制# blog/urls.py
from django.urls import path
from .views import PostListView, PostDetailView

app_name = 'blog'

urlpatterns = [
    path('', PostListView.as_view(), name='post_list'),
    path('<slug:slug>/', PostDetailView.as_view(), name='post_detail'),
]

4.4 模板系统实战

Django的模板语言(DTL)简单但强大。这是我总结的最佳目录结构：

code复制blog/
├── templates/
│   └── blog/       # 应用专属模板
│       ├── base.html
│       ├── post_list.html
│       └── post_detail.html

基础模板示例：

html复制<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{% block title %}My Blog{% endblock %}</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css" rel="stylesheet">
    {% block extra_css %}{% endblock %}
</head>
<body>
    <nav class="navbar navbar-expand-lg navbar-dark bg-dark">
        <div class="container">
            <a class="navbar-brand" href="{% url 'blog:post_list' %}">Django Blog</a>
        </div>
    </nav>

    <div class="container mt-4">
        {% block content %}{% endblock %}
    </div>

    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js"></script>
    {% block extra_js %}{% endblock %}
</body>
</html>

文章列表模板：

html复制{% extends "blog/base.html" %}

{% block title %}Blog Posts{% endblock %}

{% block content %}
    <h1 class="mb-4">Latest Posts</h1>
    
    <div class="row">
        {% for post in posts %}
        <div class="col-md-6 mb-4">
            <div class="card h-100">
                <div class="card-body">
                    <h2 class="card-title">
                        <a href="{% url 'blog:post_detail' post.slug %}" class="text-decoration-none">
                            {{ post.title }}
                        </a>
                    </h2>
                    <p class="card-text text-muted">
                        By {{ post.author.username }} | {{ post.publish_date|date:"F j, Y" }}
                    </p>
                    <p class="card-text">{{ post.content|truncatewords:30 }}</p>
                </div>
            </div>
        </div>
        {% empty %}
        <div class="col-12">
            <p>No posts available.</p>
        </div>
        {% endfor %}
    </div>
    
    {% include "blog/_pagination.html" %}
{% endblock %}

5. Django Admin深度定制

5.1 基础配置与安全

Django admin是快速获得后台管理界面的利器，但需要正确配置：

python复制# blog/admin.py
from django.contrib import admin
from .models import Category, Post

@admin.register(Post)
class PostAdmin(admin.ModelAdmin):
    list_display = ('title', 'author', 'category', 'status', 'publish_date')
    list_filter = ('status', 'category', 'publish_date')
    search_fields = ('title', 'content')
    prepopulated_fields = {'slug': ('title',)}
    raw_id_fields = ('author',)
    date_hierarchy = 'publish_date'
    ordering = ('status', '-publish_date')

@admin.register(Category)
class CategoryAdmin(admin.ModelAdmin):
    list_display = ('name', 'slug')
    prepopulated_fields = {'slug': ('name',)}

安全配置建议：

python复制# core/settings.py

# 自定义admin URL路径
ADMIN_URL = 'manage/'  # 不要使用默认的admin/

# 在urls.py中使用
urlpatterns = [
    path(settings.ADMIN_URL, admin.site.urls),
    # 其他URL...
]

5.2 高级定制技巧

通过重写admin模板可以完全改变界面外观。这是我的常用定制方法：

code复制templates/
└── admin/
    ├── base_site.html
    └── blog/
        └── post/
            └── change_form.html

覆盖基础模板 (base_site.html)：

html复制{% extends "admin/base.html" %}

{% block title %}{{ title }} | My Site Admin{% endblock %}

{% block branding %}
<h1 id="site-name">
    <a href="{% url 'admin:index' %}">My Blog Administration</a>
</h1>
{% endblock %}

{% block nav-global %}{% endblock %}

添加富文本编辑器支持：

python复制# blog/admin.py
from django import forms
from django.db import models

class PostAdminForm(forms.ModelForm):
    class Meta:
        model = Post
        widgets = {
            'content': forms.Textarea(attrs={'class': 'ckeditor'}),
        }
        fields = '__all__'

@admin.register(Post)
class PostAdmin(admin.ModelAdmin):
    form = PostAdminForm
    class Media:
        css = {
            'all': ('css/admin.css',)
        }
        js = (
            'https://cdn.ckeditor.com/4.16.2/standard/ckeditor.js',
            'js/admin.js',
        )

6. 生产环境部署要点

6.1 安全配置清单

部署前必须检查的安全设置：

python复制# core/settings.py

# 生产环境必须修改
DEBUG = False

# 必须设置允许的主机
ALLOWED_HOSTS = ['yourdomain.com', 'www.yourdomain.com']

# 安全中间件
SECURE_BROWSER_XSS_FILTER = True
SECURE_CONTENT_TYPE_NOSNIFF = True
SECURE_HSTS_SECONDS = 31536000  # 1年
SECURE_HSTS_INCLUDE_SUBDOMAINS = True
SECURE_HSTS_PRELOAD = True
SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https')
SECURE_SSL_REDIRECT = True
SESSION_COOKIE_SECURE = True
CSRF_COOKIE_SECURE = True

# 数据库配置建议
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'mydatabase',
        'USER': 'mydatabaseuser',
        'PASSWORD': 'mypassword',
        'HOST': 'localhost',
        'PORT': '5432',
    }
}

# 静态文件配置
STATIC_ROOT = '/var/www/static/'
STATIC_URL = '/static/'
MEDIA_ROOT = '/var/www/media/'
MEDIA_URL = '/media/'

6.2 Nginx + Gunicorn部署方案

这是经过验证的生产级部署方案：

安装依赖：

bash复制sudo apt-get update
sudo apt-get install -y nginx postgresql libpq-dev python3-dev
pip install gunicorn psycopg2-binary

Gunicorn服务文件 (/etc/systemd/system/gunicorn.service)：

ini复制[Unit]
Description=gunicorn daemon
After=network.target

[Service]
User=ubuntu
Group=www-data
WorkingDirectory=/path/to/your/project
ExecStart=/path/to/venv/bin/gunicorn --access-logfile - --workers 3 --bind unix:/run/gunicorn.sock core.wsgi:application

[Install]
WantedBy=multi-user.target

Nginx配置 (/etc/nginx/sites-available/yourdomain)：

nginx复制server {
    listen 80;
    server_name yourdomain.com www.yourdomain.com;

    location = /favicon.ico { access_log off; log_not_found off; }
    
    location /static/ {
        root /var/www;
    }
    
    location /media/ {
        root /var/www;
    }
    
    location / {
        include proxy_params;
        proxy_pass http://unix:/run/gunicorn.sock;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

启用配置并重启服务：

bash复制sudo ln -s /etc/nginx/sites-available/yourdomain /etc/nginx/sites-enabled
sudo systemctl restart nginx
sudo systemctl start gunicorn
sudo systemctl enable gunicorn

7. 性能优化实战技巧

7.1 数据库查询优化

Django ORM强大但容易产生性能问题。这是我总结的黄金法则：

总是使用select_related和prefetch_related：

python复制# 错误方式 - 会产生N+1查询问题
posts = Post.objects.filter(status=Post.PUBLISHED)
for post in posts:
    print(post.author.username)  # 每次循环都会查询数据库

# 正确方式
posts = Post.objects.filter(status=Post.PUBLISHED).select_related('author')

使用only()和defer()控制字段加载：

python复制# 只加载需要的字段
posts = Post.objects.only('title', 'publish_date')

# 延迟加载大字段
posts = Post.objects.defer('content')

批量操作代替循环：

python复制# 错误方式 - 每次save()都会产生一次查询
for post in Post.objects.all():
    post.slug = slugify(post.title)
    post.save()

# 正确方式 - 批量更新
from django.db.models import F
Post.objects.update(slug=F('title'))  # 使用数据库函数

# 或者使用bulk_update
posts = list(Post.objects.all())
for post in posts:
    post.slug = slugify(post.title)
Post.objects.bulk_update(posts, ['slug'])

7.2 缓存策略实施

Django提供多级缓存系统。这是我的生产环境配置：

python复制# core/settings.py

# 数据库缓存
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
        'LOCATION': 'my_cache_table',
        'TIMEOUT': 60*15,  # 15分钟
        'OPTIONS': {
            'MAX_ENTRIES': 1000
        }
    }
}

# 视图缓存示例
from django.views.decorators.cache import cache_page

@cache_page(60 * 15)  # 缓存15分钟
def my_view(request):
    # 视图逻辑

模板片段缓存：

html复制{% load cache %}

{% cache 500 sidebar %}
    <div class="sidebar">
        {% include "blog/_categories.html" %}
        {% include "blog/_recent_posts.html" %}
    </div>
{% endcache %}

8. 测试驱动开发实践

8.1 单元测试编写规范

Django内置测试框架非常强大。这是我采用的测试结构：

code复制blog/
├── tests/
│   ├── __init__.py
│   ├── test_models.py
│   ├── test_views.py
│   └── test_forms.py

模型测试示例：

python复制from django.test import TestCase
from django.contrib.auth import get_user_model
from .models import Category, Post

User = get_user_model()

class PostModelTest(TestCase):
    @classmethod
    def setUpTestData(cls):
        cls.user = User.objects.create_user(
            username='testuser',
            password='testpass123'
        )
        cls.category = Category.objects.create(
            name='Technology',
            description='Tech related posts'
        )
        cls.post = Post.objects.create(
            title='Test Post',
            content='This is a test content',
            author=cls.user,
            category=cls.category,
            status=Post.PUBLISHED
        )
    
    def test_post_creation(self):
        self.assertEqual(self.post.title, 'Test Post')
        self.assertEqual(self.post.status, 'published')
        self.assertEqual(str(self.post), 'Test Post')
    
    def test_post_url(self):
        self.assertEqual(
            self.post.get_absolute_url(),
            f'/blog/{self.post.slug}/'
        )
    
    def test_post_publish_date(self):
        self.assertIsNotNone(self.post.publish_date)

8.2 集成测试与CI/CD

使用pytest-django进行更灵活的测试：

python复制# tests/test_views.py
import pytest
from django.urls import reverse

@pytest.mark.django_db
def test_post_list_view(client):
    url = reverse('blog:post_list')
    response = client.get(url)
    assert response.status_code == 200
    assert 'posts' in response.context

@pytest.mark.django_db
def test_post_detail_view(client, post):
    url = reverse('blog:post_detail', kwargs={'slug': post.slug})
    response = client.get(url)
    assert response.status_code == 200
    assert response.context['post'] == post

GitHub Actions CI配置示例 (.github/workflows/test.yml)：

yaml复制name: Django CI

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    services:
      postgres:
        image: postgres:13
        env:
          POSTGRES_USER: postgres
          POSTGRES_PASSWORD: postgres
        ports:
          - 5432:5432
        options: --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5
    
    steps:
      - uses: actions/checkout@v2
      - name: Set up Python
        uses: actions/setup-python@v2
        with:
          python-version: '3.10'
      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install -r requirements.txt
          pip install pytest pytest-django
      - name: Run tests
        env:
          DATABASE_URL: postgres://postgres:postgres@localhost:5432/postgres
          DJANGO_SECRET_KEY: testkey
        run: |
          pytest

9. 项目扩展与进阶路线

9.1 添加REST API接口

使用Django REST Framework扩展API功能：

安装配置：

bash复制pip install djangorestframework

python复制# core/settings.py
INSTALLED_APPS = [
    ...
    'rest_framework',
]

创建序列化器：

python复制# blog/serializers.py
from rest_framework import serializers
from .models import Post, Category

class CategorySerializer(serializers.ModelSerializer):
    class Meta:
        model = Category
        fields = ['id', 'name', 'slug']

class PostSerializer(serializers.ModelSerializer):
    category = CategorySerializer(read_only=True)
    
    class Meta:
        model = Post
        fields = ['id', 'title', 'slug', 'content', 'author', 'category', 'status', 'publish_date']

创建视图集：

python复制# blog/views.py
from rest_framework import viewsets
from .models import Post
from .serializers import PostSerializer

class PostViewSet(viewsets.ModelViewSet):
    queryset = Post.objects.filter(status=Post.PUBLISHED).select_related('author', 'category')
    serializer_class = PostSerializer
    lookup_field = 'slug'

配置路由：

python复制# core/urls.py
from django.urls import path, include
from rest_framework.routers import DefaultRouter
from blog.views import PostViewSet

router = DefaultRouter()
router.register(r'api/posts', PostViewSet, basename='post')

urlpatterns = [
    ...
    path('', include(router.urls)),
]

9.2 异步任务处理

使用Celery处理后台任务：

安装配置：

bash复制pip install celery redis

python复制# core/celery.py
import os
from celery import Celery

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'core.settings')

app = Celery('core')
app.config_from_object('django.conf:settings', namespace='CELERY')
app.autodiscover_tasks()

任务示例：

python复制# blog/tasks.py
from celery import shared_task
from django.core.mail import send_mail
from django.conf import settings

@shared_task
def send_new_post_notification(post_id):
    from .models import Post
    post = Post.objects.get(id=post_id)
    
    subject = f'New Post Published: {post.title}'
    message = f'Check out our new post: {post.title}\n\n{post.content[:200]}...'
    send_mail(
        subject,
        message,
        settings.DEFAULT_FROM_EMAIL,
        ['subscribers@example.com'],
        fail_silently=False,
    )

在视图中调用：

python复制# blog/views.py
from .tasks import send_new_post_notification

def publish_post(request, post_id):
    post = get_object_or_404(Post, id=post_id)
    post.status = Post.PUBLISHED
    post.save()
    
    # 异步发送通知
    send_new_post_notification.delay(post.id)
    
    return redirect('blog:post_list')

10. 常见问题解决方案

10.1 静态文件加载问题

开发和生产环境静态文件配置差异是常见痛点。我的解决方案：

开发环境配置：

python复制# core/settings.py
STATIC_URL = '/static/'
STATICFILES_DIRS = [BASE_DIR / "static"]

生产环境配置：

bash复制# 收集静态文件
python manage.py collectstatic

Nginx配置：

nginx复制location /static/ {
    alias /path/to/static/root/;
    expires 30d;
    access_log off;
}

10.2 数据库连接问题

PostgreSQL常见连接问题解决：

检查连接设置：

python复制DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'mydb',
        'USER': 'myuser',
        'PASSWORD': 'mypassword',
        'HOST': 'localhost',
        'PORT': '5432',
        'CONN_MAX_AGE': 600,  # 连接池保持时间
    }
}

连接池配置：

bash复制pip install django-db-geventpool

python复制DATABASES = {
    'default': {
        'ENGINE': 'django_db_geventpool.backends.postgresql',
        'NAME': 'mydb',
        'USER': 'myuser',
        'PASSWORD': 'mypassword',
        'HOST': 'localhost',
        'PORT': '5432',
        'CONN_MAX_AGE': 0,
        'OPTIONS': {
            'MAX_CONNS': 20,
            'REUSE_CONNS': 10
        }
    }
}

10.3 时区问题处理

Django时区配置要点：

python复制# core/settings.py
TIME_ZONE = 'Asia/Shanghai'  # 根据实际时区设置
USE_TZ = True  # 推荐设置为True

# 模型中使用时区感知的datetime
from django.utils import timezone

class Post(models.Model):
    # ...
    def publish(self):
        self.publish_date = timezone.now()
        self.save()

11. 项目优化与监控

11.1 性能监控配置

使用Django Debug Toolbar进行开发优化：

安装配置：

bash复制pip install django-debug-toolbar

python复制# core/settings.py
INSTALLED_APPS = [
    ...
    'debug_toolbar',
]

MIDDLEWARE = [
    ...
    'debug_toolbar.middleware.DebugToolbarMiddleware',
]

INTERNAL_IPS = ['127.0.0.1']

生产环境监控：

bash复制pip install sentry-sdk

python复制# core/settings.py
import sentry_sdk
from sentry_sdk.integrations.django import DjangoIntegration

sentry_sdk.init(
    dsn="your-sentry-dsn",
    integrations=[DjangoIntegration()],
    traces_sample_rate=1.0,
    send_default_pii=True
)

11.2 日志配置最佳实践

生产环境日志配置方案：

python复制# core/settings.py
LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'verbose': {
            'format': '{levelname} {asctime} {module} {process:d} {thread:d} {message}',
            'style': '{',
        },
        'simple': {
            'format': '{levelname} {message}',
            'style': '{',
        },
    },
    'handlers': {
        'file': {
            'level': 'DEBUG',
            'class': 'logging.FileHandler',
            'filename': '/var/log/django/debug.log',
            'formatter': 'verbose'
        },
        'mail_admins': {
            'level': 'ERROR',
            'class': 'django.utils.log.AdminEmailHandler',
            'include_html': True,
        }
    },
    'loggers': {
        'django': {
            'handlers': ['file'],
            'level': 'INFO',
            'propagate': True,
        },
        'blog': {
            'handlers': ['file', 'mail_admins'],
            'level': 'DEBUG',
            'propagate': False,
        },
    },
}

12. 持续学习资源推荐

12.1 官方文档精要

Django官方文档 - 从教程开始，重点阅读"模型层"和"表单"部分
Django REST Framework文档 - 掌握API开发核心概念
Celery文档 - 理解异步任务处理机制

12.2 进阶书籍与课程

《Django for Professionals》 - 从开发到部署的全流程指南
《Two Scoops of Django》 - Django最佳实践大全
Udemy课程《Python Django Dev To Deployment》 - 项目驱动学习

12.3 社区与问答

Django官方论坛：解决特定问题的好地方
Stack Overflow的Django标签：积累了大量高质量问答
GitHub上的开源项目：学习真实项目代码结构

我在实际项目中最大的体会是：Django的"约定优于配置"哲学看似限制了灵活性，实则通过标准化帮你避免了无数潜在的架构错误。刚开始可能会觉得框架"管得太多"，但随着项目规模扩大，你会越来越感激这种设计决策带来的可维护性优势。