FLASK基础

AI大眼萌

已于 2024-04-04 12:02:27 修改

阅读量928

点赞数 17

文章标签： flask python 后端

于 2024-04-03 16:35:08 首次发布

本文链接：https://blog.csdn.net/caoxiaoye/article/details/137331312

版权

在这里插入图片描述

文章目录

Jinja2与Flask关系
Jinja 模板语法的一些基本元素：
curl命令
为什么使用序列化和反序列化？
在 Flask 框架下集成 Elasticsearch 构建一个 REST 接口
Fetch API
在 Flask 中使用 SQLAlchemy
有限状态机（Finite State Machine，FSM）

Jinja2与Flask关系

Flask 的开发者选择 Jinja2 作为默认模板引擎，是因为它的简洁性、灵活性以及强大的功能集，这些特点使得 Jinja2 成为开发 Web 应用程序的理想选择。

当你创建一个新的 Flask 应用时，不需要进行任何额外的配置就可以立即开始使用 Jinja2 模板。Flask 自动处理了 Jinja2 的集成和配置，使得开发者可以专注于编写应用程序逻辑和设计模板。

在 Flask 应用中使用 Jinja2 模板非常简单。你只需要在应用的根目录下创建一个名为 templates 的文件夹，然后在该文件夹中存放你的 Jinja2 模板文件。Flask 会自动找到并渲染这些模板。

例如，假设你有一个名为 hello.html 的 Jinja2 模板文件，内容如下：

<!DOCTYPE html>
<html>
<head>
    <title>{{ title }}</title>
</head>
<body>
    <h1>{{ message }}</h1>
</body>
</html>

你可以在你的 Flask 视图函数中使用 render_template 函数来渲染这个模板，并传递一些变量：

from flask import Flask, render_template

app = Flask(__name__)

@app.route('/')
def index():
    title = 'Welcome'
    message = 'Hello, Jinja2!'
    return render_template('hello.html', title=title, message=message)

if __name__ == '__main__':
    app.run(debug=True)

在这个例子中，render_template 函数接收模板文件的名称以及一个包含变量的字典。这些变量将被传递到模板中，并替换模板中的占位符。

由于 Flask 默认集成了 Jinja2，你不需要进行任何额外的安装或配置就可以开始使用 Jinja2 的强大功能。这使得 Flask 和 Jinja2 成为了创建动态 Web 应用程序的理想组合。

Jinja 模板语法的一些基本元素：

变量
在 Jinja 模板中，变量被包裹在 {{ … }} 中。例如：

<p>Current user: {{ user.username }}</p>

过滤器
过滤器用于格式化变量的输出。它们位于变量后面，并用 | 分隔。例如，如果你想将一个字符串转换为大写：

<p>Greeting: {{ "hello"|upper }}</p>

标签
标签用于控制模板的逻辑和结构。它们以 {% … %} 开始，并提供多种用途，如循环、条件判断、包含其他模板等。以下是一些常见的标签：

if 条件判断：

{% if user.is_authenticated %}
  <p>Welcome, {{ user.username }}!</p>
{% else %}
  <p>Welcome, guest!</p>
{% endif %}

for 循环：

<ul>
{% for item in items %}
  <li>{{ item.name }}</li>
{% endfor %}
</ul>
include 包含其他模板：
{% include 'header.html' %}
block 定义可重写的模板块：
{% block content %}
  This is the default content.
{% endblock %}

注释
Jinja 模板中的注释使用 {# … #} 包裹：

{# This is a comment in Jinja template #}

宏
宏允许你定义可重用的模板片段：

{% macro input(name, type='text') %}
  <input type="{{ type }}" name="{{ name }}">
{% endmacro %}

然后在其他地方调用宏：

{{ input('username') }}

模板继承
模板继承允许你创建一个基础模板，并让其他模板继承自它。这通常用于创建具有共同布局的页面：

{# base.html #}
<!DOCTYPE html>
<html>
<head>
  <title>{% block title %}My Site{% endblock %}</title>
</head>
<body>
  {% block content %}{% endblock %}
</body>
</html>

其他模板可以继承这个基础模板：

{# home.html #}
{% extends 'base.html' %}

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

{% block content %}
  <h1>Welcome to my site!</h1>
{% endblock %}

自动转义
Jinja 默认会自动转义所有输出，以防止 XSS 攻击。如果你想输出原始的 HTML 而不是转义的 HTML，可以使用 safe 过滤器：

<p>{{ some_html|safe }}</p>

这些是 Jinja 模板语法的基本元素。通过这些工具，你可以创建功能丰富且安全的动态网页。

curl命令

curl 是一个功能强大的命令行工具，用于发送和接收数据。它支持多种协议，包括 HTTP、HTTPS、FTP、FTPS、SCP、SFTP、TFTP、TELNET、DICT、LDAP、LDAPS、IMAP、POP3、SMTP 等。curl 常用于 API 测试、文件上传下载、数据抓取等场景。

以下是一些常用的 curl 命令及其用法：

基本 GET 请求

curl http://example.com
这个命令会向 http://example.com 发送一个 GET 请求，并输出返回的内容。

带参数的 GET 请求

curl "http://example.com/resource?param1=value1&param2=value2"
这个命令会发送一个带有查询参数的 GET 请求。

POST 请求

curl -X POST -d "param1=value1&param2=value2" http://example.com/resource
这个命令使用 POST 方法向 http://example.com/resource 发送数据。

上传文件

curl -X POST -F "file=@/path/to/your/file" http://example.com/upload
这个命令使用 -F 选项来上传文件。@ 符号后面跟着文件在本地的路径。

使用 HTTP 代理

curl -x http://proxyserver:port http://example.com
这个命令通过指定的 HTTP 代理服务器发送请求。

发送自定义头部信息

curl -H "Custom-Header: value" http://example.com
这个命令会在请求中添加一个自定义的头部信息。

持久连接（Keep-Alive）

curl --connect-timeout 60 --keepalive-time 120 http://example.com
这个命令设置了连接超时时间和保持连接的活动时间。

使用基本认证

curl -u username:password http://example.com/protected-resource
这个命令通过 -u 选项添加基本认证信息。

HTTPS 请求

curl https://example.com
这个命令会向 https://example.com 发送一个 GET 请求。

禁用 SSL 验证

curl --insecure https://example.com
这个命令会忽略 SSL 证书验证（不推荐在生产环境中使用）。

保存响应到文件

curl -o filename.html http://example.com
这个命令会将响应保存到指定的文件中。

从文件发送数据

curl -X POST --data-binary "@/path/to/your/file" http://example.com/upload
这个命令使用 --data-binary 选项发送文件内容。

使用 JSON 数据发送 POST 请求

curl -H "Content-Type: application/json" -X POST -d '{"param1":"value1", "param2":"value2"}' http://example.com/resource
这个命令发送一个 JSON 格式的数据。

跟随重定向

curl -L http://example.com/redirect
这个命令会跟随服务器返回的重定向。

显示详细的请求和响应信息

curl -v http://example.com
这个命令会显示请求和响应的详细信息，包括 HTTP 头部、数据等。

这些是 curl 的一些基本用法。curl 还有许多其他选项和功能，可以通过查看其手册页（man curl）或访问其官方文档来获取更多信息。

为什么使用序列化和反序列化？

序列化和反序列化在数据存储和网络通信中非常重要。当数据需要在网络上传输或者存储到文件中时，通常需要将其转换为一种易于传输和存储的格式。JSON 作为一种文本格式，非常适合这些场景，因为它具有良好的跨平台兼容性和可读性。

网络通信：客户端和服务器之间传输数据时，通常会使用 JSON 格式，因为它易于生成和解析，且不受平台限制。
数据存储：JSON 格式也可以用于存储配置信息、用户设置等，因为它可以轻松地被程序读取和写入。
总之，序列化和反序列化是处理 JSON 数据的基本操作，它们使得数据能够在不同的系统和平台之间进行有效的交换和使用。

序列化虽然是一种常见的数据存储和传输手段，但如果处理不当，也可能引入一些安全风险。以下是一些与序列化相关的潜在安全风险及其原因：

1. 数据泄露风险

序列化的数据可能包含敏感信息，如用户凭证、私钥或其他保密数据。如果序列化的数据在传输过程中未加密或未进行适当的保护，攻击者可能截获并解析这些数据，导致敏感信息泄露。

2. 对象注入攻击

在某些编程环境中，如果序列化的数据被恶意构造，攻击者可能利用序列化的特性执行对象注入攻击。例如，如果一个应用程序反序列化不可信的输入，并使用这些对象执行操作，攻击者可能会注入恶意代码或构造特定的对象来执行未授权的操作。

3. 版本控制问题

序列化格式可能会随时间而变化，如果应用程序没有正确地处理不同版本的序列化数据，可能会导致数据损坏或安全漏洞。例如，旧版本的应用程序可能无法正确解析新版本的序列化数据，或者新版本的应用程序可能无法防止旧版本中不存在的攻击向量。

4. 篡改风险

序列化的数据在存储或传输过程中可能被篡改。如果数据的完整性没有得到验证，攻击者可能会修改数据，导致应用程序行为异常或执行非预期操作。

如何防范这些风险

为了防范与序列化相关的安全风险，可以采取以下措施：

加密敏感数据：在序列化包含敏感信息的数据之前进行加密，确保即使数据被截获，也无法被轻易解读。
使用安全的序列化库：使用经过安全审查的序列化库，并保持库的更新，以利用最新的安全修复和改进。
输入验证和过滤：对所有将要序列化的数据进行严格的验证和过滤，确保它们不包含潜在的危险内容。
完整性检查：对序列化的数据进行完整性检查，如使用哈希算法验证数据的完整性，防止数据篡改。
版本控制和向后兼容性：设计序列化格式时考虑向后兼容性，并提供数据迁移和升级的策略，确保新旧版本的数据都能被安全地处理。
访问控制：确保只有授权的用户和程序可以序列化和反序列化数据，防止未授权的访问和修改。

通过采取这些措施，可以显著降低序列化过程中的安全风险，并保护应用程序和用户数据的安全。

反序列化在许多应用程序中是一种常见的操作，尤其是在处理来自网络请求、文件或数据库的数据时。然而，如果不正确处理，反序列化可能会引入一些安全风险。以下是一些主要的安全风险及其原因：

1. 恶意代码执行

某些对象在反序列化过程中可能会执行恶意代码。这是因为在反序列化过程中，对象的构造函数和方法可能会被调用，如果这些对象包含不安全的代码或者被恶意修改，它们可能会执行非预期的操作，比如远程代码执行（RCE）。

2. 敏感数据泄露

如果反序列化过程中没有适当的安全措施，攻击者可能会利用这一点来访问或修改敏感数据。例如，如果序列化的对象包含敏感信息，并且在反序列化时没有进行适当的加密或验证，攻击者可能会通过篡改数据来获取这些信息。

3. 拒绝服务攻击（DoS）

某些复杂的对象在反序列化时可能会消耗大量的计算资源，这可能导致服务暂时不可用。攻击者可能会利用这一点发送特制的请求，导致服务器资源耗尽，从而发起拒绝服务攻击。

4. 会话劫持

在 Web 应用程序中，会话信息通常被序列化并存储在客户端的 Cookie 中。如果会话信息的序列化和反序列化过程不够安全，攻击者可能会篡改会话信息，从而劫持用户的会话。

如何防范这些风险

为了防范这些安全风险，可以采取以下措施：

输入验证：始终对输入数据进行严格的验证，确保它们符合预期的格式和类型。
使用白名单：对于可以被反序列化的对象，使用白名单来限制允许的对象类型和结构。
避免执行不安全的操作：在对象的构造函数和方法中避免执行不安全的操作，特别是那些可以访问外部资源或执行代码的操作。
使用最新的库和框架：确保使用的序列化和反序列化库是最新的，并且已经修复了已知的安全漏洞。
加密敏感数据：对敏感数据进行加密，确保即使数据被拦截，攻击者也无法轻易解读。
实施访问控制：确保只有授权的用户和程序可以进行序列化和反序列化操作。
安全编码实践：遵循安全编码实践，避免在代码中引入可能导致安全问题的漏洞。

通过采取这些措施，可以显著降低反序列化过程中的安全风险，并保护应用程序和用户数据的安全。

在 Flask 框架下集成 Elasticsearch 构建一个 REST 接口

首先需要确保你已经安装了 Flask 和 Elasticsearch。以下是一个简单的示例，展示如何使用 Flask 和 Elasticsearch 创建一个 RESTful API，用于搜索和存储数据。

1. 安装所需库

首先，你需要安装 Flask 和 Elasticsearch 的 Python 客户端库 elasticsearch：

pip install flask elasticsearch

2. 创建 Flask 应用

创建一个名为 app.py 的文件，并在其中编写以下代码：

from flask import Flask, jsonify, request
from elasticsearch import Elasticsearch

app = Flask(__name__)
es = Elasticsearch()
app.config['JSON_AS_ASCII'] =False
@app.route('/api/search', methods=['GET'])
def search():
    query = request.args.get('q', '')  # 获取查询参数
    if not query:
        return jsonify({'error': 'No query provided'}), 400

    body = {
        "query": {
            "match": {
                "content": query
            }
        }
    }
    response = es.search(index="my_index", body=body)
    return jsonify(response)

@app.route('/api/documents', methods=['POST'])
def add_document():
    data = request.get_json()  # 获取 JSON 数据
    if not data or 'title' not in data or 'content' not in data:
        return jsonify({'error': 'Invalid data'}), 400

    # 存储文档到 Elasticsearch
    response = es.index(index="my_index", body=data)
    return jsonify(response), 201

if __name__ == '__main__':
    app.run(debug=True)

在这个示例中，我们定义了两个路由：

/api/search：用于搜索文档。它接受一个 GET 请求，并期望查询参数 q 包含搜索的关键词。
/api/documents：用于添加新的文档。它接受一个 POST 请求，并期望请求的正文包含 title 和 content 字段。

3. 运行 Flask 应用

运行 app.py 文件：

python app.py

4. 使用 REST 接口

现在，你的 Flask 应用已经运行，并且可以通过以下方式使用 REST 接口：

搜索文档：

curl "http://127.0.0.1:5000/api/search?q=your_search_term"

添加文档：

curl -X POST -H "Content-Type: application/json" -d '{"title": "New Document", "content": "Content of the new document"}' "http://127.0.0.1:5000/api/documents"

请注意，这个示例假设你的 Elasticsearch 服务已经在本地运行。如果你的 Elasticsearch 服务运行在不同的主机或端口上，你需要在创建 Elasticsearch 对象时指定 hosts 参数。

es = Elasticsearch(hosts=["http://your_elasticsearch_host:9200"])

此外，你可能需要对 Elasticsearch 进行一些配置，比如创建索引、定义映射等，这取决于你的具体需求和 Elasticsearch 的版本。这个示例仅提供了一个基本的起点，用于展示如何在 Flask 应用中集成 Elasticsearch。在生产环境中，你可能需要考虑更多的因素，比如错误处理、安全性、性能优化等。

Fetch API

Fetch API是一种在 JavaScript 中进行网络请求的现代方法，它提供了一个强大且灵活的方式来发起对服务器的 HTTP 请求并处理响应。Fetch API 可以在多种场景中使用，以下是一些主要的应用场景：

1. 网页应用（Web Applications）

在网页应用中，Fetch API 被广泛用于从服务器获取数据、提交表单、上传文件等。它可以替代传统的 XMLHttpRequest 对象，提供更加简洁、强大的 API 接口。

示例

fetch('https://api.example.com/data', {
  method: 'GET',
  headers: {
    'Content-Type': 'application/json'
  }
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));

2. 单页应用（Single Page Applications, SPAs）

在单页应用中，Fetch API 用于在不重新加载整个页面的情况下，异步加载和更新内容。这有助于创建更加动态和响应式的用户体验。

示例

// 当用户点击某个按钮时，获取新数据并更新页面
document.getElementById('load-data-button').addEventListener('click', () => {
  fetch('/api/data')
    .then(response => response.json())
    .then(data => updateUI(data))
    .catch(error => console.error('Error:', error));
});

3. 移动应用（Mobile Applications）

许多移动应用使用基于 Web 技术的前端框架（如 React Native、Ionic 等），在这些应用中，Fetch API 同样可以用来与后端服务进行通信。

示例

// 在移动应用中获取用户信息
fetch('https://api.example.com/user', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer ' + token
  }
})
.then(response => response.json())
.then(user => displayUserProfile(user))
.catch(error => console.error('Error:', error));

4. 服务器端渲染（Server-Side Rendering, SSR）

在服务器端渲染的 Web 应用中，Fetch API 可以用来在服务器上请求和获取数据，然后将这些数据嵌入到 HTML 页面中，以便快速渲染。

示例

// 在服务器端获取数据并渲染页面
const data = await fetch('https://api.example.com/data').then(response => response.json());
const html = renderPage(data);
return html;

5. 微前端（Micro Frontends）

在微前端架构中，不同的前端应用可能需要独立地与后端服务通信。Fetch API 可以作为这些独立应用的标准网络请求工具。

示例

// 微前端应用中的数据请求
const microFrontendApp = () => {
  fetch('/api/microfrontend/data')
    .then(response => response.json())
    .then(data => updateMicroFrontend(data))
    .catch(error => console.error('Error:', error));
};

6. 跨域资源共享（Cross-Origin Resource Sharing, CORS）

Fetch API 支持 CORS，允许开发者从浏览器中发起跨域请求。这使得前端应用可以访问不同域下的资源，而无需担心跨域问题。

示例

fetch('https://another-domain.com/resource', {
  mode: 'cors' // 默认值，允许跨域请求
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));

Fetch API 的设计目标是提供一个全局的 fetch() 方法，使得网络请求变得更加简单、一致且易于理解。它的引入为现代 Web 开发提供了强大的网络请求能力，适用于多种不同的应用场景。

在 Flask 中使用 SQLAlchemy

步骤 1: 安装必要的包

首先，确保你已经安装了 Flask 和 SQLAlchemy。如果没有，可以使用 pip 进行安装：

pip install Flask SQLAlchemy

步骤 2: 创建 Flask 应用和数据库模型

在你的 Flask 应用中创建一个简单的模型。首先定义一些数据库表和与之对应的 Python 类。

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///example.db'
db = SQLAlchemy(app)

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}>'

在这个例子中，我们定义了一个 User 类，它有三个字段：id, username, 和 email。这些字段使用 db.Column 来定义，并指定了相应的类型和属性。

步骤 3: 初始化数据库

在你的 Flask 应用中，你需要创建数据库表。这通常是通过运行一个迁移脚本来完成的，但是在这个简单的例子中，我们可以直接在应用启动时创建表。

@app.before_first_request
def create_table():
    db.create_all()

这个装饰器 before_first_request 确保 create_table 函数在处理第一个请求之前运行一次。

步骤 4: 与数据库交互

现在你可以在你的 Flask 路由中使用 SQLAlchemy 来查询和操作数据库了。

@app.route('/users', methods=['POST'])
def create_user():
    # 获取 POST 请求的数据
    username = request.form['username']
    email = request.form['email']

    # 创建新用户
    new_user = User(username=username, email=email)
    db.session.add(new_user)
    db.session.commit()

    return 'User created.'

在这个例子中，我们创建了一个新的 User 对象，并将其添加到数据库会话中。然后我们提交会话，这样就将新用户保存到了数据库。

有限状态机（Finite State Machine，FSM）

有限状态机（Finite State Machine，FSM）是一种强大的工具，可以用于模拟和控制具有有限数量状态的系统。它的使用场景非常广泛，涵盖了从简单的逻辑控制到复杂的系统管理等多个领域。以下是一些具体的使用场景：

1. 游戏开发【2】

在游戏开发中，状态机被用来控制游戏角色的行为，例如，角色可能有“站立”、“行走”、“跳跃”、“攻击”等状态。状态机可以帮助游戏开发者定义角色在不同情况下如何从一个状态转换到另一个状态，以及每个状态下角色应有的行为。

2. 网络协议【3】

网络协议中的状态机用于管理连接的状态，处理数据包的发送和接收。例如，TCP协议中有三次握手的过程，这个过程可以用一个状态机来描述，其中包括“监听”、“同步”、“传输”等状态。

3. 工作流程管理【2】

在业务流程管理中，状态机可以用来定义工作流程中的各个步骤以及它们之间的转换条件。例如，一个订单可能经历“创建”、“处理”、“发货”、“完成”等状态，状态机可以帮助管理这些状态的转换。

4. 自动化控制系统【2】【3】

在自动化控制系统中，状态机用于管理机器的状态和操作。例如，一个生产线上的机器人可能有“空闲”、“装载”、“加工”、“卸载”等状态，状态机可以确保机器人根据输入信号和当前状态执行正确的操作。

5. 用户界面设计【2】

在用户界面设计中，状态机可以用来管理界面元素的状态，如按钮的不同状态（“正常”、“悬停”、“按下”、“禁用”）以及界面的导航流程。

6. 硬件设计【1】

在硬件设计领域，特别是在FPGA或ASIC设计中，状态机被用来描述硬件电路的行为。例如，一个数字时钟可能使用状态机来控制显示数字的切换。

7. 软件工程【4】

在软件工程中，状态机可以用于设计和实现具有复杂状态逻辑的软件组件。通过将软件系统分解为一系列状态和事件，可以简化复杂系统的理解和维护。

8. 语言处理【4】

在编译器和解释器的设计中，状态机用于词法分析和语法分析，帮助识别和验证程序中的符号和结构。

9. 异步编程【4】

在JavaScript等支持异步操作的编程语言中，状态机可以帮助管理异步操作的状态，将异步操作与对象的状态改变挂钩，简化异步编程的复杂性。

通过上述场景，我们可以看到有限状态机是一种非常通用的设计工具，它可以帮助开发者以结构化的方式处理和控制复杂系统中的状态变化。无论是在硬件设计、软件开发还是系统管理等领域，状态机都发挥着重要的作用。

AI大眼萌

关注

17
点赞
踩
29

收藏

觉得还不错? 一键收藏
1
评论
FLASK基础

Flask 的开发者选择 Jinja2 作为默认模板引擎，是因为它的简洁性、灵活性以及强大的功能集，这些特点使得 Jinja2 成为开发 Web 应用程序的理想选择。当你创建一个新的 Flask 应用时，不需要进行任何额外的配置就可以立即开始使用 Jinja2 模板。Flask 自动处理了 Jinja2 的集成和配置，使得开发者可以专注于编写应用程序逻辑和设计模板。在 Flask 应用中使用 Jinja2 模板非常简单。
复制链接

扫一扫