1. 使用Flask的蓝图(Blueprints)

Flask的蓝图是实现模块化的核心工具：

# app/main/__init__.py
from flask import Blueprint

main = Blueprint('main', __name__)

from . import views, errors

# app/main/views.py
from . import main

@main.route('/')
def index():
    return 'Hello World!'

@main.route('/about')
def about():
    return 'About Page'

# app/main/errors.py
from . import main

@main.app_errorhandler(404)
def page_not_found(e):
    return 'Page not found', 404

2. 使用Django的应用(Apps)

Django天生支持模块化开发：

# 创建应用
python manage.py startapp blog
python manage.py startapp users

# blog/models.py
from django.db import models

class Post(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

# blog/views.py
from django.shortcuts import render
from .models import Post

def post_list(request):
    posts = Post.objects.all()
    return render(request, 'blog/post_list.html', {'posts': posts})

3. 项目结构组织

推荐的项目结构：

myproject/
├── app/
│   ├── __init__.py
│   ├── main/
│   │   ├── __init__.py
│   │   ├── views.py
│   │   ├── forms.py
│   │   └── templates/
│   ├── auth/
│   │   ├── __init__.py
│   │   ├── views.py
│   │   └── templates/
│   └── api/
│       ├── __init__.py
│       └── v1/
├── config.py
├── requirements.txt
└── run.py

4. 配置管理模块化

# config.py
import os

class Config:
    SECRET_KEY = os.environ.get('SECRET_KEY') or 'hard-to-guess-string'
    SQLALCHEMY_TRACK_MODIFICATIONS = False

class DevelopmentConfig(Config):
    DEBUG = True
    SQLALCHEMY_DATABASE_URI = 'sqlite:///dev.db'

class ProductionConfig(Config):
    SQLALCHEMY_DATABASE_URI = os.environ.get('DATABASE_URL')

config = {
    'development': DevelopmentConfig,
    'production': ProductionConfig,
    'default': DevelopmentConfig
}

5. 路由模块化

# app/__init__.py
from flask import Flask
from .main import main as main_blueprint
from .auth import auth as auth_blueprint
from .api import api as api_blueprint

def create_app(config_name='default'):
    app = Flask(__name__)
    app.config.from_object(config[config_name])

    # 注册蓝图
    app.register_blueprint(main_blueprint)
    app.register_blueprint(auth_blueprint, url_prefix='/auth')
    app.register_blueprint(api_blueprint, url_prefix='/api/v1')

    return app

6. 工具函数模块化

# utils/validators.py
import re

def is_valid_email(email):
    pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
    return re.match(pattern, email) is not None

def is_valid_password(password):
    return len(password) >= 8

# utils/helpers.py
from datetime import datetime

def format_date(date_obj):
    return date_obj.strftime('%Y-%m-%d %H:%M')

def generate_slug(text):
    return text.lower().replace(' ', '-')

7. API模块化

# app/api/v1/__init__.py
from flask import Blueprint

api = Blueprint('api', __name__)

from . import users, posts, comments

# app/api/v1/users.py
from . import api
from flask import jsonify

@api.route('/users')
def get_users():
    return jsonify({'users': []})

@api.route('/users/<int:id>')
def get_user(id):
    return jsonify({'user': {'id': id}})

8. 中间件模块化

# middleware/authentication.py
from flask import request, jsonify
from functools import wraps

def token_required(f):
    @wraps(f)
    def decorated(*args, **kwargs):
        token = request.headers.get('Authorization')
        if not token:
            return jsonify({'error': 'Token is missing'}), 401
        # 验证token逻辑
        return f(*args, **kwargs)
    return decorated

# middleware/logging.py
import logging
from flask import request

def log_requests(app):
    @app.before_request
    def log_request_info():
        app.logger.info(f'{request.method} {request.path}')

9. 测试模块化

# tests/test_auth.py
import unittest
from app import create_app
from app.models import User

class AuthTestCase(unittest.TestCase):
    def setUp(self):
        self.app = create_app('testing')
        self.client = self.app.test_client()

    def test_user_registration(self):
        response = self.client.post('/auth/register', data={
            'email': 'test@example.com',
            'password': 'password123'
        })
        self.assertEqual(response.status_code, 201)

10. 依赖管理

使用requirements.txt模块化：

# requirements/base.txt
Flask==2.0.1
SQLAlchemy==1.4.0

# requirements/dev.txt
-r base.txt
pytest==6.2.0
flake8==3.9.0

# requirements/prod.txt
-r base.txt
gunicorn==20.1.0

最佳实践

1. 单一职责原则：每个模块只负责一个特定功能

2. 明确接口：模块之间通过清晰的接口通信

3. 依赖倒置：高层模块不依赖低层模块，都依赖抽象

4. 配置分离：将配置信息从代码中分离

5. 测试独立：每个模块都应该有独立的测试

这样的模块化结构让你的网站应用更易于维护、测试和扩展。根据项目规模选择合适的模块化程度，避免过度设计。