Flask 快速入门：Python Web 框架教程 – wiki基地

作者： /

Flask 快速入门：Python Web 框架教程

欢迎来到 Web 开发的世界！如果你是一位 Python 爱好者，并渴望构建自己的网站或 Web 应用，那么 Flask 绝对是一个值得你学习的优秀框架。Flask 是一个用 Python 编写的微型 Web 框架，它简单、灵活、易于上手，非常适合初学者入门，同时也足够强大，可以构建复杂的应用。

本篇文章将带你一步步踏入 Flask 的殿堂，从环境搭建到构建第一个简单的 Web 应用，再到处理路由、模板、静态文件、表单等核心概念。无论你是否有 Web 开发经验，只要具备基本的 Python 知识，就能轻松跟随本教程。

为什么选择 Flask？

在众多 Python Web 框架中，为什么选择 Flask 呢？

  1. 微框架特性： Flask 被称为微框架（Microframework），这意味着它核心精简，只提供 Web 开发最基本的功能（请求处理、路由、模板）。它不包含 ORM（对象关系映射）、表单验证等复杂组件，但提供了强大的扩展机制，你可以根据需要选择并集成各种第三方库。这种“不提供但允许”的哲学，使得 Flask 既轻量又灵活。
  2. 简单易学： Flask 的 API 设计直观简洁，代码量少，概念清晰，非常适合快速入门和原型开发。许多功能只需要几行代码就能实现。
  3. 灵活性高： 由于不包含过多内置组件，开发者拥有更大的自由度来选择自己喜欢的库和工具，可以根据项目需求高度定制化。
  4. 强大的社区和生态： Flask 拥有一个活跃的社区，提供了大量的扩展（Flask-SQLAlchemy、Flask-WTF、Flask-Login 等），几乎可以满足你在 Web 开发中的各种需求。遇到问题时，很容易找到解决方案。
  5. 良好的文档： Flask 的官方文档非常完善和清晰，是学习和查阅的宝贵资源。

当然，Flask 并非万能。对于需要快速搭建功能齐全的大型应用，且希望框架提供更多“开箱即用”功能的场景，全栈框架（如 Django）可能是更好的选择。但对于入门、构建小型应用、API 服务或对框架有高度定制需求的场景，Flask 的优势就凸显出来了。

准备工作：环境搭建

在开始编写 Flask 应用之前，我们需要搭建一个干净的开发环境。

1. 安装 Python

确保你的计算机上已经安装了 Python 3.6 或更高版本。你可以通过在终端或命令提示符中运行以下命令来检查：

“`bash
python –version

或者

python3 –version
“`

如果未安装，请访问 Python 官网 (https://www.python.org/downloads/) 下载并安装。

2. 使用虚拟环境 (Virtual Environments)

在开发 Python 项目时，强烈建议使用虚拟环境。虚拟环境可以为每个项目创建一个独立的 Python 环境，使得项目依赖的库互不干扰，避免版本冲突。

Python 3.3+ 内置了 venv 模块来创建虚拟环境。

  • 创建虚拟环境：
    打开你的终端或命令提示符，进入你希望存放项目的文件夹，然后运行以下命令：

    “`bash

    在当前目录下创建一个名为 ‘venv’ 的虚拟环境

    python -m venv venv
    “`

  • 激活虚拟环境：

    • macOS / Linux:

      bash
      source venv/bin/activate

    • Windows (命令提示符):

      bash
      venv\Scripts\activate.bat

    • Windows (PowerShell):

      powershell
      venv\Scripts\Activate.ps1

    激活成功后，你的终端提示符前面会显示虚拟环境的名称（通常是 (venv)），表示你当前正在虚拟环境中操作。

  • 退出虚拟环境：

    随时可以运行 deactivate 命令退出虚拟环境。

    bash
    deactivate

请确保在接下来的所有操作中，你都处于激活的虚拟环境中。

3. 安装 Flask

激活虚拟环境后，我们就可以使用 pip 来安装 Flask 了。

bash
pip install Flask

pip 会自动下载并安装 Flask 及其依赖项。安装完成后，你可以运行 pip list 来查看当前环境中安装的所有库，确认 Flask 是否安装成功。

现在，你的开发环境已经准备就绪，可以开始编写第一个 Flask 应用了！

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

按照惯例，我们从一个经典的 “Hello, World!” 应用开始。

在一个你喜欢的代码编辑器中，在你项目文件夹的根目录下创建一个新的 Python 文件，比如 app.py。然后输入以下代码：

“`python

app.py

从 flask 库中导入 Flask 类

from flask import Flask

创建一个 Flask 应用实例

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

Flask 使用它来确定应用根目录，以便找到资源文件（如模板和静态文件）

app = Flask(name)

使用装饰器 @app.route() 定义一个 URL 路由

当用户访问网站的根 URL（’/’）时，下面的函数会被调用

@app.route(‘/’)
def hello_world():
# 这个函数被称为视图函数 (view function)
# 它负责处理请求并返回响应。
# 在这里，我们返回一个简单的字符串作为响应。
return ‘Hello, World! 这是我的第一个 Flask 应用！’

运行应用

确保这个脚本直接运行时才启动开发服务器

if name == ‘main‘:
# app.run() 启动 Flask 的内置开发服务器
# debug=True 模式开启调试功能，会在代码修改后自动重新加载应用
# 并且在发生错误时提供详细的调试信息
app.run(debug=True)
“`

代码解释：

  1. from flask import Flask: 导入 Flask 类，这是创建 Flask 应用的基础。
  2. app = Flask(__name__): 创建 Flask 应用的一个实例。__name__ 告诉 Flask 在哪里查找资源。
  3. @app.route('/'): 这是一个装饰器。在 Flask 中，装饰器用于将 URL 路径 ('/' 代表网站的根目录) 绑定到特定的 Python 函数。这个函数就被称为 视图函数。
  4. def hello_world():: 定义了一个视图函数。当用户访问与 @app.route 装饰器中定义的 URL 匹配的路径时，Flask 会调用这个函数。
  5. return 'Hello, World! ...': 视图函数返回一个字符串。在 Web 应用中，这个字符串就是发送给用户浏览器作为响应的内容。
  6. if __name__ == '__main__':: 这是一个标准的 Python 结构，确保 app.run() 只在直接运行此脚本时执行，而不是在作为模块被导入时执行。
  7. app.run(debug=True): 启动 Flask 的开发服务器。
    • debug=True: 开启调试模式。在调试模式下，服务器会在代码修改后自动重启，并且在程序出错时提供一个交互式的调试器，这在开发阶段非常有用。注意：调试模式不应该在生产环境中使用，因为它存在安全风险。

运行你的应用

保存 app.py 文件。确保你的终端仍然在激活的虚拟环境中，并且在 app.py 所在的目录下。然后运行以下命令：

bash
python app.py

你应该会看到类似以下的输出：

* Serving Flask app "app" (lazy loading)
* Environment: development
* Debug mode: on
* Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
* Restarting with stat
* Debugger is active!
* Debugger PIN: XXX-XXX-XXX

这表示 Flask 开发服务器已经启动，并在 http://127.0.0.1:5000/ 上监听请求。127.0.0.1 是本地回环地址，5000 是 Flask 默认的端口号。

打开你的 Web 浏览器，访问 http://127.0.0.1:5000/。

你应该能在浏览器中看到 “Hello, World! 这是我的第一个 Flask 应用！” 这段文字。

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

在终端中按 Ctrl+C 可以停止开发服务器。

Flask 的核心概念深入

现在我们已经运行了最简单的应用，接下来我们深入了解一些 Flask 的核心概念。

1. 路由 (Routing)

路由是 Flask 应用中定义 URL 模式并将其映射到视图函数的过程。 @app.route() 装饰器就是用来实现这个功能的。

我们可以定义多个路由和视图函数：

“`python
from flask import Flask

app = Flask(name)

@app.route(‘/’)
def index():
return ‘欢迎来到首页！’

@app.route(‘/about’)
def about():
return ‘这是一个关于页面。’

@app.route(‘/contact’)
def contact():
return ‘联系我们：请发送邮件…’

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

保存并运行这个文件。现在访问 http://127.0.0.1:5000/about 和 http://127.0.0.1:5000/contact，你将看到对应视图函数的输出。

2. 动态路由 (Dynamic Routes)

很多时候，URL 需要包含一些可变的部分，比如用户 ID、文章标题等。Flask 支持在路由中使用变量：

“`python
from flask import Flask

app = Flask(name)

@app.route(‘/user/‘)
def show_user_profile(username):
# username 是从 URL 中捕获的变量，会作为参数传递给视图函数
return f’用户：{username}’

@app.route(‘/post/‘)
def show_post(post_id):
# 表示 post_id 必须是整数，并且会被转换为整数类型
return f’文章 ID：{post_id}’

你也可以混合使用

@app.route(‘//tasks/‘)
def show_task(project_slug, task_id):
return f’项目：{project_slug}，任务 ID：{task_id}’

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

变量类型转换器：

Flask 提供了几种默认的变量类型转换器：

  • <string>: (默认) 接受任何不包含斜杠的字符串。
  • <int>: 接受整数。
  • <float>: 接受浮点数。
  • <path>: 接受包含斜杠的字符串（路径）。
  • <uuid>: 接受 UUID 字符串。

通过 <converter:variable_name> 的形式在路由中使用。

3. HTTP 方法 (HTTP Methods)

Web 应用不仅处理 GET 请求（获取数据），还需要处理 POST（提交数据）、PUT（更新数据）、DELETE（删除数据）等请求。@app.route 装饰器可以使用 methods 参数指定视图函数接受的 HTTP 方法列表。

“`python
from flask import Flask, request

app = Flask(name)

这个路由只接受 GET 请求（默认）

@app.route(‘/login_get’)
def login_get():
return ‘

‘

这个路由只接受 POST 请求

@app.route(‘/login_post’, methods=[‘POST’])
def login_post():
# 从请求中获取表单数据
username = request.form.get(‘username’)
return f’欢迎回来, {username}!’

接受 GET 和 POST 请求

@app.route(‘/submit’, methods=[‘GET’, ‘POST’])
def submit_data():
if request.method == ‘POST’:
# 处理 POST 请求的数据
data = request.form.get(‘data_field’)
return f’你提交的数据是: {data}’
else:
# 处理 GET 请求，通常是显示一个表单
return ‘

‘

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

在上面的例子中，我们引入了 request 对象。request 是一个全局对象（实际上是线程局部对象），包含了当前请求的所有信息，如表单数据 (request.form)、URL 参数 (request.args)、请求方法 (request.method) 等。

4. 渲染模板 (Rendering Templates)

直接在视图函数中返回 HTML 字符串非常不灵活，特别是当 HTML 结构复杂或包含动态内容时。Flask 使用 模板引擎 来生成动态 HTML。Flask 默认集成了 Jinja2 模板引擎，它功能强大且易于使用。

步骤：

  1. 创建 templates 文件夹： 在你的项目根目录下创建一个名为 templates 的文件夹。Flask 默认会在这个文件夹中查找模板文件。
  2. 创建 HTML 模板文件： 在 templates 文件夹中创建一个 .html 文件，比如 index.html。
  3. 在模板中使用 Jinja2 语法： Jinja2 模板使用 {{ variable }} 来显示变量的值，使用 {% control_structure %} 来实现逻辑控制（如循环、条件判断）。
  4. 在视图函数中渲染模板： 导入 render_template 函数，并使用它来渲染模板并将数据传递给模板。

示例：

创建 templates/index.html:

“`html




{{ page_title }} – 我的 Flask 应用


欢迎，{{ user_name or ‘访客’ }}！

{{ greeting }}

水果列表：

    {% for fruit in fruits %}

  • {{ fruit }}

    • {% else %}

  • 没有水果。

    • {% endfor %}

当前年份：{{ current_year }}


“`

修改 app.py:

“`python
from flask import Flask, render_template
import datetime

app = Flask(name)

@app.route(‘/’)
def index():
# 定义要传递给模板的数据
data = {
‘page_title’: ‘首页’,
‘greeting’: ‘很高兴你来到这里！’,
‘user_name’: ‘Alice’, # 假设这是从用户登录信息中获取的名字
‘fruits’: [‘苹果’, ‘香蕉’, ‘橙子’, ‘葡萄’],
‘current_year’: datetime.datetime.now().year
}
# 使用 render_template 渲染 templates 文件夹下的 index.html
# 并将 data 字典中的键值对作为变量传递给模板
return render_template(‘index.html’, data) # 使用 data 解包字典传递参数

@app.route(‘/guest’)
def guest_index():
data = {
‘page_title’: ‘访客页’,
‘greeting’: ‘这是为访客准备的页面。’,
‘user_name’: None, # 没有用户信息
‘fruits’: [], # 空列表
‘current_year’: datetime.datetime.now().year
}
return render_template(‘index.html’, **data)

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

运行 app.py，访问 http://127.0.0.1:5000/ 和 http://127.0.0.1:5000/guest。你会看到根据传递给模板的不同数据生成了不同的 HTML 页面。

通过 Jinja2，我们可以轻松地在 HTML 中插入动态内容、执行循环、条件判断等，使得页面生成更加灵活和模块化。

5. 静态文件 (Static Files)

Web 应用还需要提供静态文件，如 CSS 样式表、JavaScript 脚本、图片等。Flask 默认会在项目根目录下的一个名为 static 的文件夹中查找静态文件。

步骤：

  1. 创建 static 文件夹： 在项目根目录下创建一个名为 static 的文件夹。
  2. 存放静态文件： 将你的 CSS、JS、图片等文件放在 static 文件夹及其子文件夹中。例如，创建一个 static/css 文件夹并在里面放一个 style.css 文件。
  3. 在模板中链接静态文件： 在 HTML 模板中使用 url_for() 函数来生成静态文件的 URL。

示例：

创建 static/css/style.css:

“`css
body {
background-color: #f0f0f0;
color: #333;
}

h1 {
color: #007bff;
}

ul {
list-style-type: square;
}
“`

修改 templates/index.html (添加 CSS 链接):

“`html




{{ page_title }} – 我的 Flask 应用

欢迎，{{ user_name or ‘访客’ }}！

{{ greeting }}

水果列表：

    {% for fruit in fruits %}

  • {{ fruit }}

    • {% else %}

  • 没有水果。

    • {% endfor %}

当前年份：{{ current_year }}


“`

修改 app.py (无需改动，静态文件由 Flask 自动处理):

“`python
from flask import Flask, render_template
import datetime

app = Flask(name)

@app.route(‘/’)
def index():
data = {
‘page_title’: ‘首页’,
‘greeting’: ‘很高兴你来到这里！’,
‘user_name’: ‘Alice’,
‘fruits’: [‘苹果’, ‘香蕉’, ‘橙子’, ‘葡萄’],
‘current_year’: datetime.datetime.now().year
}
return render_template(‘index.html’, **data)

@app.route(‘/guest’)
def guest_index():
data = {
‘page_title’: ‘访客页’,
‘greeting’: ‘这是为访客准备的页面。’,
‘user_name’: None,
‘fruits’: [],
‘current_year’: datetime.datetime.now().year
}
return render_template(‘index.html’, **data)

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

运行应用并访问页面，你会看到页面使用了 style.css 定义的样式。

url_for('static', filename='css/style.css') 函数的第一个参数 'static' 是 Flask 内置的用于处理静态文件的端点名称。filename 参数是静态文件相对于 static 文件夹的路径。使用 url_for 来生成 URL 是推荐的方式，因为它会根据你的应用配置正确生成 URL，避免硬编码路径带来的问题。

6. 表单处理与请求对象 (Form Handling and Request Object)

Web 应用通常需要处理用户通过 HTML 表单提交的数据。我们前面已经初步接触了 request 对象。现在我们更详细地看看如何处理表单。

当用户通过表单提交数据时（通常是 POST 请求），这些数据会被包含在请求体中。在 Flask 中，可以通过 request.form 来访问这些数据（对于 application/x-www-form-urlencoded 或 multipart/form-data 类型的表单）。如果数据是通过 URL 参数传递的（GET 请求），可以使用 request.args。

示例：一个简单的登录表单

创建 templates/login.html:

“`html




登录页面

用户登录





“`

修改 app.py:

“`python
from flask import Flask, render_template, request, redirect, url_for, flash

app = Flask(name)
app.config[‘SECRET_KEY’] = ‘这是一个非常安全的密钥，用于保护会话和闪现消息’ # 生产环境中请使用复杂且随机的密钥

GET 请求用于显示登录表单，POST 请求用于处理登录提交

@app.route(‘/login’, methods=[‘GET’, ‘POST’])
def login():
if request.method == ‘POST’:
# 从 POST 请求中获取表单数据
username = request.form.get(‘username’)
password = request.form.get(‘password’)

    # 这里只是一个简单的示例验证，实际应用中需要查询数据库等
    if username == 'admin' and password == 'password':
        # 登录成功，重定向到首页或其他页面
        flash('登录成功！', 'success') # 添加一个闪现消息
        return redirect(url_for('index')) # 重定向到 index 视图函数对应的 URL
    else:
        # 登录失败，重新显示登录表单并显示错误消息
        flash('用户名或密码错误！', 'danger')
        return render_template('login.html') # 重新渲染登录页面

# 如果是 GET 请求，则显示登录表单
return render_template('login.html')

假设这是登录成功后重定向到的页面

@app.route(‘/’)
def index():
# flash() 的消息需要在模板中显示
return render_template(‘index.html’, page_title=’首页’)

创建一个 templates/index.html 并在其中显示闪现消息

(可以在 body 顶部添加)

“””
{% with messages = get_flashed_messages(with_categories=true) %}
{% if messages %}

    {% for category, message in messages %}

  • {{ message }}

    • {% endfor %}

{% endif %}
{% endwith %}
“””

这里的 index.html 假设已经存在，内容可以是你希望登录成功后看到的页面

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

代码解释：

  1. from flask import ..., redirect, url_for, flash: 导入处理重定向、生成 URL 和闪现消息所需的函数。
  2. app.config['SECRET_KEY'] = '...': 设置一个密钥。这是使用会话 (session) 或闪现消息 (flash) 所必需的，用于加密。在生产环境中，请使用一个随机生成、足够复杂的密钥，并妥善保管。
  3. @app.route('/login', methods=['GET', 'POST']): 这个路由接受 GET 和 POST 请求。GET 用于显示表单，POST 用于处理提交。
  4. if request.method == 'POST':: 检查请求方法是否为 POST。
  5. username = request.form.get('username'): 使用 request.form.get() 获取表单中名为 ‘username’ 的输入框的值。使用 .get() 方法而不是直接 request.form['username'] 可以避免在键不存在时抛出 KeyError。
  6. redirect(url_for('index')): 使用 redirect() 函数进行重定向。url_for('index') 函数会根据视图函数名 'index' 查找其对应的 URL 规则（在本例中是 '/'），并生成相应的 URL。这样做的好处是，即使将来你修改了 '/' 路由对应的视图函数名，这里的重定向代码也不需要修改。
  7. flash('消息', '类别'): 添加一条闪现消息。消息会被存储在用户的会话中，通常在下一个请求中显示一次后就会被移除。类别（可选）可以用来控制消息的样式（如 ‘success’, ‘danger’）。需要在模板中使用 get_flashed_messages() 函数来获取并显示这些消息（如上面的 index.html 注释所示）。
  8. render_template('login.html'): 如果登录失败，重新渲染登录模板，用户可以看到错误消息并再次尝试。

这个示例演示了如何使用 Flask 处理 HTTP 方法、访问表单数据、进行重定向以及使用闪现消息。

7. 数据库集成 (Database Integration)

几乎所有的实际 Web 应用都需要与数据库交互来存储和检索数据。Flask 本身不提供数据库功能，但由于其微框架特性，你可以自由选择任何 Python 数据库库或 ORM。

常用的选择包括：

  • SQLAlchemy: 一个功能强大的 ORM，支持多种数据库后端（SQLite, PostgreSQL, MySQL 等）。通常与 Flask-SQLAlchemy 扩展一起使用，后者简化了 SQLAlchemy 在 Flask 中的集成。
  • 数据库连接器： 如果你想直接使用 SQL，可以使用数据库对应的 Python 库，例如 psycopg2 (PostgreSQL), mysql.connector (MySQL), sqlite3 (Python 内置，适合小型应用或开发测试)。

由于数据库内容本身就是一个非常大的主题，在本快速入门教程中无法详细展开。但知道如何选择和集成是重要的。对于初学者，使用 SQLite 配合 SQLAlchemy (通过 Flask-SQLAlchemy 扩展) 是一个不错的起点。

8. 应用结构 (Application Structure)

随着应用功能的增加，所有代码都放在一个 app.py 文件中会变得难以维护。Flask 提供了几种组织大型应用的方式：

  • 简单的模块化： 将相关的视图函数、模型（如果使用 ORM）、表单类等放在不同的 Python 文件中，并在主应用文件 (app.py) 中导入和注册。
  • 蓝图 (Blueprints): 这是 Flask 官方推荐的组织大型应用的方式。蓝图可以将应用划分为独立的、可重用的组件。每个蓝图可以有自己的视图函数、模板文件夹、静态文件文件夹等。然后将这些蓝图注册到主应用实例上。这使得应用结构清晰，便于维护和扩展。

“`python

示例：使用蓝图（简化）

projects/routes.py (示例蓝图文件)

from flask import Blueprint, render_template

创建一个蓝图实例

projects_bp = Blueprint(‘projects’, name, url_prefix=’/projects’,
template_folder=’templates’, # 蓝图自己的模板文件夹 (相对于这个文件)
static_folder=’static’) # 蓝图自己的静态文件夹 (相对于这个文件)

@projects_bp.route(‘/’)
def list_projects():
# 在这里访问 projects 蓝图下的 templates 文件夹中的文件
return render_template(‘projects/list.html’)

@projects_bp.route(‘/‘)
def show_project(project_id):
return f’项目详情: {project_id}’

app.py (主应用文件)

from flask import Flask
from projects.routes import projects_bp # 从蓝图文件导入蓝图实例

app = Flask(name)

注册蓝图到主应用

app.register_blueprint(projects_bp)

@app.route(‘/’)
def index():
return ‘主应用首页’

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

使用蓝图可以让你将与特定功能（如用户管理、博客、API）相关的代码组织在一起，提高代码的可读性和可维护性。

9. 调试 (Debugging)

在开发过程中，遇到错误是常有的事。Flask 的 debug=True 模式是你的好帮手。当应用发生未捕获的异常时，它会在浏览器中显示一个交互式的调试器。你可以查看堆栈跟踪、变量值，甚至在浏览器中执行 Python 代码来排查问题。

重要提示： 绝对不要 在生产环境中开启 debug=True，因为它会泄露敏感信息并存在安全风险。

除了内置调试器，你还可以使用标准的 Python 调试工具，如 pdb 或集成开发环境（IDE）提供的调试功能。

10. 部署 (Deployment)

app.run() 启动的开发服务器是单线程的，性能低下，并且存在安全问题，仅用于开发和测试。将 Flask 应用部署到生产环境需要使用更健壮的 Web 服务器网关接口 (WSGI) 服务器。

流行的 WSGI 服务器包括：

  • Gunicorn: (GUnicorn ‘Green Unicorn’) 一个基于 pre-fork 模型的高性能 WSGI 服务器，常用于 Unix 系统。
  • uWSGI: 一个功能更强大、配置选项更多的 WSGI 服务器，支持多种协议和平台。

通常的部署流程是：

  1. 在服务器上安装 Python、虚拟环境和你的应用依赖。
  2. 将你的 Flask 应用代码上传到服务器。
  3. 配置一个 WSGI 服务器来运行你的 Flask 应用（例如 gunicorn app:app，其中第一个 app 是文件名，第二个 app 是 Flask 应用实例的变量名）。
  4. 配置一个反向代理服务器（如 Nginx 或 Apache）来接收外部请求，并将这些请求转发给 WSGI 服务器。反向代理服务器还可以处理静态文件、SSL 加密、负载均衡等。

许多云平台（如 Heroku, PythonAnywhere, AWS Elastic Beanstalk, Google App Engine）提供了方便的部署服务，可以简化部署流程。

总结与下一步

通过本教程，你已经：

  • 了解了 Flask 是什么以及为什么选择它。
  • 搭建了 Flask 开发环境，学会了使用虚拟环境和 pip 安装 Flask。
  • 编写并运行了你的第一个 Flask “Hello, World!” 应用。
  • 掌握了 Flask 的核心概念：路由、动态路由、HTTP 方法、模板渲染 (Jinja2)、静态文件服务、简单的表单处理和请求对象。
  • 初步了解了 Flask 的应用结构组织（蓝图概念）、调试和部署。

这只是 Flask 的冰山一角。要成为一名熟练的 Flask 开发者，你还需要进一步学习：

  • Flask 扩展： 探索 Flask-SQLAlchemy (数据库), Flask-WTF (表单), Flask-Login (用户认证), Flask-Migrate (数据库迁移), Flask-RESTful (构建 API) 等常用扩展。
  • 数据库操作： 深入学习如何使用 ORM（如 SQLAlchemy）进行数据的增删改查。
  • 用户认证和授权： 实现用户注册、登录、注销以及控制用户对资源的访问权限。
  • 会话 (Session)： 在请求之间存储用户特定信息。
  • 错误处理： 如何处理 404 错误、500 错误以及自定义错误页面。
  • 测试： 编写单元测试和集成测试来确保你的应用按预期工作。
  • 前后端分离： 如果你想构建更复杂的前端应用（使用 React, Vue, Angular 等），Flask 可以作为一个强大的后端 API 框架。
  • 更高级的部署： 学习如何在不同的生产环境中部署和扩展你的应用。

Flask 的官方文档 (https://flask.palletsprojects.com/) 是你继续深入学习的最佳资源。同时，多动手实践，尝试构建一些小项目，是掌握任何框架的关键。

祝你在 Flask 的 Web 开发之旅中一切顺利！从现在开始，去创造属于你自己的 Web 世界吧！

发表评论

您的邮箱地址不会被公开。 必填项已用 * 标注

滚动至顶部