Flask 基础教程：新手快速上手指南

引言：欢迎来到 Flask 的世界！

在当今的Web开发领域，Python以其简洁、易读和强大的生态系统占据了一席之地。而说到Python的Web框架，Django和Flask无疑是两座高山。Django以其“包罗万象”的特性，提供了一站式的解决方案；而Flask，则以其“微框架”的定位，以极简主义和灵活性著称，允许开发者根据项目需求自由选择组件，实现高度定制化。

对于刚踏入Web开发领域的初学者，或者希望快速构建轻量级应用、API服务的开发者来说，Flask是一个绝佳的起点。它让你能够快速理解Web应用的基本原理，并以最少的代码实现功能。本篇教程将带你从零开始，一步步掌握Flask的基础知识，助你快速搭建起自己的第一个Web应用。

准备好了吗？让我们一起探索Flask的奇妙之旅吧！

1. 什么是 Flask？为什么选择它？

1.1 Flask 简介

Flask 是一个用 Python 编写的轻量级 Web 应用框架。它被称为“微框架”，因为它不包含 ORM（对象关系映射器）、表单验证等复杂的内置工具。相反，Flask 提供了核心的 Web 服务功能（如路由、请求处理、模板引擎），并允许开发者通过丰富的第三方扩展来按需添加功能。

1.2 为什么选择 Flask？

轻量级和简洁性： Flask 的核心非常精简，学习曲线平缓，非常适合初学者。它让你能够专注于应用逻辑，而不是被框架的各种约定和配置所束缚。
灵活性和可扩展性： Flask 不强制你使用特定的工具或库。你可以自由选择数据库、ORM、表单库、认证方案等，甚至可以集成几乎任何你喜欢的 Python 库。这种自由度使得 Flask 成为构建定制化解决方案的理想选择。
出色的文档： Flask 拥有清晰、详尽且易于理解的官方文档，这对于学习和解决问题非常有帮助。
强大的社区和丰富的扩展： 尽管Flask本身是微框架，但其活跃的社区贡献了大量的扩展（Extensions），例如 Flask-SQLAlchemy 用于数据库集成、Flask-WTF 用于表单处理、Flask-Login 用于用户认证等，这些扩展极大地弥补了核心框架的不足。
适合小型项目和 API 开发： 对于需要快速原型开发、构建小型网站、RESTful API 或微服务的项目，Flask 是一个非常高效和强大的工具。

2. 准备工作：搭建你的开发环境

在开始编写 Flask 应用之前，我们需要确保你的开发环境已经准备就绪。

2.1 安装 Python

Flask 是基于 Python 构建的，所以你首先需要安装 Python。推荐安装 Python 3.7 或更高版本。

Windows: 访问 Python 官方网站下载安装包，并在安装过程中勾选“Add Python to PATH”选项。
macOS: macOS 通常预装了 Python，但可能是旧版本。推荐通过 Homebrew 安装最新版：brew install python3。
Linux: 大多数 Linux 发行版都预装了 Python。如果版本过旧，可以使用包管理器安装：sudo apt update && sudo apt install python3 python3-pip (Debian/Ubuntu) 或 sudo dnf install python3 python3-pip (Fedora)。

安装完成后，打开终端或命令提示符，输入 python --version 或 python3 --version，应该能看到 Python 的版本信息。同时，pip --version 或 pip3 --version 应该能显示 pip 的版本信息。

2.2 使用虚拟环境（强烈推荐！）

在开发 Python 项目时，使用虚拟环境（Virtual Environment）是一个最佳实践。它能够为你的每个项目创建一个独立的 Python 环境，将项目所需的依赖库与其他项目或系统全局的库隔离开来，避免版本冲突。

创建项目目录：
首先，为你即将创建的 Flask 应用创建一个新的目录。
bash mkdir myflaskapp cd myflaskapp
创建虚拟环境：
在项目根目录下，使用 venv 模块创建虚拟环境。
bash python3 -m venv venv
这会在 myflaskapp 目录下创建一个名为 venv 的子目录，其中包含了独立的 Python 解释器和 pip。
激活虚拟环境：
激活虚拟环境后，你的终端提示符会显示虚拟环境的名称（通常是 (venv)），表示你当前的操作都将在虚拟环境中进行。
- macOS / Linux:
  bash source venv/bin/activate
- Windows (Command Prompt):
  bash venv\Scripts\activate.bat
- Windows (PowerShell):
  powershell .\venv\Scripts\Activate.ps1
当你完成开发或切换到其他项目时，可以使用 deactivate 命令退出虚拟环境。

2.3 安装 Flask

在激活虚拟环境后，使用 pip 安装 Flask。
bash pip install Flask
这会安装 Flask 及其所有必要的依赖。

3. 你的第一个 Flask 应用：Hello, Flask!

现在，我们来编写一个最简单的 Flask 应用，它将在浏览器中显示“Hello, Flask!”。

创建 app.py 文件：
在 myflaskapp 目录下创建一个名为 app.py 的文件。
编写代码：
“`python
# app.py
from flask import Flask

1. 创建 Flask 应用实例

name 是 Python 的一个特殊变量，表示当前模块的名称。

Flask 用它来确定应用的根目录，以便找到模板和静态文件等资源。

app = Flask(name)

2. 定义路由（Route）

@app.route(‘/’) 是一个装饰器，它将下面的函数绑定到 URL 路径 ‘/’。

当用户访问应用的根 URL 时，这个函数就会被调用。

@app.route(‘/’)
def hello_world():
# 3. 返回响应
# 这个函数返回的字符串会作为 HTTP 响应发送给用户的浏览器。
return ‘Hello, Flask!’

4. 运行应用

确保只有在直接运行 app.py 文件时才启动开发服务器。

debug=True 开启调试模式，当代码修改时服务器会自动重启，并提供详细的错误信息。

if name == ‘main‘:
app.run(debug=True)
“`
运行应用：
在已激活虚拟环境的终端中，运行你的应用：
bash python app.py
你将看到类似以下的输出：
“`
- Serving Flask app ‘app’
- Debug mode: on
- Running on http://127.0.0.1:5000 (Press CTRL+C to quit)
- Restarting with stat
- Debugger is active!
- Debugger PIN: 123-456-789
  “`
  这表示你的 Flask 应用已经在本地开发服务器上运行起来了。
访问应用：
打开你的Web浏览器，访问 http://127.0.0.1:5000。
你将会看到页面上显示“Hello, Flask!”。

恭喜你！你已经成功创建并运行了你的第一个 Flask 应用。

4. Flask 核心概念详解

现在我们已经有了一个能运行的 Flask 应用，接下来深入了解 Flask 的一些核心概念，这将帮助你构建更复杂的应用。

4.1 路由 (Routing)

路由是将 URL 映射到 Python 函数的过程。在 Flask 中，这通过 @app.route() 装饰器实现。

4.1.1 多个路由到同一个视图函数

你可以将多个 URL 映射到同一个视图函数。
python @app.route('/') @app.route('/home') def index(): return 'Welcome to the home page!'
访问 / 或 /home 都会显示“Welcome to the home page!”。

4.1.2 动态路由 (URL Variables)

路由可以包含变量，这使得你的 URL 更加灵活。变量会作为参数传递给视图函数。
“`python
@app.route(‘/user/‘)
def show_user_profile(username):
# username 变量会从 URL 中提取并作为参数传递给函数
return f’User: {username}’

@app.route(‘/post/‘)
def show_post(post_id):
# 表示 post_id 必须是一个整数
return f’Post ID: {post_id}’
`` 访问/user/alice将显示“User: alice”，访问/post/123将显示“Post ID: 123”。 Flask 支持多种变量类型转换器，如string(默认)、int、float、path(包含斜杠的字符串)、uuid`。

4.1.3 HTTP 方法 (Methods)

Web 应用通常需要处理不同的 HTTP 方法，如 GET（获取数据）、POST（提交数据）、PUT（更新数据）、DELETE（删除数据）。
默认情况下，Flask 路由只响应 GET 请求。你可以通过 methods 参数指定允许的 HTTP 方法。
“`python
from flask import request

@app.route(‘/login’, methods=[‘GET’, ‘POST’])
def login():
if request.method == ‘POST’:
# 处理表单提交逻辑
username = request.form[‘username’]
password = request.form[‘password’]
return f’Username: {username}, Password: {password} (via POST)’
else:
# 显示登录表单
return ”’

”’
`` 在这个例子中，当用户通过 GET 请求访问/login时，会显示一个登录表单；当用户通过 POST 请求提交表单时，if request.method == ‘POST’` 代码块会被执行。

4.2 请求对象 (Request Object)

request 对象是一个全局对象，它包含了所有关于当前 HTTP 请求的信息，如表单数据、查询参数、请求头等。你需要从 flask 模块中导入它。

request.method: 当前请求的 HTTP 方法（’GET’, ‘POST’, 等）。
request.args: 包含 URL 查询字符串参数的字典（例如 ?key=value）。
request.form: 包含 POST 请求中表单数据的字典。
request.json: 如果请求的 Content-Type 是 application/json，则包含解析后的 JSON 数据。
request.headers: 请求头信息。
request.files: 包含上传文件的字典。

4.3 响应 (Responses)

视图函数返回的内容会作为 HTTP 响应发送给客户端。

字符串： 最简单的响应就是直接返回一个字符串。
python return 'Hello, Flask!'
HTML： 返回包含 HTML 标签的字符串。
python return '<h1>Welcome!</h1><p>This is my first Flask page.</p>'
JSON： 对于 API 开发非常有用。Flask 提供了 jsonify 函数来帮助你构建 JSON 响应。
“`python
from flask import jsonify

@app.route(‘/api/data’)
def get_data():
data = {‘name’: ‘Alice’, ‘age’: 30, ‘city’: ‘New York’}
return jsonify(data)
``jsonify会自动设置Content-Type: application/json` 响应头。
Redirect (重定向)： 将用户重定向到另一个 URL。
“`python
from flask import redirect, url_for

@app.route(‘/old_path’)
def old_path():
return redirect(url_for(‘new_path’)) # 重定向到名为 ‘new_path’ 的视图函数

@app.route(‘/new_path’)
def new_path():
return ‘You have been redirected!’
``url_for()` 函数非常重要，它根据视图函数的名称动态生成 URL，避免了硬编码 URL，使得应用在路由变更时更易维护。
Abort (中止请求)： 当发生错误时，可以使用 abort() 函数中止请求，并返回指定的 HTTP 状态码（如 404 Not Found, 403 Forbidden）。
“`python
from flask import abort

@app.route(‘/admin’)
def admin_panel():
if not current_user.is_admin: # 假设有用户认证逻辑
abort(403) # 返回 403 Forbidden 错误
return ‘Welcome, Admin!’

自定义错误页面（可选）

@app.errorhandler(403)
def forbidden_error(error):
return ‘

403 Forbidden: Access Denied!

‘, 403
“`

4.4 模板 (Templates)

在实际的 Web 应用中，直接在 Python 代码中拼接 HTML 字符串是非常低效和难以维护的。Flask 使用 Jinja2 作为其默认的模板引擎，它允许你将 HTML 结构与 Python 逻辑分离。

创建 templates 目录：
在你的 myflaskapp 根目录下创建一个名为 templates 的文件夹。Flask 会自动在这个文件夹中寻找模板文件。
创建模板文件 (例如 index.html)：
在 templates 文件夹中创建 index.html：
html  <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>My Flask App</title> </head> <body> <h1>Hello, {{ name }}!</h1> <p>This is a paragraph from the template.</p> <p>Current year: {{ current_year }}</p> </body> </html>
在视图函数中使用 render_template：
“`python
# app.py
from flask import Flask, render_template
from datetime import datetime

app = Flask(name)

@app.route(‘/greet/‘)
def greet(name):
current_year = datetime.now().year
# render_template 会查找 templates 目录下的文件
# 第二个及后续参数是传递给模板的变量
return render_template(‘index.html’, name=name, current_year=current_year)

@app.route(‘/’)
def home():
return render_template(‘index.html’, name=’Guest’, current_year=datetime.now().year)

if name == ‘main‘:
app.run(debug=True)
`` 访问/greet/Alice将会看到“Hello, Alice!”。访问/` 则看到“Hello, Guest!”。

4.4.1 Jinja2 模板语法基础

变量： {{ variable_name }}。变量会被其在视图函数中传递的值替换。
控制结构： {% if ... %}、{% for ... in ... %} 等。
“`html
- {{ item }}
- No items found.
{% if user_logged_in %}

Welcome back, {{ user_name }}!

{% else %}

Please log in.

{% endif %}
在视图函数中：python
@app.route(‘/list’)
def show_list():
my_items = [‘Apple’, ‘Banana’, ‘Cherry’]
# my_items = [] # 试试空列表的效果
logged_in = True
username = “Dev”
return render_template(‘list.html’, items=my_items, user_logged_in=logged_in, user_name=username)
* **注释：** `{# This is a Jinja2 comment #}`。 * **过滤器：** 可以修改变量的显示方式。html

Name (uppercase): {{ name | upper }}

List length: {{ items | length }}

“`

4.4.2 模板继承 (Template Inheritance)

模板继承是 Jinja2 最强大的功能之一，它允许你创建一个基础模板 (base.html)，其中包含网站的公共结构（如头部、导航栏、底部），然后让其他页面模板继承这个基础模板，只填充或修改特定的内容块。这大大减少了代码重复。

创建 base.html：
“`html

<!DOCTYPE html>

{% block title %}My Flask App{% endblock %}

Home
About
Contact
```
<div class="content">
    {% block content %}{% endblock %}
</div>

<footer>
    <p>&copy; {{ current_year }} My Flask App</p>
</footer>
```
`` *{% block title %}和{% block content %}定义了可供子模板覆盖的区域。 *{{ url_for(‘static’, filename=’css/style.css’) }}` 是用来引用静态文件的。
创建子模板 (例如 about.html)：
“`html

{% extends “base.html” %}

{% block title %}About Us{% endblock %}

{% block content %}

About My Flask App

This is the about page content.

Learn more about our mission and vision.

{% endblock %}
`` *{% extends “base.html” %}指示这个模板继承自base.html。 *{% block … %}` 块中的内容会替换掉父模板中同名块的内容。
更新 app.py：
“`python
# app.py
# … (imports)
from datetime import datetime

… (app = Flask(name))

@app.route(‘/’)
def home():
return render_template(‘index.html’, name=’Guest’, current_year=datetime.now().year)

@app.route(‘/about’)
def about():
return render_template(‘about.html’, current_year=datetime.now().year) # 传递 current_year 给 base.html

… (if name == ‘main‘: app.run(debug=True))

`` 现在访问/about`，你将会看到一个带有导航栏和底部的关于页面。

4.5 静态文件 (Static Files)

静态文件是指那些不会被服务器处理，直接发送给浏览器的文件，如 CSS 样式表、JavaScript 脚本、图片等。

创建 static 目录：
在你的 myflaskapp 根目录下创建一个名为 static 的文件夹。Flask 会自动在这个文件夹中寻找静态文件。
创建子目录和文件 (例如 static/css/style.css)：
css /* static/css/style.css */ body { font-family: Arial, sans-serif; margin: 20px; background-color: #f4f4f4; color: #333; } h1 { color: #0056b3; } nav { background-color: #333; padding: 10px; margin-bottom: 20px; } nav a { color: white; margin: 0 15px; text-decoration: none; } nav a:hover { text-decoration: underline; } .content { background-color: white; padding: 20px; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); } footer { margin-top: 30px; text-align: center; color: #666; font-size: 0.9em; }
在模板中引用静态文件：
使用 url_for('static', filename='path/to/your/file.ext') 来生成静态文件的 URL。
在 base.html 中，我们已经通过 {{ url_for('static', filename='css/style.css') }} 引用了 CSS 文件。
刷新页面，你将看到应用了样式的页面。

5. 进阶：表单处理与数据库集成（初探）

5.1 表单处理 (Using Flask-WTF)

处理表单是Web应用中非常常见的任务。虽然可以直接使用 request.form，但为了更好的验证、CSRF 保护和渲染便利性，我们通常会使用专门的表单库，如 Flask-WTF。

安装 Flask-WTF：
bash pip install Flask-WTF
配置 Secret Key：
Flask-WTF 依赖于 Flask 应用的 SECRET_KEY 来生成 CSRF 令牌。在 app.py 中设置它。
python # app.py app.config['SECRET_KEY'] = 'a_very_secret_key_that_you_should_change_in_production'
在生产环境中，这个密钥应该是一个复杂且随机的字符串。
定义表单：
创建一个 forms.py 文件（或直接放在 app.py 中），定义一个表单类。
“`python
# forms.py
from flask_wtf import FlaskForm
from wtforms import StringField, PasswordField, SubmitField
from wtforms.validators import DataRequired, Email, EqualTo, Length

class RegistrationForm(FlaskForm):
username = StringField(‘Username’, validators=[DataRequired(), Length(min=2, max=20)])
email = StringField(‘Email’, validators=[DataRequired(), Email()])
password = PasswordField(‘Password’, validators=[DataRequired()])
confirm_password = PasswordField(‘Confirm Password’,
validators=[DataRequired(), EqualTo(‘password’)])
submit = SubmitField(‘Sign Up’)
“`
在视图函数中使用表单：
“`python
# app.py
# … (imports)
from forms import RegistrationForm # 假设 forms.py 在同一目录下

@app.route(‘/register’, methods=[‘GET’, ‘POST’])
def register():
form = RegistrationForm()
if form.validate_on_submit():
# 表单验证通过，处理注册逻辑
username = form.username.data
email = form.email.data
password = form.password.data # 通常这里会哈希密码
print(f’User registered: {username}, {email}’)
# 可以在这里保存到数据库
return redirect(url_for(‘home’)) # 注册成功后重定向
return render_template(‘register.html’, form=form, current_year=datetime.now().year)
“`

创建表单模板 (templates/register.html)：
“`html

{% extends “base.html” %}

{% block title %}Register{% endblock %}

{% block content %}

Register

    <div>
        {{ form.username.label }}
        {{ form.username() }}
        {% if form.username.errors %}
            {% for error in form.username.errors %}
                <span style="color: red;">{{ error }}</span>
            {% endfor %}
        {% endif %}
    </div>
    <div>
        {{ form.email.label }}
        {{ form.email() }}
        {% if form.email.errors %}
            {% for error in form.email.errors %}
                <span style="color: red;">{{ error }}</span>
            {% endfor %}
        {% endif %}
    </div>
    <div>
        {{ form.password.label }}
        {{ form.password() }}
        {% if form.password.errors %}
            {% for error in form.password.errors %}
                <span style="color: red;">{{ error }}</span>
            {% endfor %}
        {% endif %}
    </div>
    <div>
        {{ form.confirm_password.label }}
        {{ form.confirm_password() }}
        {% if form.confirm_password.errors %}
            {% for error in form.confirm_password.errors %}
                <span style="color: red;">{{ error }}</span>
            {% endfor %}
        {% endif %}
    </div>
    <div>
        {{ form.submit() }}
    </div>
</form>

{% endblock %}
`` 访问/register` 尝试填写和提交表单，你会看到验证错误或成功注册的提示。

5.2 数据库集成 (Using Flask-SQLAlchemy)

对于任何非琐碎的 Web 应用，数据库都是必不可少的。Flask-SQLAlchemy 是一个 Flask 扩展，它将 SQLAlchemy（一个强大的 Python SQL 工具包和 ORM）集成到 Flask 中，使数据库操作变得简单。

我们将使用 SQLite 数据库，因为它是一个轻量级的文件数据库，非常适合开发和小型应用，无需额外的数据库服务器。

安装 Flask-SQLAlchemy：
bash pip install Flask-SQLAlchemy
配置数据库：
在 app.py 中配置数据库 URI。
“`python
# app.py
# … (imports)
from flask_sqlalchemy import SQLAlchemy
import os

… (app = Flask(name))

basedir = os.path.abspath(os.path.dirname(file))
app.config[‘SQLALCHEMY_DATABASE_URI’] = ‘sqlite:///’ + os.path.join(basedir, ‘app.db’)
app.config[‘SQLALCHEMY_TRACK_MODIFICATIONS’] = False # 禁用信号系统开销

db = SQLAlchemy(app)
“`
定义模型 (Models)：
模型是 Python 类，它代表数据库中的表。
“`python
# app.py (或 models.py 文件)
class User(db.Model):
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)
```
def __repr__(self):
    return f'<User {self.username}>'
```
“`
创建数据库表：
在终端中运行以下代码来创建数据库文件和表。
“`python
# app.py
# … (所有之前的代码)

在应用上下文外运行 db.create_all() 需要 app.app_context()

if name == ‘main‘:
with app.app_context():
db.create_all() # 这将根据你的模型创建数据库表
print(“Database tables created!”)
app.run(debug=True)
`` 当你第一次运行python app.py时，它会在myflaskapp目录下创建一个app.db文件，并根据User模型创建user表。 *注意：在生产环境中，通常会使用 Flask-Migrate 来管理数据库迁移，而不是简单地create_all()`。*
CRUD 操作 (Create, Read, Update, Delete)：
- Create (添加数据)：
  python # 可以在一个临时的视图函数或 Python shell 中测试 @app.route('/add_user/<username>/<email>') def add_user(username, email): new_user = User(username=username, email=email) db.session.add(new_user) # 将新用户添加到会话 db.session.commit() # 提交会话，保存到数据库 return f'User {username} with email {email} added!'
  访问 /add_user/john/[email protected]。
- Read (查询数据)：
  “`python
  @app.route(‘/users’)
  def list_users():
  users = User.query.all() # 查询所有用户
  user_list = [f'{user.id}: {user.username} ({user.email})’ for user in users]
  return ‘
  ‘.join(user_list)
  
  @app.route(‘/user_by_id/‘)
  def get_user_by_id(user_id):
  user = User.query.get_or_404(user_id) # 根据主键查询，找不到返回 404
  return f’Found user: {user.username} ({user.email})’
  `` 访问/users或/user_by_id/1`。
- Update (更新数据)：
  python @app.route('/update_user/<int:user_id>/<new_email>') def update_user_email(user_id, new_email): user = User.query.get_or_404(user_id) user.email = new_email # 修改对象的属性 db.session.commit() # 提交会话保存更改 return f'User {user.username} email updated to {new_email}'
  访问 /update_user/1/[email protected]。
- Delete (删除数据)：
  python @app.route('/delete_user/<int:user_id>') def delete_user(user_id): user = User.query.get_or_404(user_id) db.session.delete(user) # 将用户从会话中标记为删除 db.session.commit() # 提交会话执行删除 return f'User {user.username} deleted!'
  访问 /delete_user/1。

这些简单的例子展示了 Flask-SQLAlchemy 的基本用法。在实际应用中，你会将这些操作封装到更复杂的业务逻辑中。

6. 项目结构组织

随着应用功能的增加，将所有代码都放在 app.py 中会变得混乱。良好的项目结构能提高可维护性。一个常见的 Flask 项目结构如下：

myflaskapp/ ├── venv/ # 虚拟环境目录 ├── app.py # 应用主文件，包含应用实例、配置、路由等 ├── forms.py # 定义表单 ├── models.py # 定义数据库模型 ├── templates/ # HTML 模板文件 │ ├── base.html │ ├── index.html │ ├── about.html │ └── register.html ├── static/ # 静态文件（CSS, JS, 图片） │ ├── css/ │ │ └── style.css │ └── js/ │ └── main.js ├── config.py # 应用程序配置 (可选，但推荐) └── requirements.txt # 项目依赖列表

为了保持 app.py 的简洁，你可以将 forms 和 models 分离到单独的文件中，并在 app.py 中导入它们。
对于更大型的应用，可以使用 Blueprints 来组织相关的路由、模板和静态文件，进一步模块化你的应用。

7. 部署（简要介绍）

当你完成开发并准备将应用发布到生产环境时，需要考虑部署。

禁用调试模式： 在生产环境中，务必将 app.run(debug=True) 改为 app.run(debug=False) 或直接省略 debug 参数。调试模式会暴露敏感信息。
WSGI 服务器： Flask 内置的开发服务器不适合生产环境。你需要一个生产级的 WSGI (Web Server Gateway Interface) 服务器，如 Gunicorn 或 uWSGI，来运行你的 Flask 应用。
反向代理： 通常，WSGI 服务器会与一个反向代理服务器（如 Nginx 或 Apache）配合使用。反向代理负责处理客户端请求、缓存、负载均衡，并将请求转发给 WSGI 服务器。
环境变量： 敏感信息（如 SECRET_KEY、数据库密码）不应硬编码在代码中，而应通过环境变量注入。

部署是一个复杂的话题，超出了本入门教程的范围，但了解这些概念有助于你未来的学习。

8. 下一步：深入学习和实践

你已经掌握了 Flask 的基础知识，但 Web 开发的世界广阔无垠。以下是一些你可以继续探索的方向：

更多 Flask 扩展：
- Flask-Login: 用户认证和会话管理。
- Flask-Migrate: 数据库迁移工具 (基于 Alembic)。
- Flask-Mail: 发送邮件。
- Flask-RESTful: 快速构建 RESTful API。
数据库： 学习更多关于关系型数据库 (PostgreSQL, MySQL) 或 NoSQL 数据库 (MongoDB, Redis)。
前端技术： 深入学习 HTML, CSS, JavaScript，以及流行的前端框架 (React, Vue, Angular)。
测试： 学习如何为你的 Flask 应用编写单元测试和集成测试。
版本控制： 掌握 Git 的使用，这对于团队协作和项目管理至关重要。
Docker： 使用容器化技术来打包和部署你的应用。

结语

Flask 提供了一个强大而灵活的平台，让你能够从简单的原型到复杂的应用，以自己喜欢的方式构建 Web 服务。本教程为你打下了坚实的基础，但真正的学习在于实践。

现在，是时候将你所学付诸实践了！尝试构建一个小型的博客、一个待办事项列表应用、一个简单的照片分享网站。在实践中你会遇到问题，解决问题是成长的最佳方式。

祝你在 Flask 的世界里开发愉快！

Flask 基础教程：新手快速上手指南

引言：欢迎来到 Flask 的世界！

1. 什么是 Flask？为什么选择它？

1.1 Flask 简介

1.2 为什么选择 Flask？

2. 准备工作：搭建你的开发环境

2.1 安装 Python

2.2 使用虚拟环境（强烈推荐！）

2.3 安装 Flask

3. 你的第一个 Flask 应用：Hello, Flask!

1. 创建 Flask 应用实例

name 是 Python 的一个特殊变量，表示当前模块的名称。

Flask 用它来确定应用的根目录，以便找到模板和静态文件等资源。

2. 定义路由（Route）

@app.route(‘/’) 是一个装饰器，它将下面的函数绑定到 URL 路径 ‘/’。

当用户访问应用的根 URL 时，这个函数就会被调用。

4. 运行应用

确保只有在直接运行 app.py 文件时才启动开发服务器。

debug=True 开启调试模式，当代码修改时服务器会自动重启，并提供详细的错误信息。