Python学习4

一、Flask是什么，为什么选择它¶

Flask 是基于 Python 的轻量级 Web 应用框架，诞生于 2010 年，其核心依赖 Werkzeug WSGI 工具包和 Jinja2 模板引擎。它就像是一个小巧灵活的工具箱，仅提供了 Web 开发所需的核心功能，如简单的路由系统、请求处理和模板渲染等。这种轻量级的设计使得 Flask 非常适合快速搭建小型 Web 应用或进行项目原型开发。
与其他 Python Web 框架相比，Flask 的独特魅力在于它的轻量与灵活。
而 Flask 则截然不同，它没有过多的内置功能和强制的项目结构，开发者可以根据项目的具体需求自由选择和集成各种扩展和工具。

二、环境搭建¶

2.1 安装 Python¶

从 Python 官方网站（https://www.python.org/downloads/windows/ ）下载适合你系统的 Python 安装包（例如，Windows x86-64 executable installer 对于 64 位系统）。下载完成后，双击运行安装程序，在安装过程中，务必勾选 “Add Python to PATH” 选项，这样才能在命令行中直接运行 Python。安装完成后，按下 Win+R 键，打开运行窗口，输入 “cmd” 打开命令行界面，输入 “python -V”（注意有空格），如果看到版本号显示出来（如 Python 3.10.0），则说明 Python 已经成功安装。

2.2 创建虚拟环境¶

虚拟环境是一种工具，它允许你为不同的项目创建隔离的 Python 运行环境，这样可以避免不同项目之间的依赖包冲突。

1.进入anaconda根目录，打开命令行工具
2.创建虚拟环境，名叫myenvs：conda create -n myenvs python=3.13
3.激活环境：conda activate myenvs

2.3 安装 Flask¶

激活虚拟环境后，就可以使用 Python 的包管理器pip来安装 Flask 了。在命令行中输入以下命令：

pip install Flask

安装完成后，可以通过以下命令验证 Flask 是否安装成功：

pip show Flask

如果安装成功，会显示 Flask 的相关信息，包括名称、版本、摘要、主页、作者、作者邮箱、许可证、安装位置以及依赖项等

三、深入理解 Flask 核心概念¶

3.1 应用对象¶

在 Flask 中，Flask类的实例就是我们的应用对象，它代表整个 Web 应用。应用对象是 Flask 应用的入口点，所有的请求都会通过它来进行分发和处理。它还提供了一系列方法和属性，方便我们对应用进行定制和扩展。

3.2 路由系统¶

路由系统是 Flask 的核心功能之一，它负责将不同的 URL 映射到对应的视图函数上，使得应用能够根据用户请求的 URL 来执行相应的代码逻辑。

在 Flask 中，使用@app.route装饰器来定义路由，除了静态路由，Flask 还支持动态路由，即 URL 中可以包含参数。动态路由的参数使用<参数名>的形式定义，视图函数中可以接收这些参数。

Flask 支持的动态路由参数类型除了int（整数），还有string（字符串，默认类型，可不写类型声明）、float（浮点数）、path（路径，可包含斜杠）等

3.3 请求与响应¶

在 Web 开发中，请求与响应是客户端（通常是浏览器）和服务器之间交互的基本方式。当用户在浏览器中输入 URL 并访问时，浏览器会向服务器发送一个 HTTP 请求，服务器接收到请求后进行处理，然后返回一个 HTTP 响应给浏览器。

在 Flask 中，处理请求和返回响应是通过视图函数来完成的。Flask 会自动将客户端发送的请求信息封装成request对象，视图函数可以通过这个对象获取请求的各种信息，如请求方法（GET、POST 等）、请求参数、请求头、请求体等。

四、模板引擎¶

在 Web 开发中，我们常常需要根据不同的用户请求或数据生成动态的 HTML 页面，这就离不开模板引擎的帮助。Flask 默认使用 Jinja2 作为模板引擎，它功能强大且灵活，能够很好地满足 Web 开发中动态页面生成的需求

4.1 Jinja2 模板引擎¶

Jinja2 是一个用 Python 编写的模板引擎，它的设计思想借鉴了 Django 的模板引擎，并在此基础上进行了扩展，提供了更加丰富和强大的功能。Jinja2 的主要特点包括：

简洁的语法：采用类似于 Python 的语法，易于学习和使用
强大的控制结构：支持完整的 Python 控制结构，如条件语句（if-else）、循环语句（for、while）等，使得在模板中可以进行复杂的逻辑处理
丰富的过滤器：过滤器用于在渲染变量之前对其进行处理和转换，Jinja2 内置了大量常用的过滤器，如capitalize（将字符串首字母大写）、lower（将字符串转换为小写）、upper（将字符串转换为大写）、trim（去除字符串两端的空白字符）、join（将列表元素连接成字符串）、format（格式化字符串）等
模板继承：允许创建一个基础模板，然后其他模板可以继承这个基础模板，并根据需要覆盖其中的部分内容。这在创建具有统一布局和风格的 Web 应用时非常有用，可以大大减少重复代码
宏定义：类似于 Python 中的函数，宏允许在模板中定义可重用的代码块，通过传递不同的参数来实现不同的功能

4.2 在 Flask 中使用 Jinja2 模板¶

在 Flask 中使用 Jinja2 模板非常简单，Flask 提供了render_template函数来渲染模板。

假设我们要创建一个简单的博客应用，展示文章列表。首先，在项目目录下创建一个templates文件夹（Flask 会自动从这个文件夹中查找模板文件），然后在其中创建一个index.html模板文件，内容如下：

In [ ]:

<!DOCTYPEhtml>

<html lang="en">

<head>

<meta charset="UTF-8">

<title>My Blog</title>

</head>

<body>

<h1>My Blog</h1>

<ul>

{% for post in posts %}

<li>

<a href="{{ post.url }}">{{ post.title }}</a> - {{ post.author }} - {{ post.published_date }}

</li>

{% endfor %}

</ul>

</body>

</html>

在上述模板中，{{ post.title }}、{{ post.author }}、{{ post.published_date }}等是变量占位符，它们将在渲染时被实际的数据替换；{% for post in posts %}和{% endfor %}是循环控制结构，用于遍历posts列表并为每个文章项生成一个< li>元素

接下来，在 Flask 应用中，我们需要准备数据并调用render_template函数来渲染这个模板。在app.py中添加如下代码:

In [ ]:

fromflaskimport Flask, render_template

app = Flask(__name__)

# 模拟文章数据

posts = [

{

'title': 'First Post',

'author': 'John',

'published_date': '2024-10-01',

'url': '/posts/1'

},

{

'title': 'Second Post',

'author': 'Jane',

'published_date': '2024-10-02',

'url': '/posts/2'

}

]

@app.route('/')

defindex():

return render_template('index.html', posts=posts)

if __name__ == '__main__':

app.run(debug=True)

在index视图函数中，我们将posts列表作为参数传递给render_template函数，这样在index.html模板中就可以使用posts变量了。运行 Flask 应用后，访问 http://127.0.0.1:5000/ ，就可以看到渲染后的页面，其中展示了文章列表

4.3 模板继承与宏¶

模板继承是 Jinja2 的一个重要特性，它允许我们创建一个基础模板（通常包含网站的通用结构，如页眉、页脚、导航栏等），然后其他模板可以继承这个基础模板，并覆盖其中的特定块，从而实现代码的复用和页面结构的统一。

例如，创建一个基础模板base.html：

In [ ]:

<!DOCTYPEhtml>

<html lang="en">

<head>

<meta charset="UTF-8">

<title>{% block title %}My Site{% endblock %}</title>

</head>

<body>

<header>

<h1>My Awesome Site</h1>

<nav>

<a href="/">Home</a> | <a href="/about">About</a>

</nav>

</header>

<main>

{% block content %}{% endblock %}

</main>

<footer>

<p>&copy; 2024 My Company</p>

</footer>

</body>

</html>

在这个基础模板中，{% block title %}{% endblock %}和{% block content %}{% endblock %}定义了两个可替换的块，子模板可以根据需要覆盖这些块的内容。

然后，创建一个继承自base.html的子模板index.html：

In [ ]:

{% extends "base.html" %}

{% block title %}Home Page{% endblock %}

{% block content %}

<h2>Welcome to my home page</h2>

<p>This is the content of the home page.</p>

{% endblock %}

在index.html中，{% extends "base.html" %}表示继承base.html模板，{% block title %}和{% block content %}分别覆盖了base.html中相应块的内容。

宏则是 Jinja2 中可重用的模板代码块，类似于函数

在templates文件夹中创建一个macros.html文件，定义一个用于渲染表单输入框的宏：

In [ ]:

{% macro render_input(name, type='text', value='') %}

<input type="{{ type }}" name="{{ name }}" value="{{ value }}">

{% endmacro %}

在其他模板中，可以通过{% from "macros.html" import render_input %}导入这个宏，然后使用{{ render_input('username') }}这样的方式来调用宏，传入不同的参数来生成不同的表单输入框

五、表单处理¶

在 Web 应用中，表单是实现用户与服务器交互的重要方式，用户可以通过表单输入数据，如注册信息、登录凭证、搜索关键词等，然后将这些数据提交给服务器进行处理。Flask 提供了基本的表单处理功能，结合一些扩展库（如 Flask - WTF），可以更方便地实现表单验证、数据获取等操作

5.1 创建 HTML 表单¶

首先，我们需要在 HTML 中创建表单。表单的method属性通常设置为POST（也可以是GET，但POST更安全，适合提交敏感数据或大数据量的表单），action属性指定表单数据提交的目标 URL，通常是 Flask 应用中的某个路由

例如，创建一个简单的登录表单login.html：

In [ ]:

<!DOCTYPEhtml>

<html lang="en">

<head>

<meta charset="UTF-8">

<title>Login</title>

</head>

<body>

<h1>Login</h1>

<form action="{{ url_for('login') }}" method="post">

<label for="username">Username:</label>

<input type="text" id="username" name="username" required><br>

<label for="password">Password:</label>

<input type="password" id="password" name="password" required><br>

<input type="submit" value="Login">

</form>

</body>

</html>

在这个表单中，action="{{ url_for('login') }}"表示表单数据将提交到名为login的 Flask 路由；method="post"指定使用 POST 方法提交表单；required属性是 HTML5 的验证属性，确保用户在提交表单时必须填写这两个字段，否则浏览器会弹出提示框阻止表单提交

5.2 处理表单数据¶

在 Flask 应用中，需要定义一个路由来接收表单数据，并在相应的视图函数中处理这些数据。通过request对象的form属性可以获取 POST 请求中的表单数据

在app.py中添加如下代码:

In [ ]:

fromflaskimport Flask, render_template, request, redirect, url_for

app = Flask(__name__)

@app.route('/login', methods=['GET', 'POST'])

deflogin():

if request.method == 'POST':

username = request.form.get('username')

password = request.form.get('password')

# 这里可以进行用户认证等处理，例如检查用户名和密码是否匹配

if username == 'admin' and password == '123456':

return redirect(url_for('dashboard'))

else:

return 'Login failed. Please check your username and password.'

return render_template('login.html')

@app.route('/dashboard')

defdashboard():

return 'Welcome to the dashboard, admin!'

if __name__ == '__main__':

app.run(debug=True)

在login视图函数中，首先判断请求方法是否为 POST，如果是，则从request.form中获取username和password字段的值。然后进行简单的用户认证，若认证成功，使用redirect函数重定向到dashboard路由；若认证失败，返回错误提示信息。如果请求方法是 GET，则直接渲染login.html模板，显示登录表单

5.3 表单验证¶

表单验证是确保用户输入数据有效性的重要环节，可以防止非法数据进入系统，提高系统的安全性和稳定性。虽然 Flask 本身不提供强大的表单验证功能，但结合 WTForms 库（通常通过 Flask - WTF 扩展使用），可以很方便地实现表单验证

安装 Flask - WTF 扩展：

In [ ]:

pip install flask-wtf

在app.py中定义一个表单类，并使用验证器来验证表单字段:

In [ ]:

fromflaskimport Flask, render_template, request, redirect, url_for

fromflask_wtfimport FlaskForm

fromwtformsimport StringField, PasswordField, SubmitField

fromwtforms.validatorsimport DataRequired, Length

app = Flask(__name__)

app.secret_key = 'your_secret_key' # 用于CSRF保护，必须设置

classLoginForm(FlaskForm):

username = StringField('Username', validators=[DataRequired(), Length(min=3, max=20)])

password = PasswordField('Password', validators=[DataRequired(), Length(min=6, max=50)])

submit = SubmitField('Login')

@app.route('/login', methods=['GET', 'POST'])

deflogin():

form = LoginForm()

if form.validate_on_submit():

username = form.username.data

password = form.password.data

# 进行用户认证等处理

if username == 'admin' and password == '123456':

return redirect(url_for('dashboard'))

else:

return 'Login failed. Please check your username and password.'

return render_template('login.html', form=form)

@app.route('/dashboard')

defdashboard():

return 'Welcome to the dashboard, admin!'

if __name__ == '__main__':

app.run(debug=True)

在上述代码中，LoginForm类继承自FlaskForm，定义了username、password和submit三个字段。DataRequired验证器确保字段不为空，Length验证器限制了字段的长度范围。在login视图函数中，使用form.validate_on_submit()方法来验证表单数据，如果验证通过，则进行后续处理；如果验证失败，form对象会包含错误信息，这些错误信息可以在模板中显示给用户

在login.html模板中，可以通过form.errors来显示错误信息

In [ ]:

<!DOCTYPEhtml>

<html lang="en">

<head>

<meta charset="UTF-8">

<title>Login</title>

</head>

<body>

<h1>Login</h1>

<form method="post">

{{ form.hidden_tag() }}

<div>

{{ form.username.label }}: {{ form.username() }}

{% if form.username.errors %}

<ul>

{% for error in form.username.errors %}

<li>{{ error }}</li>

{% endfor %}

</ul>

{% endif %}

</div>

<div>

{{ form.password.label }}: {{ form.password() }}

{% if form.password.errors %}

<ul>

{% for error in form.password.errors %}

<li>{{ error }}</li>

{% endfor %}

</ul>

{% endif %}

</div>

{{ form.submit() }}

</form>

</body>

</html>

{{ form.hidden_tag() }}用于生成一个隐藏的 CSRF 令牌，防止跨站请求伪造攻击。当表单验证失败时，会在相应字段下方显示错误信息，帮助用户了解输入错误并进行修正

六、数据库操作：持久化数据¶

在实际的 Web 应用中，数据的持久化存储是至关重要的，数据库就是实现这一功能的关键工具。Flask 本身并没有内置的数据库处理模块，但它提供了很好的扩展性，我们可以通过使用各种数据库扩展来实现与不同类型数据库的交互，其中 SQLAlchemy 是一个非常流行且强大的选择

6.1 SQLAlchemy 简介¶

SQLAlchemy 是 Python 的一个数据库抽象层库，它提供了一套丰富的工具和 API，让开发者可以使用 Python 代码与各种关系型数据库（如 MySQL、PostgreSQL、SQLite 等）进行交互，而无需直接编写 SQL 语句，这种方式被称为对象关系映射（ORM）。ORM 的核心思想是将数据库中的表映射为 Python 中的类，表中的行映射为类的实例，表中的列映射为类的属性，这样我们就可以通过操作 Python 对象来实现对数据库的增删改查等操作，大大提高了开发效率和代码的可维护性

6.2 使用 SQLAlchemy 连接数据库¶

需要安装flask_sqlalchemy扩展：

In [ ]:

pip install flask_sqlalchemy

安装完成后，在 Flask 应用中进行配置。假设我们使用MySQL数据库，在app.py中添加如下代码：

In [ ]:

fromflaskimport Flask

fromflask_sqlalchemyimport SQLAlchemy

app = Flask(__name__)

# 配置数据库连接，这里使用MySQL数据库的用户名是root，密码是123456，主机是localhost，端口是3306，数据库名为mydb

app.config['SQLALCHEMY_DATABASE_URI'] ='mysql://root:123456@localhost:3306/mydb'

# 关闭对模型修改的监控，以减少不必要的开销，因为这个功能会消耗额外的内存和性能，在生产环境中如果不需要实时追踪模型的修改情况，可以将其关闭 

app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

# 创建SQLAlchemy实例，这个实例将用于定义数据库模型和执行数据库操作

db = SQLAlchemy(app)

这里需要注意，连接 MySQL 数据库还需要安装 MySQL 的 Python 驱动，如mysqlclient或pymysql，可以使用pip install mysqlclient或pip install pymysql进行安装

6.3 定义数据库模型¶

数据库模型是数据库表在 Python 中的映射，通过定义模型类，我们可以方便地操作数据库表。模型类需要继承自db.Model，其中的属性对应数据库表中的列

例如，我们要创建一个用户表User，包含id（主键，自增长）、username（用户名，字符串类型，唯一且不能为空）、email（邮箱，字符串类型，唯一且不能为空）字段，在app.py中添加如下代码：

In [ ]:

classUser(db.Model):

__tablename__ = 'user' # 定义表名，若不指定，默认使用类名的小写形式作为表名

id = db.Column(db.Integer, primary_key=True, autoincrement=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}>'

__tablename__指定了数据库表名，如果不设置，SQLAlchemy 会自动将类名的小写形式作为表名
db.Column用于定义表中的列，第一个参数指定列的数据类型，如db.Integer表示整数类型，db.String(80)表示最大长度为 80 的字符串类型；后面的参数primary_key=True表示该列是主键，autoincrement=True表示主键自增长，unique=True表示该列的值必须唯一，nullable=False表示该列不能为空
__repr__方法是一个特殊的方法，用于定义对象的字符串表示形式，方便在调试和打印对象时查看对象的信息

6.4 基本数据库操作¶

定义好数据库模型后，就可以进行基本的数据库操作了，如创建表、添加数据、查询数据、更新数据和删除数据，这些操作通常被称为 CRUD（Create, Read, Update, Delete）操作

七、项目结构优化¶

7.1 中型项目结构示例¶

这种中型项目结构将不同功能的代码分离到不同的文件和模块中，使得代码结构更加清晰，易于维护和扩展

my_flask_app/ │ ├── app/ │ ├── __init__.py │ ├── routes.py │ └── models.py │ ├── config.py ├── requirements.txt └── run.py

app/目录：是 Flask 应用的核心代码目录，包含了应用的主要逻辑
__ init__.py：用于初始化 Flask 应用，通常会创建 Flask 应用实例，并配置一些扩展（如 SQLAlchemy 等），还可以导入和注册蓝图
routes.py：专门用于定义应用的路由和视图函数，将不同功能的路由集中管理，提高代码的可读性和可维护性

使用Blueprint创建了一个名为main的蓝图，定义了根路由和/about路由及其对应的视图函数

In [ ]:

fromflaskimport Blueprint

bp = Blueprint('main', __name__)

@bp.route('/')

defhome():

return 'This is the home page'

@bp.route('/about')

defabout():

return 'This is the about page

然后在__init__.py中注册这个蓝图:

In [ ]:

fromflaskimport Flask

from.routesimport bp

app = Flask(__name__)

app.register_blueprint(bp)

models.py：用于定义应用的数据模型，与数据库相关的操作都可以在这里进行定义。例如，如果使用 SQLAlchemy，会在这里定义数据库表对应的模型类。例如：

In [ ]:

fromappimport db

classUser(db.Model):

__tablename__ = 'user'

id = db.Column(db.Integer, primary_key=True, autoincrement=True)

username = db.Column(db.String(80), unique=True, nullable=False)

email = db.Column(db.String(120), unique=True, nullable=False)

config.py文件：用于存放应用的配置信息，如数据库连接字符串、密钥、调试模式开关等。例如:

In [ ]:

classConfig:

SECRET_KEY = 'your_secret_key'

SQLALCHEMY_DATABASE_URI ='sqlite:///test.db'

SQLALCHEMY_TRACK_MODIFICATIONS = False

requirements.txt文件：与简单项目结构中的作用相同，记录项目的依赖库及其版本，方便在新环境中安装依赖

run.py文件：是项目的启动文件，通过运行这个文件来启动 Flask 应用。内容如下:

In [ ]:

fromappimport create_app

app = create_app()

if __name__ == '__main__':

app.run(debug=True)

7.2 大型项目结构设计¶

这种大型项目结构设计，可以将复杂的应用分解为多个相对独立的模块，每个模块负责特定的功能，模块之间通过清晰的接口进行交互。这不仅有利于团队成员分工协作开发，还能提高代码的可维护性、可扩展性和可测试性

my_flask_app/ │ ├── app/ │ ├── __init__.py │ ├── routes/ │ │ ├── __init__.py │ │ ├── main.py │ │ └── auth.py │ ├── models/ │ │ ├── __init__.py │ │ └── user.py │ ├── services/ │ │ ├── __init__.py │ │ └── user_service.py │ ├── templates/ │ │ ├── layout.html │ │ ├── home/ │ │ │ └── index.html │ │ └── auth/ │ │ └── login.html │ └── static/ │ ├── css/ │ └── js/ │ ├── config/ │ ├── __init__.py │ └── settings.py │ ├── migrations/ │ └── ... │ ├── tests/ │ ├── __init__.py │ ├── test_routes.py │ └── test_models.py │ ├── requirements.txt └── run.py

app/目录：依然是应用的核心代码目录，但进一步细化了模块结构

__ init__.py：除了初始化 Flask 应用和注册蓝图外，还可以进行一些全局的设置和初始化操作

routes/目录：将不同功能模块的路由进一步分开管理，例如main.py中存放主业务模块的路由，auth.py中存放认证相关的路由。以auth.py为例:

In [ ]:

fromflaskimport Blueprint, render_template, request, redirect, url_for

bp = Blueprint('auth', __name__)

@bp.route('/login', methods=['GET', 'POST'])

deflogin():

if request.method == 'POST':

# 处理登录逻辑

return redirect(url_for('main.dashboard'))

return render_template('auth/login.html')

models/目录：存放各种数据模型类，每个模型类可以放在单独的文件中，如user.py中定义用户模型。
services/目录：用于存放业务逻辑相关的代码，将业务逻辑从路由和模型中分离出来，提高代码的复用性和可维护性。例如:user_service.py中可以定义与用户相关的业务逻辑方法，如用户注册、登录验证等。
templates/目录：存放 HTML 模板文件，按照功能模块进一步细分目录，如home/目录下存放主页相关的模板，auth/目录下存放认证相关的模板。
static/目录：存放静态文件，如 CSS 样式表、JavaScript 脚本文件等。
config/目录：专门用于存放配置文件，settings.py中可以定义各种配置类，如开发环境配置、生产环境配置等，通过在__ init__.py中进行导入和选择，方便在不同环境下切换配置。
migrations/目录：存放数据库迁移文件，用于管理数据库结构的版本控制，当数据模型发生变化时，可以通过数据库迁移工具（如 Flask - Migrate）生成迁移脚本，更新数据库结构。
tests/目录：存放测试代码，对应用的各个模块进行单元测试和集成测试，确保代码的正确性和稳定性。例如，test_routes.py中可以测试路由的功能是否正常，test_models.py中可以测试数据模型的方法和行为是否符合预期。
requirements.txt文件：和前面的项目结构一样，记录项目依赖库。
run.py文件：启动 Flask 应用

posted @ 2026-01-18 20:45 望极春愁阅读(0) 评论(0) 收藏举报

刷新页面返回顶部

lzjhuiyi

Python学习4

一、Flask是什么，为什么选择它¶

二、环境搭建¶

2.1 安装 Python¶

2.2 创建虚拟环境¶

2.3 安装 Flask¶

三、深入理解 Flask 核心概念¶

3.1 应用对象¶

3.2 路由系统¶

3.3 请求与响应¶

四、模板引擎¶

4.1 Jinja2 模板引擎¶

4.2 在 Flask 中使用 Jinja2 模板¶

4.3 模板继承与宏¶

五、表单处理¶

5.1 创建 HTML 表单¶

5.2 处理表单数据¶

5.3 表单验证¶

六、数据库操作：持久化数据¶

6.1 SQLAlchemy 简介¶

6.2 使用 SQLAlchemy 连接数据库¶

6.3 定义数据库模型¶

6.4 基本数据库操作¶

七、项目结构优化¶

7.1 中型项目结构示例¶

7.2 大型项目结构设计¶

公告