1

pip install flask

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

from flask import Flask

# 创建 Flask 应用实例
# 这里的 __name__ 参数告诉 Flask 你的模块位置
# 这样它才能找到模板和静态文件
app = Flask(__name__)

# 定义路由：访问根路径时返回 "Hello, World!"
@app.route('/')
def hello():
    return 'Hello, World!'

# 程序入口
if __name__ == '__main__':
    # debug=True 开启调试模式，修改代码后自动重载
    app.run(debug=True, host='0.0.0.0', port=5000)
    # 现在打开浏览器访问 http://127.0.0.1:5000 就能看到效果了

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

from flask import Flask

app = Flask(__name__)

# 最简单的路由：根路径
@app.route('/')
def index():
    return '这是首页'

# 访问 /about 就看到这个函数
@app.route('/about')
def about():
    return '这是关于页面'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

from flask import Flask

app = Flask(__name__)

# <变量名> 定义路径参数，类型默认是字符串
@app.route('/user/<username>')
def show_user_profile(username):
    # username 会自动传递给函数参数
    return f'用户资料：{username}'

# <int:参数名> 限制参数必须是整数
@app.route('/post/<int:post_id>')
def show_post(post_id):
    # post_id 会是整数类型，而不是字符串
    return f'文章ID：{post_id}，类型是 {type(post_id).__name__}'

# <float:参数名> 限制参数必须是浮点数
@app.route('/price/<float:price>')
def show_price(price):
    return f'价格：{price} 元'

# <path:参数名> 匹配包含斜杠的路径（用于嵌套路径）
@app.route('/files/<path:filepath>')
def show_file(filepath):
    return f'文件路径：{filepath}'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

from flask import Flask, request

app = Flask(__name__)

# methods 参数指定允许的 HTTP 方法
@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        # 获取表单数据
        username = request.form.get('username')
        password = request.form.get('password')
        return f'登录成功：用户名={username}'
    else:
        return '请通过 POST 方法提交登录表单'

# 只接受 GET 请求（默认就是 GET）
@app.route('/search', methods=['GET'])
def search():
    # 获取 URL 查询参数（?key=value）
    query = request.args.get('q', '')
    return f'搜索关键词：{query}'

# RESTful 风格示例
@app.route('/books/<int:book_id>', methods=['GET', 'PUT', 'DELETE'])
def book_detail(book_id):
    if request.method == 'GET':
        return f'获取书籍 {book_id} 的详情'
    elif request.method == 'PUT':
        return f'更新书籍 {book_id}'
    elif request.method == 'DELETE':
        return f'删除书籍 {book_id}'

1
2
3
4
5
6
7
8

# GET 请求（浏览器直接访问）
curl http://127.0.0.1:5000/search?q=Python
→ 搜索关键词：Python

# POST 请求
curl -X POST http://127.0.0.1:5000/login \
  -d "username=admin&password=123456"
→ 登录成功：用户名=admin

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

from flask import Flask, request

app = Flask(__name__)

@app.route('/demo', methods=['POST'])
def demo_request():
    # 1. 获取查询参数（URL 中 ? 后面的部分）
    # 例如：/demo?page=1&limit=10
    page = request.args.get('page', 1)        # type: ignore
    limit = request.args.get('limit', 10)

    # 2. 获取表单数据（POST 表单提交）
    username = request.form.get('username')
    password = request.form.get('password')

    # 3. 获取 JSON 数据（API 请求常用）
    # Content-Type: application/json
    json_data = request.get_json()
    email = json_data.get('email') if json_data else None

    # 4. 获取请求头信息
    user_agent = request.headers.get('User-Agent')
    auth_token = request.headers.get('Authorization')

    # 5. 获取 URL 路径和完整 URL
    path = request.path          # 例如：/demo
    full_url = request.url       # 例如：http://127.0.0.1:5000/demo?page=1

    # 6. 获取上传的文件
    # <form method="post" enctype="multipart/form-data">
    #   <input type="file" name="myfile">
    # </form>
    uploaded_file = request.files.get('myfile')
    if uploaded_file:
        filename = uploaded_file.filename
        uploaded_file.save(f'/uploads/{filename}')

    # 7. 获取请求方法
    method = request.method  # 'POST'

    return {
        'page': page,
        'limit': limit,
        'username': username,
        'user_agent': user_agent,
        'method': method
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

from flask import Flask, make_response, jsonify

app = Flask(__name__)

@app.route('/text')
def text_response():
    # 1. 直接返回字符串（自动包装为 HTML 响应）
    return '<h1>这是 HTML</h1>'

@app.route('/json')
def json_response():
    # 2. 返回 JSON（API 开发最常用）
    # jsonify 会自动设置 Content-Type: application/json
    return jsonify({
        'name': '张三',
        'age': 25,
        'skills': ['Python', 'JavaScript']
    })

@app.route('/custom')
def custom_response():
    # 3. 自定义响应（用于设置 Cookie、状态码等）
    response = make_response('操作成功')
    response.status_code = 200
    response.headers['X-Custom-Header'] = 'CustomValue'
    response.set_cookie('session_id', 'abc123')
    return response

@app.route('/redirect')
def redirect_demo():
    # 4. 重定向
    from flask import redirect, url_for
    # url_for 根据函数名生成 URL
    return redirect(url_for('json_response'))

@app.route('/error')
def error_response():
    # 5. 错误响应
    from flask import abort
    abort(404)  # 抛出 404 错误，会被 errorhandler 捕获
    # 或者直接返回错误响应
    return '页面不存在', 404

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

from flask import Flask, render_template

app = Flask(__name__)

@app.route('/')
def index():
    # render_template 会在 templates/ 文件夹下查找模板文件
    # 默认路径：./templates/index.html
    return render_template(
        'index.html',
        title='首页',
        message='欢迎来到 Flask 世界！',
        username='小明',
        items=['苹果', '香蕉', '橙子'],
        is_logged_in=True,
        user={'name': '张三', 'level': 'VIP'},
        price=19.99
    )

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <title>{{ title }}</title>
</head>
<body>
    <!-- 1. 变量插值：{{ 变量名 }} -->
    <h1>{{ title }}</h1>
    <p>{{ message }}</p>
    <p>当前用户：{{ username }}</p>

    <!-- 2. 条件判断 -->
    {% if is_logged_in %}
        <p>欢迎回来，会员用户！</p>
    {% else %}
        <p>请 <a href="/login">登录</a></p>
    {% endif %}

    <!-- 3. 循环遍历 -->
    <h2>商品列表</h2>
    <ul>
    {% for item in items %}
        <li>{{ loop.index }}: {{ item }}</li>
    {% endfor %}
    </ul>

    <!-- 4. 访问对象属性 -->
    <p>用户名称：{{ user.name }}</p>
    <p>会员等级：{{ user.level }}</p>

    <!-- 5. 过滤器（管道操作） -->
    <p>价格：{{ price }} 元</p>
    <p>价格（保留2位小数）：{{ price | round(2) }}</p>
    <p>用户名（转大写）：{{ username | upper }}</p>
    <p>用户名（转小写）：{{ username | lower }}</p>
    <p>用户名（首字母大写）：{{ username | capitalize }}</p>
    <p>用户名（未定义时默认）：{{ undefined_var | default("匿名用户") }}</p>

    <!-- 6. 模板继承：子模板可覆盖 content 块 -->
</body>
</html>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <title>{% block title %}默认标题{% endblock %}</title>
    <!-- 引入 CSS -->
    <style>
        body { font-family: Arial, sans-serif; margin: 0; padding: 0; }
        nav { background: #333; padding: 10px; }
        nav a { color: white; margin: 0 10px; text-decoration: none; }
        footer { background: #f5f5f5; padding: 20px; text-align: center; margin-top: 50px; }
        .content { padding: 20px; }
    </style>
</head>
<body>
    <!-- 导航栏 -->
    <nav>
        <a href="/">首页</a>
        <a href="/about">关于</a>
        <a href="/contact">联系</a>
    </nav>

    <!-- 内容区域：子模板可以覆盖这个 block -->
    <div class="content">
        {% block content %}
        <p>默认内容</p>
        {% endblock %}
    </div>

    <!-- 页脚 -->
    <footer>
        <p>&copy; 2026 我的 Flask 网站</p>
    </footer>
</body>
</html>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

<!-- 继承基础模板 -->
{% extends "base.html" %}

<!-- 覆盖 title block -->
{% block title %}首页 - 我的网站{% endblock %}

<!-- 覆盖 content block -->
{% block content %}
    <h1>欢迎来到首页！</h1>
    <p>这是一个使用 Flask 和 Jinja2 构建的动态网站。</p>

    <!-- 演示 Jinja2 的内置变量（在 for 循环中可用）-->
    {% for item in items %}
    <p>当前循环索引：{{ loop.index }}</p>
    <p>是否为第一次循环：{{ loop.first }}</p>
    <p>是否为最后一次循环：{{ loop.last }}</p>
    {% endfor %}

{% endblock %}

1
2
3
4
5
6
7
8
9

{% extends "base.html" %}

{% block title %}关于我们{% endblock %}

{% block content %}
    <h1>关于我们</h1>
    <p>我们是一个热爱技术的团队。</p>
    <p>成立于 2020年</p>
{% endblock %}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

from flask import Flask, session, redirect, url_for, request

app = Flask(__name__)

# ⚠️ 重要：设置一个强密钥，用于加密 Session 数据
# 在生产环境中，这个密钥要保密且随机生成
app.secret_key = '这是一个超级-secret-key-不要告诉别人！'

@app.route('/')
def index():
    # 检查 session 中是否有用户名
    if 'username' in session:
        return f'已登录：{session["username"]} <a href="/logout">退出</a>'
    return '未登录 <a href="/login">登录</a>'

@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        username = request.form.get('username')
        password = request.form.get('password')

        # 简单验证（实际项目要用数据库验证）
        if username == 'admin' and password == '123456':
            # 将用户名存入 session
            session['username'] = username
            session['is_vip'] = True
            return redirect(url_for('index'))
        else:
            return '用户名或密码错误 <a href="/login">重新登录</a>'
    else:
        # 返回登录表单页面
        return '''
        <form method="post">
            用户名：<input type="text" name="username"><br>
            密码：<input type="password" name="password"><br>
            <button type="submit">登录</button>
        </form>
        '''

@app.route('/logout')
def logout():
    # 清除 session
    session.pop('username', None)
    session.pop('is_vip', None)
    return '已退出登录 <a href="/">返回首页</a>'

# Session 配置
@app.route('/set_session')
def set_session():
    session['theme'] = 'dark'
    session['language'] = 'zh-CN'
    return 'Session 已设置'

@app.route('/get_session')
def get_session():
    theme = session.get('theme', 'light')
    return f'当前主题：{theme}'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

from flask import Flask, make_response, request

app = Flask(__name__)

@app.route('/set_cookie')
def set_cookie():
    response = make_response('Cookie 已设置')
    # set_cookie(名称, 值, 过期时间秒)
    response.set_cookie('username', '张三', max_age=3600)  # 1小时后过期
    response.set_cookie('is_vip', 'true', max_age=3600*24)  # 1天后过期
    return response

@app.route('/get_cookie')
def get_cookie():
    username = request.cookies.get('username', '游客')
    is_vip = request.cookies.get('is_vip', 'false')
    return f'用户名：{username}，VIP：{is_vip}'

@app.route('/delete_cookie')
def delete_cookie():
    response = make_response('Cookie 已删除')
    response.delete_cookie('username')
    return response

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

from flask import Blueprint, render_template, request, redirect, url_for

# 创建蓝图：第一个参数是蓝图名称，第二个是蓝图所在的模块
# __name__ 帮助 Flask 定位模板和静态文件
auth_bp = Blueprint('auth', __name__, 
                    template_folder='templates')

# 使用 auth_bp.route() 定义路由
@auth_bp.route('/login')
def login():
    return render_template('auth/login.html', title='用户登录')

@auth_bp.route('/register')
def register():
    return '注册页面'

@auth_bp.route('/logout')
def logout():
    return '退出登录'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

from flask import Blueprint, render_template

blog_bp = Blueprint('blog', __name__,
                    template_folder='templates',
                    url_prefix='/blog')  # 所有路由自动加上 /blog 前缀

@blog_bp.route('/')
def index():
    return render_template('blog/index.html', title='博客首页')

@blog_bp.route('/<int:post_id>')
def detail(post_id):
    return f'文章详情：{post_id}'

@blog_bp.route('/create')
def create():
    return '创建文章'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

from flask import Flask
from auth import auth_bp      # 导入蓝图
from blog import blog_bp

app = Flask(__name__)

# 注册蓝图
# url_prefix 参数会在所有路由前添加前缀
app.register_blueprint(auth_bp, url_prefix='/auth')
app.register_blueprint(blog_bp, url_prefix='/blog')

@app.route('/')
def home():
    return '<h1>首页</h1><ul>' \
           '<li><a href="/auth/login">登录</a></li>' \
           '<li><a href="/blog">博客</a></li>' \
           '</ul>'

if __name__ == '__main__':
    app.run(debug=True)

1
2
3
4
5
6
7

# 创建蓝图时指定静态文件目录
admin_bp = Blueprint('admin', __name__,
                     static_folder='static',      # 静态文件目录
                     static_url_path='/admin_static')  # 访问路径

# 在模板中使用蓝图名生成 URL
# <link rel="stylesheet" href="{{ url_for('admin.static', filename='admin.css') }}">

1

pip install flask-restful

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

from flask import Flask
from flask_restful import Api, Resource, reqparse

app = Flask(__name__)
# 包装 Flask 应用
api = Api(app)

# 定义资源（Resource）是 RESTful 的核心概念
# 每个 Resource 对应一个 URL 端点，自动处理 GET/POST/PUT/DELETE

class HelloWorld(Resource):
    def get(self):
        '''GET 请求返回欢迎信息'''
        return {
            'message': 'Hello, World!',
            'status': 'success'
        }

    def post(self):
        '''POST 请求处理客户端提交的数据'''
        # 从请求体中获取参数
        parser = reqparse.RequestParser()
        parser.add_argument('name', type=str, required=True, help='姓名不能为空')
        parser.add_argument('age', type=int, default=18)
        args = parser.parse_args()

        return {
            'message': f'欢迎 {args["name"]}！',
            'age': args['age'],
            'status': 'created'
        }, 201  # 201 = Created

# 注册资源到路由
api.add_resource(HelloWorld, '/', '/hello')

if __name__ == '__main__':
    app.run(debug=True)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# GET 请求
curl http://127.0.0.1:5000/
# 返回：
# {
#     "message": "Hello, World!",
#     "status": "success"
# }

# POST 请求
curl -X POST http://127.0.0.1:5000/hello \
  -H "Content-Type: application/json" \
  -d '{"name": "张三", "age": 25}'
# 返回（状态码 201）：
# {
#     "message": "欢迎 张三！",
#     "age": 25,
#     "status": "created"
# }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

from flask import Flask, request
from flask_restful import Api, Resource, reqparse, abort

app = Flask(__name__)
api = Api(app)

# 模拟数据库
todos = {
    1: {'title': '学 Flask', 'done': False},
    2: {'title': '学 Django', 'done': False},
}

# 请求参数解析器
parser = reqparse.RequestParser()
parser.add_argument('title', type=str, required=True, help='标题不能为空')
parser.add_argument('done', type=bool, default=False)

def abort_if_todo_not_found(todo_id):
    '''检查 todo 是否存在，不存在则返回 404'''
    if todo_id not in todos:
        abort(404, message=f'Todo {todo_id} 不存在')

class TodoList(Resource):
    '''Todo 列表资源'''

    def get(self):
        '''获取所有 todos'''
        return todos

    def post(self):
        '''创建新 todo'''
        args = parser.parse_args()
        new_id = max(todos.keys(), default=0) + 1
        todos[new_id] = {'title': args['title'], 'done': args['done']}
        return todos[new_id], 201

class Todo(Resource):
    '''单个 Todo 资源'''

    def get(self, todo_id):
        '''获取指定 todo'''
        abort_if_todo_not_found(todo_id)
        return todos[todo_id]

    def put(self, todo_id):
        '''更新指定 todo'''
        abort_if_todo_not_found(todo_id)
        args = parser.parse_args()
        todos[todo_id]['title'] = args['title']
        todos[todo_id]['done'] = args['done']
        return todos[todo_id]

    def delete(self, todo_id):
        '''删除指定 todo'''
        abort_if_todo_not_found(todo_id)
        del todos[todo_id]
        return '', 204  # 204 = No Content

# 注册路由
api.add_resource(TodoList, '/todos')
api.add_resource(Todo, '/todos/<int:todo_id>')

if __name__ == '__main__':
    app.run(debug=True)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# 获取所有 todos
curl http://127.0.0.1:5000/todos
# [{"title": "学 Flask", "done": false}, {"title": "学 Django", "done": false}]
# 注意：字典的 key 变成了字符串，因为 JSON 格式

# 获取单个 todo
curl http://127.0.0.1:5000/todos/1
# {"title": "学 Flask", "done": false}

# 创建新 todo
curl -X POST http://127.0.0.1:5000/todos \
  -H "Content-Type: application/json" \
  -d '{"title": "学 FastAPI", "done": false}'
# 状态码 201

# 更新 todo
curl -X PUT http://127.0.0.1:5000/todos/1 \
  -H "Content-Type: application/json" \
  -d '{"title": "学 Flask（已学完）", "done": true}'

# 删除 todo
curl -X DELETE http://127.0.0.1:5000/todos/2

# 访问不存在的 todo
curl http://127.0.0.1:5000/todos/999
# {"message": "Todo 999 不存在"}
# 状态码：404

1

pip install flask-sqlalchemy

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)

# 配置数据库
# SQLite 格式：sqlite:///数据库名（三个斜杠是相对路径）
# 绝对路径：sqlite:////绝对路径/数据库名
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///blog.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False  # 禁止追踪修改，省内存

# 创建数据库实例
db = SQLAlchemy(app)

# 定义模型（类 → 表）
class User(db.Model):
    '''用户表'''
    __tablename__ = 'users'  # 表名，不写默认用类名的小写

    id = db.Column(db.Integer, primary_key=True)  # 主键
    username = db.Column(db.String(80), unique=True, nullable=False)  # 唯一、不能为空
    email = db.Column(db.String(120), unique=True, nullable=False)
    created_at = db.Column(db.DateTime, default=db.func.now())  # 创建时间

    # 关系：一对多
    posts = db.relationship('Post', backref='author', lazy=True)

    def __repr__(self):
        return f'<User {self.username}>'

class Post(db.Model):
    '''文章表'''
    __tablename__ = 'posts'

    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(200), nullable=False)
    content = db.Column(db.Text, nullable=False)
    user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
    # ForeignKey 外键关联 users 表的 id

    def __repr__(self):
        return f'<Post {self.title}>'

# 创建表（开发环境用，生产用迁移）
with app.app_context():
    db.create_all()

# CRUD 操作
@app.route('/init')
def init_db():
    # 创建数据
    admin = User(username='admin', email='admin@example.com')
    post1 = Post(title='第一篇文章', content='内容...', author=admin)

    db.session.add(admin)  # 添加到会话
    db.session.add(post1)
    db.session.commit()  # 提交事务

    return '数据库初始化成功！'

@app.route('/users')
def list_users():
    # 查询所有用户
    users = User.query.all()
    return '<br>'.join([f'{u.id}: {u.username} - {u.email}' for u in users])

@app.route('/user/<int:user_id>')
def get_user(user_id):
    # 根据主键查询
    user = User.query.get_or_404(user_id, description='用户不存在')
    return f'{user.username} - {user.email}'

@app.route('/user/delete/<int:user_id>')
def delete_user(user_id):
    user = User.query.get(user_id)
    if user:
        db.session.delete(user)
        db.session.commit()
        return f'用户 {user.username} 已删除'
    return '用户不存在'

@app.route('/posts')
def list_posts():
    # 过滤查询
    posts = Post.query.filter_by(user_id=1).all()
    return '<br>'.join([f'{p.title} (作者: {p.author.username})' for p in posts])

1

pip install flask-migrate

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///blog.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

db = SQLAlchemy(app)
migrate = Migrate(app, db)  # 初始化迁移

# 定义模型...
class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(100))
    age = db.Column(db.Integer)  # 新增字段

# 迁移命令（终端执行）：
# flask db init         # 初始化迁移目录
# flask db migrate -m "添加 age 字段"  # 创建迁移脚本
# flask db upgrade      # 执行迁移
# flask db downgrade    # 回滚迁移

1

pip install flask-login

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

from flask import Flask, render_template_string, request, redirect, url_for
from flask_sqlalchemy import SQLAlchemy
from flask_login import LoginManager, UserMixin, login_user, login_required, logout_user, current_user

app = Flask(__name__)
app.config['SECRET_KEY'] = 'secret-key'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///users.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

db = SQLAlchemy(app)
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = 'login'  # 未登录时重定向到登录页

# 用户模型需要继承 UserMixin
class User(UserMixin, db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(100), unique=True, nullable=False)
    password = db.Column(db.String(100), nullable=False)

@login_manager.user_loader
def load_user(user_id):
    '''根据用户 ID 加载用户（必须实现）'''
    return User.query.get(int(user_id))

@app.route('/')
def index():
    return f'''
    <h1>首页</h1>
    <p>当前用户：{current_user.username if current_user.is_authenticated else "未登录"}</p>
    <a href="/login">登录</a> |
    <a href="/logout">退出</a> |
    <a href="/profile">个人资料（需登录）</a>
    '''

@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        username = request.form.get('username')
        password = request.form.get('password')
        user = User.query.filter_by(username=username, password=password).first()
        if user:
            login_user(user)  # 登录用户
            next_page = request.args.get('next')  # 登录后跳转
            return redirect(next_page or url_for('index'))
        return '用户名或密码错误'
    return '''
    <form method="post">
        用户名：<input name="username"><br>
        密码：<input name="password" type="password"><br>
        <button>登录</button>
    </form>
    '''

@app.route('/logout')
@login_required  # 必须登录才能访问
def logout():
    logout_user()  # 退出登录
    return '已退出 <a href="/">返回</a>'

@app.route('/profile')
@login_required  # 保护路由
def profile():
    return f'<h1>个人资料</h1><p>欢迎，{current_user.username}！</p>'

# 初始化数据库
with app.app_context():
    db.create_all()
    # 创建测试用户
    if not User.query.filter_by(username='admin').first():
        db.session.add(User(username='admin', password='123456'))
        db.session.commit()

if __name__ == '__main__':
    app.run(debug=True)

1
2
3
4
5
6

# 服务器端安装
pip install gunicorn flask

# Nginx 安装（Linux）
# sudo apt install nginx   # Ubuntu/Debian
# sudo yum install nginx    # CentOS/RHEL

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

# gunicorn_config.py
import multiprocessing

# 绑定地址和端口
bind = '127.0.0.1:8000'

# 工作进程数（一般设为 CPU 核心数的 2-4 倍）
workers = multiprocessing.cpu_count() * 2

# 工作模式
worker_class = 'sync'  # 同步模式（简单应用）
# worker_class = 'gevent'  # 异步模式（高并发）
# worker_class = 'uvicorn.workers.UvicornWorker'  # 如果用 FastAPI

# 每个 worker 的线程数
threads = 2

# 超时时间（秒）
timeout = 30

# 预加载应用（共享内存，省内存）
preload_app = True

# 日志
accesslog = '/var/log/gunicorn/access.log'
errorlog = '/var/log/gunicorn/error.log'
loglevel = 'info'

# 进程名称
proc_name = 'myflaskapp'

# 协程数（异步 worker 用）
worker_connections = 1000

1
2
3
4
5
6
7
8
9

# 基本启动
gunicorn -w 4 -b 127.0.0.1:8000 app:app

# 使用配置文件
gunicorn -c gunicorn_config.py app:app

# 停止旧进程并重启
# kill -HUP $(cat /tmp/gunicorn.pid)  # 平滑重启（重载代码）
# kill -9 $(cat /tmp/gunicorn.pid)    # 强制停止

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

# /etc/nginx/sites-available/myflaskapp
upstream flask_backend {
    server 127.0.0.1:8000 fail_timeout=0;
}

server {
    listen 80;
    server_name example.com www.example.com;

    # 重定向到 HTTPS（如果配置了 SSL）
    # return 301 https://$server_name$request_uri;

    # 访问日志
    access_log /var/log/nginx/myflaskapp_access.log;
    error_log /var/log/nginx/myflaskapp_error.log;

    # 最大上传文件大小
    client_max_body_size 10M;

    location / {
        # 代理到 Gunicorn
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_pass http://flask_backend;

        # 超时设置
        proxy_connect_timeout 60s;
        proxy_read_timeout 60s;
        proxy_send_timeout 60s;
    }

    # 静态文件（让 Nginx 直接处理，不经过 Flask）
    location /static/ {
        alias /var/www/myflaskapp/static/;
        expires 30d;  # 缓存 30 天
    }

    # 上传文件目录
    location /media/ {
        alias /var/www/myflaskapp/media/;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 创建软链接
sudo ln -s /etc/nginx/sites-available/myflaskapp /etc/nginx/sites-enabled/

# 测试配置
sudo nginx -t

# 重载 Nginx
sudo systemctl reload nginx

# 或者完全重载
sudo systemctl restart nginx

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# 安装 Django
pip install django

# 创建项目（类似于脚手架）
django-admin startproject mysite

# 创建应用
cd mysite
python manage.py startapp blog

# 目录结构
mysite/
├── manage.py              # 管理脚本
├── mysite/
│   ├── __init__.py
│   ├── settings.py         # 项目配置
│   ├── urls.py             # URL 根配置
│   ├── wsgi.py             # WSGI 入口
│   └── asgi.py             # ASGI 入口（异步）
└── blog/
    ├── __init__.py
    ├── models.py           # 模型定义
    ├── views.py            # 视图函数
    ├── urls.py             # 应用 URL 配置（需创建）
    ├── admin.py            # Admin 配置
    └── ...

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

from django.db import models

class Article(models.Model):
    '''文章模型'''
    title = models.CharField(max_length=200)      # 标题，最大200字符
    content = models.TextField()                  # 内容，文本
    author = models.CharField(max_length=100)     # 作者
    created_at = models.DateTimeField(auto_now_add=True)  # 创建时间
    updated_at = models.DateTimeField(auto_now=True)      # 更新时间
    is_published = models.BooleanField(default=False)     # 是否发布

    def __str__(self):
        return self.title

    class Meta:
        ordering = ['-created_at']  # 默认按创建时间倒序

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

from django.shortcuts import render, get_object_or_404
from django.http import HttpResponse
from .models import Article

def index(request):
    '''首页：显示所有已发布的文章'''
    articles = Article.objects.filter(is_published=True)
    return render(request, 'blog/index.html', {'articles': articles})

def detail(request, article_id):
    '''文章详情页'''
    article = get_object_or_404(Article, pk=article_id)
    return render(request, 'blog/detail.html', {'article': article})

def about(request):
    '''关于页面'''
    return HttpResponse('这是关于页面')

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

from django.urls import path
from . import views

app_name = 'blog'  # 命名空间，用于 url 反查

urlpatterns = [
    path('', views.index, name='index'),
    path('<int:article_id>/', views.detail, name='detail'),
    path('about/', views.about, name='about'),
]

1
2
3
4
5
6
7

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),        # Admin 后台
    path('blog/', include('blog.urls')),     # 引入 blog 应用的 URL
]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <title>我的博客</title>
    <style>
        body { font-family: Arial; max-width: 800px; margin: 0 auto; padding: 20px; }
        .article { border-bottom: 1px solid #ddd; padding: 10px 0; }
        h1 { color: #333; }
        .meta { color: #888; font-size: 0.9em; }
    </style>
</head>
<body>
    <h1>📚 我的博客</h1>
    <a href="/admin">管理后台</a>
    <hr>

    {% for article in articles %}
    <div class="article">
        <h2><a href="{% url 'blog:detail' article.id %}">{{ article.title }}</a></h2>
        <p class="meta">作者：{{ article.author }} | 发布时间：{{ article.created_at|date:"Y-m-d H:i" }}</p>
        <p>{{ article.content|truncatewords:30 }}</p>
    </div>
    {% empty %}
    <p>暂无文章</p>
    {% endfor %}
</body>
</html>

1
2
3
4
5
6
7

python manage.py runserver
# Watching for file changes with StatReloader
# Starting development server at http://127.0.0.1:8000/

# 创建数据表
python manage.py makemigrations  # 生成迁移文件
python manage.py migrate          # 执行迁移

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

from django.db import models

class Author(models.Model):
    '''作者模型'''
    name = models.CharField(max_length=100)  # 字符串，最大100字符
    email = models.EmailField()              # 邮箱格式验证
    bio = models.TextField()                 # 长文本
    birth_date = models.DateField()          # 日期
    phone = models.CharField(max_length=20, blank=True, null=True)  # 可选
    website = models.URLField(blank=True)    # URL 格式验证

class Book(models.Model):
    '''书籍模型'''
    title = models.CharField(max_length=200)
    price = models.DecimalField(max_digits=10, decimal_places=2)  # 精确小数
    pages = models.IntegerField(default=0)    # 整数
    rating = models.FloatField(default=0.0)   # 浮点数
    is_available = models.BooleanField(default=True)
    published_date = models.DateField()

    # ForeignKey：一对多关系（一个作者 → 多本书）
    author = models.ForeignKey(Author, on_delete=models.CASCADE, related_name='books')

    # ManyToManyField：多对多关系（一本书 → 多个标签，一个标签 → 多本书）
    tags = models.ManyToManyField('Tag', related_name='books')

    def __str__(self):
        return self.title

class Tag(models.Model):
    '''标签模型'''
    name = models.CharField(max_length=50, unique=True)

    def __str__(self):
        return self.name

class Publisher(models.Model):
    '''出版社模型'''
    name = models.CharField(max_length=100)
    # OneToOneField：一对一关系（用户表扩展信息）
    user = models.OneToOneField('User', on_delete=models.CASCADE)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

class Comment(models.Model):
    '''评论模型 - 展示自引用外键'''
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

    # 自引用外键：评论可以回复评论
    parent = models.ForeignKey('self', on_delete=models.CASCADE, null=True, blank=True)
    article = models.ForeignKey(Article, on_delete=models.CASCADE, related_name='comments')
    author_name = models.CharField(max_length=100)

    # related_name='comments' 允许反向查询：
    # article.comments.all() 获取某文章的所有评论