Python Flask est un framework d'application Web léger écrit en Python pour le développement rapide d'applications Web et d'API. Il est conçu dans un souci de simplicité, de facilité d’utilisation et d’évolutivité.
Voici quelques-unes des principales fonctionnalités de Python Flask :
Léger : Flask n'a pas de bibliothèques ni de boîtes à outils redondantes, ce qui le rend très léger, ce qui signifie également que vous pouvez ajouter vos propres bibliothèques selon vos besoins.
Facilité d'utilisation : l'API de Flask est très simple et facile à comprendre et à apprendre, elle est donc très adaptée aux débutants.
Extensibilité : Flask est extensible, vous pouvez ajouter des plugins pour améliorer ses fonctionnalités et il peut être facilement intégré à d'autres bibliothèques et frameworks.
Flexibilité : Flask vous permet de choisir les composants dont vous avez besoin, tels que le moteur de modèles, la base de données, la validation de formulaire et plus encore.
Haute intégration : Flask prend en charge l'intégration avec d'autres bibliothèques et frameworks Python, tels que SQLAlchemy, WTForms, Jinja2, etc.
Prise en charge RESTful : Flask est une API RESTful facile à utiliser et peut facilement créer des services Web RESTful.
En bref, Python Flask est un framework Web puissant, facile à utiliser, évolutif et flexible, largement utilisé dans le développement d'applications Web et d'API.
Flask est un framework d'application Web écrit en Python. Il utilise la boîte à outils Werkzeug et le moteur de modèles Jinja2.
Le framework Flask est principalement composé des modules suivants :
Module d'application : Le module principal de Flask est l'entrée de l'ensemble de l'application Web et est responsable de la réception des requêtes HTTP et du renvoi des réponses. Il est également responsable du routage, de la gestion des erreurs, du contexte et d'autres fonctions.
Module de routage : Flask utilise des décorateurs pour définir la relation de mappage entre les routes d'URL et les fonctions d'affichage.
Module View : La fonction d'affichage est le cœur de l'application Web Flask. Elle gère les requêtes HTTP et renvoie des réponses, qui peuvent renvoyer des pages HTML, des données JSON, etc.
Module Modèle : Flask utilise le moteur de modèles Jinja2 pour générer des pages HTML. Le moteur de modèles fournit une syntaxe riche et des filtres pour générer facilement des pages HTML complexes.
Module de base de données : Flask peut être facilement intégré à une variété de bases de données, notamment MySQL, PostgreSQL, SQLite, etc.
Module de formulaire : Flask-WTF est une extension de traitement de formulaire pour Flask, qui fournit des méthodes de traitement de formulaire pratiques pour créer facilement des formulaires, valider les données du formulaire, etc.
Module d'extension : le module d'extension de Flask fournit diverses fonctions, telles que l'envoi d'e-mails, la mise en cache, l'authentification de connexion, etc.
Le concept de conception de Flask est simple, flexible et facile à étendre. Il ne limite pas les choix des développeurs. Diverses extensions tierces peuvent être sélectionnées pour augmenter les fonctionnalités en fonction des besoins des développeurs. Dans le même temps, Flask fournit également des fonctions et des outils de base pour permettre aux développeurs de créer rapidement des applications Web.
Le module d'application est l'un des modules de base du framework Flask. Il est responsable de la création d'objets d'application Flask et de la définition de certaines configurations et fonctions au niveau de l'application. Les modules d'application incluent généralement les éléments suivants :
Créer des objets d'application : créez des objets d'application à l'aide des classes Flask. Le constructeur de la classe Flask nécessite que le nom de l'application soit passé en paramètre.
Configuration de l'application : Vous pouvez utiliser l'attribut config pour configurer les propriétés de base de l'application, telles que le mode de débogage, les clés, les connexions à la base de données, etc.
Enregistrer les routes : utilisez le décorateur de route pour enregistrer la relation de mappage entre les routes d'URL et les fonctions d'affichage. Le routage définit la relation de mappage entre l'adresse URL de la requête HTTP et la fonction d'affichage.
Définir la fonction d'affichage : la fonction View est une fonction qui gère les requêtes HTTP et peut renvoyer des pages HTML, des données JSON, etc. Les fonctions d'affichage utilisent généralement le décorateur d'itinéraire pour définir les itinéraires d'URL.
Gestion du contexte : les applications Flask utilisent des objets de contexte pour gérer le contexte de la demande et le contexte de l'application. Le contexte de la requête contient des informations pertinentes pour chaque requête HTTP, telles que les en-têtes de requête, les paramètres de requête, etc. Le contexte de l'application contient des informations relatives à l'application, telles que des informations de configuration, des connexions à la base de données, etc.
Gestion des erreurs : les applications Flask peuvent gérer les erreurs qui se produisent dans les requêtes HTTP, telles que les erreurs 404, 500, etc., en enregistrant des fonctions de gestion des erreurs.
Gestion des extensions : les applications Flask peuvent ajouter des fonctionnalités d'application en enregistrant des objets d'extension, tels que les connexions à la base de données, la mise en cache, l'envoi d'e-mails, etc.
Démarrer l'application : démarrez l'application via la méthode run afin qu'elle puisse recevoir des requêtes HTTP.
Le module d'application est l'un des modules de base de l'application Flask. Il est responsable de la gestion du cycle de vie de l'ensemble de l'application et constitue une partie importante du développement des applications Web Flask.
【Exemple】Ce qui suit est un exemple d'application Flask simple qui montre comment utiliser le module d'application pour créer un objet d'application Flask, enregistrer les fonctions de routage et d'affichage, configurer l'application, etc.
from flask import Flask, render_template
app = Flask(__name__)
# 配置应用程序
app.config['DEBUG'] = True
app.config['SECRET_KEY'] = 'your_secret_key'
# 注册路由和视图函数
@app.route('/')
def index():
return 'Hello, World!'
@app.route('/user/<name>')
def user(name):
return 'Hello, %s!' % name
@app.route('/hello/')
@app.route('/hello/<name>')
def hello(name=None):
return render_template('hello.html', name=name)
# 启动应用程序
if __name__ == '__main__':
app.run()Explication du code :
在上面的示例中，我们首先导入了 Flask 类和 render_template 函数。然后创建了一个 Flask 应用程序对象，使用了 __name__ 作为应用程序的名称。接着配置了应用程序的一些基本属性，包括调试模式和密钥等。
然后使用 @app.route() 装饰器来注册 URL 路由和视图函数之间的映射关系。我们定义了三个视图函数，分别对应不同的 URL 地址，可以返回不同的响应内容。其中 /hello/ 和 /hello/<name> 两个路由对应的是同一个视图函数，使用了 Flask 支持的多路由规则。
最后使用 app.run() 方法启动了应用程序，使其可以接收 HTTP 请求。
注意，在开发过程中，我们通常不会将 Flask 应用程序对象的 run() 方法直接放在程序的主体代码中，而是使用一个单独的脚本来启动应用程序，如：
if __name__ == '__main__':
app.run()路由模块是 Flask 应用程序的核心组成部分之一，它实现了 URL 路由和视图函数之间的映射关系。在 Flask 中，我们可以通过定义路由模块来为应用程序添加不同的路由规则，使得应用程序可以响应不同的 URL 请求。
在 Flask 中，可以使用装饰器来定义路由模块。常用的装饰器包括：
@app.route(rule, options)：定义路由规则和处理函数之间的映射关系。其中 rule 参数表示路由规则，options 参数表示路由的配置选项。
例如，下面的示例定义了一个路由规则，用于处理 /hello URL 请求，并返回一个包含字符串的响应：
from flask import Flask
app = Flask(__name__)
@app.route('/hello')
def hello():
return 'Hello, World!'@app.before_request：在每个请求被处理之前执行的函数。通常用于执行一些预处理操作，例如验证用户的登录状态、设置全局变量等。
例如，下面的示例定义了一个 before_request 函数，用于在处理请求之前打印请求的 HTTP 方法和 URL：
from flask import Flask, request
app = Flask(__name__)
@app.before_request
def log_request():
print(f'Request: {request.method} {request.url}')@app.after_request：在每个请求被处理之后执行的函数。通常用于执行一些后处理操作，例如添加响应头信息、记录日志等。
例如，下面的示例定义了一个 after_request 函数，用于在处理请求之后添加一个名为 X-My-Header 的响应头：
from flask import Flask
app = Flask(__name__)
@app.after_request
def add_header(response):
response.headers['X-My-Header'] = 'Hello, World!'
return response@app.errorhandler：处理指定错误码的异常，例如 404 错误、500 错误等。可以定义多个不同的错误处理函数，以处理不同的异常情况。
例如，下面的示例定义了一个 404 错误处理函数，用于处理访问不存在的 URL 时的异常情况：
from flask import Flask, render_template
app = Flask(__name__)
@app.errorhandler(404)
def page_not_found(e):
return render_template('404.html'), 404在上面的示例中，我们定义了一个 page_not_found() 函数，并使用 @app.errorhandler(404) 装饰器将其注册为处理 404 错误的函数。在处理 404 错误时，Flask 会调用该函数，并将异常对象作为参数传入。函数返回一个包含错误信息的响应，并将 HTTP 状态码设置为 404。
总之，路由模块是 Flask 应用程序的重要组成部分，它可以通过不同的装饰器实现请求预处理、响应后处理、错误处理等功能。下面是一个完整的 Flask 路由模块的示例：
from flask import Flask, request, render_template
app = Flask(__name__)
# 请求预处理函数
@app.before_request
def log_request():
print(f'Request: {request.method} {request.url}')
# 路由规则和处理函数
@app.route('/')
def index():
return 'Hello, World!'
@app.route('/hello')
def hello():
return 'Hello, World!'
@app.route('/hello/<name>')
def hello_name(name):
return f'Hello, {name}!'
# 响应后处理函数
@app.after_request
def add_header(response):
response.headers['X-My-Header'] = 'Hello, World!'
return response
# 错误处理函数
@app.errorhandler(404)
def page_not_found(e):
return render_template('404.html'), 404
# 启动应用程序
if __name__ == '__main__':
app.run()在上面的示例中，我们定义了一个 Flask 应用程序，并使用 @app.route 装饰器定义了三个路由规则和处理函数：
/ URL 请求将会调用 index() 函数，并返回一个字符串 'Hello, World!'。
/hello URL 请求将会调用 hello() 函数，并返回一个字符串 'Hello, World!'。
/hello/<name> URL 请求将会调用 hello_name(name) 函数，并返回一个包含 name 参数的字符串 'Hello, {name}!'。
我们还使用了 @app.before_request 装饰器定义了一个请求预处理函数 log_request()，用于在每个请求被处理之前打印请求的 HTTP 方法和 URL。
同时，我们还使用了 @app.after_request 装饰器定义了一个响应后处理函数 add_header(response)，用于在每个请求被处理之后添加一个名为 X-My-Header 的响应头。
最后，我们使用 @app.errorhandler 装饰器定义了一个 404 错误处理函数 page_not_found(e)，用于处理访问不存在的 URL 时的异常情况。
整个路由模块的代码非常简单明了，通过 Flask 提供的装饰器可以轻松地定义路由规则和处理函数，实现不同 URL 请求的响应。
在 Flask 中，视图模块用于处理请求并生成响应，通常由视图函数来实现。视图函数负责处理一个或多个 URL 请求，并返回一个响应对象。响应对象可以是纯文本、HTML、JSON、图像等。
下面是一个简单的 Flask 视图模块的示例：
from flask import Flask, request, jsonify
app = Flask(__name__)
# 视图函数
@app.route('/hello')
def hello():
name = request.args.get('name', 'World')
return f'Hello, {name}!'
@app.route('/json')
def json():
data = {'message': 'Hello, World!'}
return jsonify(data)
# 启动应用程序
if __name__ == '__main__':
app.run()在上面的示例中，我们定义了两个视图函数：
hello() 函数处理 /hello URL 请求，使用 request.args.get() 方法获取请求参数中的 name 参数（默认为 'World'），并将其插入到响应字符串中返回给客户端。
json() 函数处理 /json URL 请求，生成一个包含 message 属性的字典对象，然后使用 Flask 提供的 jsonify() 函数将其转换为 JSON 格式的响应对象返回给客户端。
启动 Flask 应用程序后，可以在浏览器中访问 /hello 或 /json URL 来测试视图函数的效果。
视图函数是 Flask 应用程序的核心组成部分，可以通过不同的方式生成响应，如使用模板引擎渲染 HTML 页面、返回纯文本或 JSON 数据等。视图函数还可以接受请求参数，通过 request 对象获取请求数据，并根据请求参数生成相应的响应。
在 Flask 中，模板模块用于生成动态的 HTML 页面或其他类型的文档。Flask 支持多种模板引擎，如 Jinja2、Mako、Mustache 等，其中 Jinja2 是最常用的模板引擎之一。
下面是一个简单的 Flask 模板模块的示例，使用 Jinja2 模板引擎渲染一个 HTML 页面：
from flask import Flask, render_template
app = Flask(__name__)
# 路由规则和视图函数
@app.route('/')
def index():
return render_template('index.html', name='World')
# 启动应用程序
if __name__ == '__main__':
app.run()在上面的示例中，我们定义了一个路由规则 /，并使用 render_template() 函数将模板文件 index.html 渲染为 HTML 页面，其中传递了一个名为 name 的变量值为 'World'。
下面是 index.html 模板文件的示例：
<!DOCTYPE html>
<html>
<head>
<title>Hello, {{ name }}!</title>
</head>
<body>
<h2>Hello, {{ name }}!</h2>
</body>
</html>代码讲解：
在上面的示例中，使用了 Jinja2 模板引擎的语法 {{ name }}，它将在渲染模板时被替换为 render_template() 函数中传递的 name 变量的值。
启动 Flask 应用程序后，访问根 URL / 将会返回一个包含 Hello, World! 的 HTML 页面。
模板模块是 Flask 应用程序的重要组成部分，它可以实现动态生成各种类型的文档，如 HTML 页面、JSON 数据、CSV 文件等。在 Flask 中，使用模板引擎可以方便地将数据和 HTML 页面进行分离，实现更加清晰和易于维护的代码结构。
在 Flask 应用程序中，通常需要使用数据库来存储和管理数据。Flask 提供了多种数据库模块的支持，如 SQLAlchemy、Peewee、MongoDB 等。
下面以 SQLAlchemy 为例，介绍如何在 Flask 应用程序中使用数据库模块。
使用 pip 安装 SQLAlchemy：
pip install SQLAlchemy
在 Flask 应用程序中，需要配置数据库连接，包括数据库类型、主机名、端口号、数据库名、用户名和密码等。可以使用 Flask 应用程序的配置对象 app.config 来存储这些配置信息，如下所示：
from flask import Flask from flask_sqlalchemy import SQLAlchemy app = Flask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://user:password@localhost/mydatabase' db = SQLAlchemy(app)
在上面的示例中，我们使用 SQLAlchemy 模块创建了一个数据库连接 db，并将其关联到 Flask 应用程序对象 app 上。
使用 SQLAlchemy 模块可以方便地定义数据库模型，例如下面的示例定义了一个简单的用户模型：
from datetime import datetime
from sqlalchemy import Column, Integer, String, DateTime
class User(db.Model):
id = Column(Integer, primary_key=True)
name = Column(String(50), nullable=False)
email = Column(String(120), unique=True, nullable=False)
created_at = Column(DateTime, default=datetime.now)在上面的示例中，我们使用 SQLAlchemy 提供的 Column 类定义了三个列：id、name、email 和 created_at。其中，id 是主键列，name 和 email 是字符串列，created_at 是日期时间列。
使用 SQLAlchemy 模块可以方便地执行数据库操作，例如下面的示例：
# 创建数据库表 db.create_all() # 插入数据 user = User(name='Alice', email='alice@example.com') db.session.add(user) db.session.commit() # 查询数据 users = User.query.all() # 更新数据 user.name = 'Bob' db.session.commit() # 删除数据 db.session.delete(user) db.session.commit()
在上面的示例中，我们使用 db.create_all() 创建数据库表，使用 db.session.add() 插入数据，使用 User.query.all() 查询数据，使用 db.session.commit() 提交事务。还可以使用 db.session.query() 查询数据，使用 db.session.filter() 过滤数据，使用 db.session.order_by() 排序数据等。
数据库模块是 Flask 应用程序的核心组成部分之一，它可以方便地实现数据的存储和管理，为 Web 应用程序提供强大的数据支持。在使用数据库模块时，需要注意数据的安全性和可靠性，如防止 SQL 注入攻击、处理事务、使用数据库索引等。
表单模块是 Flask 应用程序中常用的组件之一，它可以方便地实现用户输入的数据验证和处理。在 Flask 中，表单模块通常使用 WTForms 库实现。
下面介绍如何在 Flask 应用程序中使用表单模块。
使用 pip 安装 WTForms：
pip install WTForms
在 Flask 应用程序中，需要定义一个表单类来描述需要接收的数据和对数据进行验证的规则。例如下面的示例定义了一个简单的用户注册表单：
from wtforms import Form, StringField, PasswordField, validators
class RegistrationForm(Form):
name = StringField('Name', [validators.Length(min=4, max=25)])
email = StringField('Email', [validators.Email()])
password = PasswordField('Password', [
validators.DataRequired(),
validators.EqualTo('confirm_password', message='Passwords must match')
])
confirm_password = PasswordField('Confirm Password')在上面的示例中，我们使用 WTForms 提供的 Form 类定义了一个表单类 RegistrationForm，并定义了三个字段：name、email 和 password。对于每个字段，我们使用不同的验证器进行验证，例如 validators.Length、validators.Email 和 validators.EqualTo 等。
在 Flask 应用程序中，需要使用表单类来接收用户提交的数据，然后对数据进行验证和处理。例如下面的示例定义了一个处理用户注册的视图函数：
from flask import render_template, request
from .forms import RegistrationForm
@app.route('/register', methods=['GET', 'POST'])
def register():
form = RegistrationForm(request.form)
if request.method == 'POST' and form.validate():
# 处理用户注册数据
return 'Registration successful!'
return render_template('register.html', form=form)在上面的示例中，我们使用表单类 RegistrationForm 来接收用户提交的数据，然后在视图函数中使用 request.form 方法获取表单数据，并使用 form.validate() 方法验证表单数据是否合法。如果表单数据验证通过，则进行用户注册操作，并返回注册成功的消息。
在 Flask 应用程序中，需要使用模板引擎来渲染表单模板，并将表单类传递给模板。例如下面的示例定义了一个注册表单模板：
<form method="POST">
{{ form.name.label }} {{ form.name }}
{{ form.email.label }} {{ form.email }}
{{ form.password.label }} {{ form.password }}
{{ form.confirm_password.label }} {{ form.confirm_password }}
<button type="submit">Register</button>
</form>在上面的示例中，我们使用表单类 RegistrationForm 中的字段 name、email、password 和 confirm_password 渲染表单模板，并使用 form.name.label 和 form.name 等属性来获取标签和输入框的 HTML 代码。
表单模块是 Flask 应用程序中常用的组件之一。
在 Flask 应用程序中，扩展模块可以帮助我们更方便地实现某些功能或解决某些问题。下面介绍一些常用的 Flask 扩展模块。
Flask-WTF：Flask-WTF 是一个 WTForms 的 Flask 扩展，它为 Flask 应用程序提供了更方便的表单处理和 CSRF 保护等功能。使用 Flask-WTF 可以大大简化表单处理的代码，同时提高应用程序的安全性。
Flask-Login：Flask-Login 是一个用于用户身份验证和管理的 Flask 扩展，它提供了用户登录和登出等功能，还可以方便地管理用户状态和权限等信息。使用 Flask-Login 可以大大简化用户身份验证和管理的代码，同时提高应用程序的安全性。
Flask-SQLAlchemy：Flask-SQLAlchemy 是一个 SQLAlchemy 的 Flask 扩展，它提供了对关系型数据库的支持，例如 MySQL、PostgreSQL 和 SQLite 等。使用 Flask-SQLAlchemy 可以方便地进行数据库操作，例如创建表、插入数据和查询数据等。
Flask-Cache：Flask-Cache 是一个缓存的 Flask 扩展，它提供了缓存功能，可以将应用程序中的一些计算结果缓存起来，以减少计算量和响应时间。使用 Flask-Cache 可以提高应用程序的性能和响应速度。
Flask-Mail：Flask-Mail 是一个邮件发送的 Flask 扩展，它提供了发送邮件的功能，可以方便地发送邮件给用户或管理员等。使用 Flask-Mail 可以大大简化发送邮件的代码，同时提高应用程序的交互性和用户体验。
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
