Python Flask 快速入门教程：构建你的第一个 Web 应用

欢迎来到 Flask 的世界！如果你已经掌握了一些 Python 基础知识，并且对构建 Web 应用充满兴趣，那么 Flask 是一个非常棒的起点。作为一个轻量级的 Web 框架，Flask 以其简洁、灵活和易于扩展的特性而备受欢迎。它不会替你做太多决策，这使得它既适合小型项目，也适合构建更大型、更复杂的应用，只要你愿意引入适当的扩展。

本教程将带你从零开始，一步步构建一个简单的 Flask 应用，并详细解释其中的每一个重要概念。我们将涵盖从安装、运行到处理请求、使用模板和静态文件等核心内容。

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

Flask 是一个用 Python 编写的微型 Web 框架。这里的“微型”指的是它自身只包含一个 Web 应用开发所需的最低限度核心功能。它不包含数据库抽象层、表单验证等现成组件，而是通过各种扩展（Extensions）来按需添加这些功能。这种设计哲学让 Flask 保持核心简洁，并提供了极高的灵活性。

为什么选择 Flask？

简洁优雅： 代码量少，概念清晰，非常适合初学者入门。
灵活自由： 不强制使用特定的工具或库，你可以自由选择你喜欢的数据库、模板引擎等（尽管它默认集成了 Jinja2 模板引擎）。
易于上手： 只需几行代码就能创建一个功能简单的 Web 应用。
强大的生态： 拥有丰富的第三方扩展，可以轻松集成各种功能（如数据库ORM、用户认证、RESTful API、后台管理等）。
活跃的社区： 遇到问题很容易找到帮助和资源。

相比之下，像 Django 这样的全功能框架提供了更多的“开箱即用”组件，这对于快速开发特定类型的应用很有优势，但对于初学者来说，Flask 的微型特性可以让你更容易理解 Web 应用的基本工作原理。

2. 准备工作：安装 Python 和创建虚拟环境

在开始之前，你需要确保你的计算机上已经安装了 Python 3。你可以从 Python 官方网站下载并安装最新版本。安装完成后，打开终端或命令提示符，输入 python --version 或 python3 --version 来确认 Python 是否安装成功。

“`bash
python –version

或者

python3 –version
“`

（注意：在某些系统上，Python 3 的命令可能是 python3）

接下来，强烈建议为你的项目创建一个虚拟环境（Virtual Environment）。虚拟环境是一个独立的 Python 环境，可以让你在其中安装特定项目的依赖库，而不会干扰系统中全局安装的库或其他项目的库。这有助于保持项目的依赖清晰和隔离。

Python 3.3+ 自带了 venv 模块，这是创建虚拟环境的推荐方式。

创建虚拟环境：

打开终端或命令提示符。
导航到你打算创建项目的目录。
运行以下命令创建虚拟环境（例如，命名为 venv）：

bash python -m venv venv

这会在当前目录下创建一个名为 venv 的文件夹，里面包含了独立的 Python 解释器和 pip。

激活虚拟环境：

macOS/Linux:

bash source venv/bin/activate
Windows:

bash venv\Scripts\activate

激活成功后，你的终端提示符前会显示虚拟环境的名称（例如 (venv)）。现在，你在这个终端中安装的所有 Python 包都将只安装到这个虚拟环境中。

3. 安装 Flask

虚拟环境激活后，安装 Flask 就非常简单了。只需使用 pip 命令：

bash pip install Flask

pip 会自动下载并安装 Flask 及其依赖项（如 Werkzeug、Jinja2、MarkupSafe、ItsDangerous、click）。

安装完成后，你可以通过运行以下命令来确认 Flask 是否已安装：

bash pip show Flask

这会显示 Flask 的信息，包括版本号和安装路径。

4. 你的第一个 Flask 应用：“Hello, World!”

现在，让我们编写第一个 Flask 应用。在一个文本编辑器或 IDE 中创建一个新的 Python 文件（例如，命名为 app.py）。

输入以下代码：

“`python

app.py

1. 从 flask 模块导入 Flask 类

from flask import Flask

2. 创建 Flask 应用实例

name 是当前模块的名称，Flask 用它来确定应用程序的根目录

app = Flask(name)

3. 定义路由和视图函数

@app.route(‘/’) 是一个装饰器，它将 URL “/” 映射到 hello_world 函数

@app.route(‘/’)
def hello_world():
# 视图函数返回一个字符串，作为 HTTP 响应体
return ‘Hello, World!’

4. 运行应用

确保这个文件是作为主程序运行时才执行 app.run()

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

保存文件。现在，回到激活了虚拟环境的终端中，运行这个 Python 文件：

bash python app.py

或者，如果你在 Windows 上使用 python 代替 python3：

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/ 监听请求。打开你的 Web 浏览器，访问这个地址。

你应该会看到页面上显示 “Hello, World!”。

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

5. 解释第一个应用的代码

让我们详细分解一下刚才的代码：

from flask import Flask: 这一行从安装的 flask 库中导入了 Flask 类。它是创建 Flask 应用的核心。
app = Flask(__name__): 这一行创建了一个 Flask 类的实例，并将其赋值给变量 app。__name__ 是一个特殊的 Python 变量，表示当前模块的名称。Flask 使用它来查找资源（如模板和静态文件）。在大多数情况下，传递 __name__ 就足够了。
@app.route('/'): 这是一个装饰器（Decorator）。在 Python 中，装饰器是一种修改函数行为的特殊语法。在这里，@app.route('/') 装饰器告诉 Flask，当用户访问网站的根 URL（即 "/"）时，应该执行紧跟在其下面的函数。
def hello_world():: 这是一个标准的 Python 函数。在 Flask 中，与路由关联的函数被称为视图函数（View Function）。当对应的 URL 被请求时，这个函数就会被调用。
return 'Hello, World!': 视图函数执行完毕后，需要返回一个值，这个值将作为 HTTP 响应的主体发送给用户的浏览器。在这里，我们返回了一个简单的字符串。Flask 会自动将这个字符串包装在一个完整的 HTTP 响应中，并设置正确的 MIME 类型（默认为 text/html）。视图函数也可以返回 HTML、JSON 或者更复杂的响应对象。
if __name__ == '__main__':: 这是标准的 Python 惯用法。它确保 app.run() 只在直接运行这个脚本时执行，而不是在它作为模块被导入到其他脚本中时执行。
app.run(debug=True): 这一行启动 Flask 内置的开发 Web 服务器。
- debug=True 参数开启了调试模式。在开发阶段开启调试模式非常有益：
  - 当你的代码发生错误时，浏览器中会显示一个详细的交互式调试器，帮助你诊断问题。
  - 当你修改了 Python 代码并保存文件后，服务器会自动重新加载，无需手动停止和重启。

注意： debug=True 仅用于开发环境。在生产环境中，绝对不要开启调试模式，因为它会暴露敏感信息并存在安全风险。在生产环境部署时，你会使用更健壮的 Web 服务器（如 Gunicorn、uWSGI）和专门的 Web 服务器（如 Nginx、Apache）来提供服务。

6. 添加更多路由和页面

一个 Web 应用通常包含多个页面或功能，对应着不同的 URL。在 Flask 中，你可以通过添加更多的 @app.route() 装饰器来定义多个路由和视图函数。

修改 app.py 文件，添加另一个路由：

“`python

app.py

from flask import Flask

app = Flask(name)

@app.route(‘/’)
def hello_world():
return ‘Hello, World!’

新增路由 /about

@app.route(‘/about’)
def about():
return ‘这是关于我们页面！’

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

保存文件。因为 debug=True 开启了自动重载，服务器应该已经自动重启了。

现在，在浏览器中访问 http://127.0.0.1:5000/about。你应该能看到页面上显示 “这是关于我们页面！”。

你可以按照这种方式添加任意多的路由，每个路由都对应一个特定的 URL 路径和一个处理该请求的视图函数。

7. 动态路由：使用变量规则

很多时候，你的 URL 需要包含可变的部分，例如用户的 ID、文章的标题等。Flask 允许你在路由规则中使用变量标记 <variable_name>。

修改 app.py 文件：

“`python

app.py

from flask import Flask

app = Flask(name)

@app.route(‘/’)
def hello_world():
return ‘Hello, World!’

@app.route(‘/about’)
def about():
return ‘这是关于我们页面！’

新增动态路由 /user/

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

动态路由，使用类型转换器

@app.route(‘/post/‘)
def show_post(post_id):
# post_id 会从 URL 中捕获，并自动转换为整数类型
return f’文章 ID: {post_id}’

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

保存文件。现在尝试访问以下 URL：

http://127.0.0.1:5000/user/alice
http://127.0.0.1:5000/user/bob
http://127.0.0.1:5000/post/1
http://127.0.0.1:5000/post/12345

你会看到页面根据 URL 中的变量显示不同的内容。

变量规则：

在路由规则中，你可以使用 <variable_name> 来标记一个变量部分。这个变量会被作为关键字参数传递给对应的视图函数。

类型转换器：

Flask 还支持在变量规则中指定类型转换器，例如 <int:variable_name> 或 <string:variable_name>。这可以确保捕获到的 URL 部分符合指定的类型，并在不匹配时返回 404 错误。常用的类型转换器包括：

<string>: 默认类型，接受任何不包含斜杠的文本。
<int>: 接受整数。
<float>: 接受浮点数。
<path>: 接受包含斜杠的文本，常用于文件路径。
<uuid>: 接受 UUID 字符串。

8. HTTP 方法：GET 和 POST

Web 请求可以使用不同的 HTTP 方法，最常见的是 GET 和 POST。

GET: 用于从服务器获取数据。当你直接在浏览器地址栏输入 URL 或点击链接时，通常使用的是 GET 请求。GET 请求的数据（查询参数）会附加在 URL 的后面。
POST: 用于向服务器提交数据（例如，提交表单）。POST 请求的数据通常放在请求体中，不会显示在 URL 中。

默认情况下，Flask 路由只响应 GET 请求。要允许其他方法，可以在 @app.route() 装饰器中添加 methods 参数。

修改 app.py，创建一个简单的表单处理示例（尽管我们稍后会用模板来更好地处理表单）：

“`python

app.py

from flask import Flask, request # 导入 request 对象

app = Flask(name)

… 其他路由（hello_world, about, show_user_profile, show_post） …

新增一个处理登录的路由，允许 GET 和 POST 方法

@app.route(‘/login’, methods=[‘GET’, ‘POST’])
def login():
if request.method == ‘POST’:
# 如果是 POST 请求，处理提交的表单数据
username = request.form.get(‘username’) # 从表单数据中获取 username 字段
password = request.form.get(‘password’) # 从表单数据中获取 password 字段
# 这里可以添加验证逻辑
if username == ‘admin’ and password == ‘password’:
return ‘登录成功！欢迎管理员。’
else:
return ‘用户名或密码错误！’
else:
# 如果是 GET 请求，显示登录表单
return ”’

”’

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

保存文件。现在访问 http://127.0.0.1:5000/login。

初次访问时，你会看到一个简单的 HTML 表单（这是一个 GET 请求）。
在表单中输入用户名和密码，然后点击“Login”按钮。浏览器会向 /login URL 发送一个 POST 请求。
login() 函数会检测到 request.method == 'POST' 为真，然后从 request.form 中获取提交的数据，并根据简单的判断逻辑返回不同的结果。

request 对象：

Flask 提供了一个全局的 request 对象，它包含了当前请求的所有信息，例如：

request.method: 请求的方法（’GET’, ‘POST’ 等）。
request.args: 解析 URL 查询参数（GET 请求中的 ?key=value）。
request.form: 解析 POST 请求中的表单数据。
request.json: 解析 POST 请求中的 JSON 数据。
request.cookies: 请求中的 cookies。
request.headers: 请求头信息。

你需要从 flask 模块导入 request 才能使用它。

9. 使用模板：分离逻辑与表现

在前面的例子中，我们将 HTML 代码直接写在了 Python 视图函数中。对于简单的返回字符串或少量 HTML 尚可，但对于复杂的页面结构，这种方式变得难以维护。理想情况下，我们应该将 Python 逻辑（视图函数）与 HTML 结构（页面布局）分离开来。

这就是模板引擎的作用。Flask 默认集成了 Jinja2 模板引擎，它功能强大且易于使用。

步骤：

创建 templates 文件夹： 在与 app.py 文件相同的目录下，创建一个名为 templates 的新文件夹。Flask 默认会在这个文件夹中查找模板文件。
创建 HTML 模板文件： 在 templates 文件夹中创建一个 HTML 文件（例如，命名为 index.html）。
在视图函数中渲染模板： 使用 Flask 提供的 render_template 函数来加载并渲染模板文件。

修改 app.py：

“`python

app.py

导入 render_template 函数

from flask import Flask, request, render_template

app = Flask(name)

… 其他路由 …

新增一个使用模板的路由

@app.route(‘/hello/’) # 注意这里的斜杠是可选的，’/hello’ 和 ‘/hello/’ 都可以访问
@app.route(‘/hello/‘)
def hello(name=None): # 这里的 name 参数有默认值 None，以处理 /hello/ 的情况
# 使用 render_template 渲染 index.html 模板，并将 name 变量传递给模板
return render_template(‘index.html’, name=name)

修改 login 路由以使用模板 (可选，为了展示模板的使用)

首先创建一个 templates/login.html 文件

然后修改 login 函数:

@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 == ‘password’:
# 成功后返回一个简单的页面或重定向
return ‘登录成功！’ # 为了简单，这里仍然返回字符串
else:
# 失败时重新渲染登录模板，并传递错误信息
error = ‘用户名或密码错误！’
return render_template(‘login.html’, error=error)
else:
# GET 请求时渲染登录模板，不传递错误信息
return render_template(‘login.html’, error=None)

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

创建 templates/index.html 文件：

“`html

你好页面

{% if name %}

你好, {{ name }}!

{% else %}

你好, 世界!

{% endif %}

“`

创建 templates/login.html 文件：

“`html

登录页面

用户登录

{% if error %}

{% endif %}

“`

保存所有文件。访问 http://127.0.0.1:5000/hello/ 和 http://127.0.0.1:5000/hello/Alice。你会看到页面内容根据传递的 name 变量而变化。访问 http://127.0.0.1:5000/login 尝试登录。

Jinja2 模板语法：

Jinja2 模板文件包含了普通的 HTML 代码，以及特殊的 Jinja2 标记：

{{ variable }}: 用于输出变量的值。Flask 视图函数通过 render_template() 的关键字参数将变量传递给模板，例如 render_template('index.html', name=name) 使得模板中可以使用 {{ name }}。
{% ... %}: 用于执行控制结构，如 if 语句、for 循环等。
{# ... #}: 用于添加注释。

Jinja2 会自动对输出的变量进行HTML 转义（escaping），这可以有效防止跨站脚本攻击（XSS）。如果你确定某些内容是安全的 HTML，并且不想被转义，可以使用 {{ variable | safe }}，但这需要谨慎使用。

10. 使用静态文件：CSS, JavaScript 和图片

Web 应用通常需要使用 CSS 文件来设置样式，JavaScript 文件来添加交互，以及图片等资源。这些文件被称为静态文件（Static Files）。

Flask 默认配置了一个特殊的路由来处理静态文件。你只需要在与 app.py 文件相同的目录下创建一个名为 static 的文件夹，并将你的静态文件放在里面。

步骤：

创建 static 文件夹： 在与 app.py 文件相同的目录下，创建一个名为 static 的新文件夹。
创建子文件夹（可选，但推荐）： 在 static 文件夹内创建 css、js、images 等子文件夹来组织文件。
添加静态文件： 在 static/css/ 文件夹中创建一个名为 style.css 的文件。
在模板中链接静态文件： 使用 Flask 提供的 url_for() 函数来生成静态文件的 URL。

创建 static/css/style.css 文件：

“`css
/ static/css/style.css /
body {
font-family: sans-serif;
background-color: #f4f4f4;
color: #333;
margin: 20px;
}

h1 {
color: #0056b3;
}

p {
line-height: 1.6;
}
“`

修改 templates/index.html，添加 CSS 链接：

“`html

你好页面

{% if name %}

你好, {{ name }}!

{% else %}

你好, 世界!

{% endif %}

这是一个使用静态 CSS 文件设置样式的示例。

“`

保存文件。访问 http://127.0.0.1:5000/hello/。你会看到页面现在应用了 style.css 中定义的样式。

url_for() 函数：

url_for() 是一个非常有用的函数，用于为指定的函数构建 URL。

url_for('hello_world') 会生成 /。
url_for('show_user_profile', username='peter') 会生成 /user/peter。
url_for('static', filename='css/style.css') 会生成 /static/css/style.css。

使用 url_for() 来生成 URL 的好处是，即使你将来修改了路由规则（例如将 /about 改为 /about-us），只要你在 url_for() 中引用的是视图函数的名称（about），Flask 就会自动生成正确的 URL，而无需手动修改模板中的链接。对于静态文件，引用路由名称 static 和文件路径即可。

11. 项目结构组织

对于简单的单文件应用，将所有代码放在 app.py 中是可以的。但随着应用的增长，为了保持代码的组织性和可维护性，最好将应用拆分成多个文件和目录。

一个简单的项目结构可以如下：

myproject/ ├── venv/ # 虚拟环境 (隐藏) ├── app.py # 入口文件，创建 Flask 应用实例 ├── views.py # 存放视图函数 (路由处理逻辑) ├── templates/ # 存放 HTML 模板 │ ├── index.html │ ├── login.html │ └── ... ├── static/ # 存放静态文件 │ ├── css/ │ │ └── style.css │ ├── js/ │ └── images/ └── requirements.txt # 记录项目依赖库

在这种结构中：

app.py 只负责创建 Flask 应用实例和配置（本例中配置很简单）。
views.py 包含了所有的 @app.route() 装饰器和视图函数。
templates/ 和 static/ 保持不变。

为了实现这种结构，我们需要对 app.py 和 views.py 进行修改。

首先，创建 views.py 文件，并将所有视图函数和它们的路由装饰器移动到这里：

“`python

views.py

from flask import render_template, request # 导入所需的函数和对象

导入在 app.py 中创建的 app 实例

from app import app # <— 假设 app 实例在 app.py 中被创建并暴露

将所有路由和视图函数移动到这里

@app.route(‘/’)
def hello_world():
return ‘Hello, World!’

@app.route(‘/about’)
def about():
return ‘这是关于我们页面！’

@app.route(‘/user/‘)
def show_user_profile(username):
return f’用户: {username}’

@app.route(‘/post/‘)
def show_post(post_id):
return f’文章 ID: {post_id}’

@app.route(‘/hello/’)
@app.route(‘/hello/‘)
def hello(name=None):
return render_template(‘index.html’, name=name)

@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 == ‘password’:
return ‘登录成功！’
else:
error = ‘用户名或密码错误！’
return render_template(‘login.html’, error=error)
else:
return render_template(‘login.html’, error=None)

注意：这里没有 if name == ‘main‘: 和 app.run()

“`

然后，修改 app.py 文件，使其创建应用实例，并导入 views 模块以注册路由：

“`python

app.py

from flask import Flask

app = Flask(name)

导入 views 模块，这将执行 views.py 中的代码，包括 @app.route 装饰器

从而将路由注册到 app 实例上

import views # <— 导入 views.py

可选：在这里进行配置

app.config[‘SECRET_KEY’] = ‘your-secret-key’

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

现在，运行 python app.py 仍然可以启动应用，所有路由也都能正常工作。这种结构使得 app.py 保持精简，而路由逻辑则集中在 views.py 中，更易于管理。

对于更复杂的应用，你可能还会进一步拆分视图函数到不同的模块（例如 user_views.py, post_views.py），并使用 Flask 的蓝图（Blueprints）功能来组织路由，但这超出了快速入门的范围。

最后，记录项目依赖是一个好习惯。在项目目录下运行：

bash pip freeze > requirements.txt

这将把当前虚拟环境中安装的所有库及其版本写入 requirements.txt 文件。这样，当你将项目分享给他人或部署到新环境时，他们只需创建虚拟环境并运行 pip install -r requirements.txt 即可安装所有必需的依赖。

12. 调试技巧

在开发过程中，难免会遇到错误。Flask 提供了一些调试工具：

debug=True: 如前所述，这是最重要的开发工具。它提供了交互式调试器和自动重载。当出现未捕获的异常时，浏览器会显示一个详细的页面，你可以检查变量、执行代码等。永远记住在生产环境中关闭它。
日志记录: 使用 Python 标准库的 logging 模块可以在代码中记录信息，帮助追踪程序的执行流程和变量状态。
python import logging # 配置日志 (通常在 app.py 或配置模块中) logging.basicConfig(level=logging.DEBUG) # 在视图函数中使用日志 logging.debug(f'User {username} attempted to log in.')
集成开发环境 (IDE): 使用 PyCharm, VS Code 等现代 IDE，你可以设置断点并单步调试你的 Flask 应用，这是定位复杂问题的强大方法。

13. 接下来去哪里？

本教程涵盖了 Flask 的基础知识，足以让你构建一个简单的 Web 应用。但 Flask 的能力远不止于此。要继续深入学习，你可以探索以下主题：

Flask Extensions: 学习如何使用流行的 Flask 扩展来添加数据库支持 (Flask-SQLAlchemy)、用户认证 (Flask-Login)、表单处理 (Flask-WTF)、迁移数据库 (Flask-Migrate) 等。
数据库: 学习如何将你的 Flask 应用与数据库集成，存储和检索数据。SQLAlchemy 是 Python 中常用的 ORM (对象关系映射) 工具，与 Flask-SQLAlchemy 配合使用非常方便。
蓝图 (Blueprints): 学习如何使用蓝图来组织大型应用的路由和资源，实现模块化。
应用上下文和请求上下文: 理解 Flask 的上下文机制，这对理解一些高级特性和扩展至关重要。
错误处理: 学习如何自定义错误页面（如 404 Not Found, 500 Internal Server Error）。
重定向和消息闪现 (Flashing): 学习如何使用 redirect() 进行页面跳转，以及如何使用 flash() 在不同请求之间传递一次性消息（例如，“登录成功”）。
Cookies 和 Sessions: 学习如何使用 Cookies 和 Sessions 来存储用户状态信息。
测试: 学习如何为你的 Flask 应用编写自动化测试。
部署: 学习如何将你的 Flask 应用部署到生产服务器上，通常会使用 WSGI 服务器 (如 Gunicorn, uWSGI) 和 Web 服务器 (如 Nginx, Apache)。
构建 RESTful API: Flask 也是构建 API 的优秀选择，可以结合 Flask-RESTful 或 Flask-RESTPlus (现名 Flask-RESTX) 等扩展。

总结

在本快速入门教程中，你学习了：

Flask 的基本概念和优势。
如何安装 Flask 并设置虚拟环境。
如何创建并运行你的第一个“Hello, World!” Flask 应用。
如何定义路由和视图函数。
如何使用动态路由和变量规则。
如何处理不同的 HTTP 方法 (GET 和 POST)。
如何使用 Jinja2 模板引擎分离 Python 代码和 HTML 结构。
如何处理静态文件 (CSS, JS, 图片)。
一个基本的 Flask 项目结构组织方式。
一些基本的调试技巧。

你现在已经具备了构建简单 Web 应用所需的基础知识。继续实践，尝试将所学应用到自己的小项目中，并探索 Flask 丰富的生态系统，你的 Web 开发之旅将会越来越精彩！

希望这篇详细教程对你有所帮助。祝你在 Flask 的世界中编程愉快！

Python Flask 快速入门教程：构建你的第一个 Web 应用

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

2. 准备工作：安装 Python 和创建虚拟环境

或者

3. 安装 Flask

4. 你的第一个 Flask 应用：“Hello, World!”

app.py

1. 从 flask 模块导入 Flask 类

2. 创建 Flask 应用实例

name 是当前模块的名称，Flask 用它来确定应用程序的根目录

3. 定义路由和视图函数

@app.route(‘/’) 是一个装饰器，它将 URL “/” 映射到 hello_world 函数

4. 运行应用

确保这个文件是作为主程序运行时才执行 app.run()

5. 解释第一个应用的代码

6. 添加更多路由和页面

app.py

新增路由 /about

7. 动态路由：使用变量规则

app.py

新增动态路由 /user/

动态路由，使用类型转换器

8. HTTP 方法：GET 和 POST

app.py

… 其他路由（hello_world, about, show_user_profile, show_post） …

新增一个处理登录的路由，允许 GET 和 POST 方法

9. 使用模板：分离逻辑与表现

app.py

导入 render_template 函数

… 其他路由 …

新增一个使用模板的路由

修改 login 路由以使用模板 (可选，为了展示模板的使用)

首先创建一个 templates/login.html 文件

然后修改 login 函数:

你好, {{ name }}!

你好, 世界!

用户登录

10. 使用静态文件：CSS, JavaScript 和图片

你好, {{ name }}!

你好, 世界!

11. 项目结构组织

views.py

导入在 app.py 中创建的 app 实例

将所有路由和视图函数移动到这里

注意：这里没有 if name == ‘main‘: 和 app.run()

app.py

导入 views 模块，这将执行 views.py 中的代码，包括 @app.route 装饰器

从而将路由注册到 app 实例上

可选：在这里进行配置

app.config[‘SECRET_KEY’] = ‘your-secret-key’

12. 调试技巧

13. 接下来去哪里？

总结

发表评论 取消回复

发表评论取消回复