Flask学习笔记
Flask是一个用Python编写的轻量级Web应用框架。它的设计目标是易于使用，同时保持开发人员的灵活性。Flask提供了路由、模板引擎和Wsgi支持等核心Web服务功能，同时还支持插件扩展，例如数据库交互、表单验证等。
flask 路由
request 请求参数
html模板
flask数据库
表单
flask特性：
轻量级：Flask是一个轻量级的Web服务程序。Flask路由：Flask使用装饰器来处理路由，使URL与Python函数建立对应关系。Request 请求参数：Flask通过request对象来处理客户端请求，我们可以利用它来获取请求参数。HTML模板：Flask使用Jinja2模板引擎，我们可以在HTML文件中插入动态数据。Flask数据库：Flask可以通过SQLAlchemy等扩展与数据库进行交互。表单：Flask通过WTForms库来处理表单，便于数据的验证和提交。
Flask “Hello World” 示例
下面是一个基本的 Flask “Hello World” 应用的代码示例：
from flask import Flask
#创建一个app对象
app = Flask(__name__)
#路由
@app.route('/')
def hello_world():
return 'Hello, World!'
if __name__ == '__main__':
app.run()
在这个示例中，我们首先从flask模块中导入了Flask类。然后，我们创建了一个Flask web服务器实例。@app.route('/')是一个装饰器，它告诉Flask哪些URL能触发我们的函数。在这种情况下，我们的函数返回了字符串"Hello, World!"，这将作为网页的内容返回给用户。
路由
Flask路由是Flask框架处理URL的机制。在Flask中，我们使用装饰器@app.route()来定义路由。装饰器的参数是URL规则，它将URL与Python函数关联起来。当用户访问指定的URL时，关联的函数就会被执行，其返回值将作为HTTP回应发送给客户端。
例如，以下代码定义了一个基本的路由：
@app.route('/')
def home():
return 'Hello, World!'
在这个例子中，当用户访问应用的根URL（例如：http://localhost:5000/）时，home函数将被执行，并返回字符串"Hello, World!"。
除了根URL，你也可以定义其他的URL规则。例如，你可以创建一个名为greet的路由，当用户访问/greet/
@app.route('/greet/
def greet(name):
return 'Hello, %s!' % name
在这个例子中，
请求方法
在 Flask 中，我们可以通过在路由装饰器中添加 methods 参数来指定 HTTP 请求方法。默认情况下，Flask 的路由只会响应 GET 请求，但我们可以通过 methods 参数来指定路由应该响应的 HTTP 方法，例如 GET、POST、PUT、DELETE 等。
HTTP协议中的GET和POST是两种基本的请求方法，主要区别在于数据传输的方式和用途不同。
数据传输方式：GET请求的数据会附加在URL之后（就是把数据放置在HTTP协议头中），以?分割URL和传输数据，多个参数用&连接。POST方法是把提交的数据放置在是HTTP包的包体中。数据大小：由于GET方法的数据是放在HTTP头中的，因此受到HTTP协议的限制，数据不能太大，一般不能大于2KB。POST方法没有限制，理论上数据的大小可以达到无限大。数据安全性：POST的数据因为在包体中，所以有一定的安全性。而GET将所有数据放在URL中，用户输入的数据都在URL中明文显示，所以安全性较低。用途：GET方法一般用于获取/查询资源信息，而POST方法一般用于更新资源信息。
以下是一个示例，展示了如何在 Flask 中处理 POST 请求：
@app.route('/login', methods=['POST'])
def login():
if request.method == 'POST':
user = request.form['username']
return 'Hello, %s!' % user
在这个示例中，我们首先定义了一个新的路由 ‘/login’，并通过 methods 参数指定这个路由只接受 POST 请求。然后在路由关联的函数中，我们检查了请求方法是否为 POST（尽管在这个例子中可能不需要，因为我们已经指定了这个路由只接受 POST 请求）。如果请求方法为 POST，我们就从表单数据中获取用户名，并返回一个问候消息。
@app.route('/data', methods=['GET', 'POST'])
def data():
if request.method == 'POST':
# POST请求通常用于提交表单数据
# 数据在请求体中，不会显示在URL中
data = request.form['data']
return 'Received the data: %s' % data
else:
# GET请求通常用于获取数据
# 请求的数据显示在URL中
return 'This is a GET request'
在这个例子中，/data路由可以同时处理GET和POST请求。如果请求方法是POST，我们从表单数据中获取数据，并返回接收到的数据。如果请求方法是GET（也就是说，不是POST），我们返回一个表示这是GET请求的消息。这个例子清楚地展示了POST和GET请求的主要区别：POST请求通常用于提交数据，数据在请求体中，不会显示在URL中；而GET请求通常用于获取数据，请求的数据显示在URL中。
路由变量规则
在 Flask 中，我们可以在路由规则中使用变量部分。特定部分的 URL 可以标记为
@app.route('/user/
def show_user_profile(username):
# 用户名将作为字符串传递给 show_user_profile
return 'User %s' % username
在这个例子中，当用户访问如 http://localhost:5000/user/John 的 URL 时，show_user_profile 函数将被调用，且其参数 username 的值将会是 John。
你也可以使用类型转换器在变量规则中指定变量的类型，例如 int、float、path 等。以下是一些例子：
int：接受整数
@app.route('/post/
def show_post(post_id):
# post_id 将会是整数类型
return 'Post %d' % post_id
float：接受浮点数
@app.route('/price/
def show_price(price):
# price 将会是浮点数类型
return 'Price: %f' % price
path：和默认的字符串类似，但也接受斜线
@app.route('/path/
def show_subpath(subpath):
# subpath 将会是字符串类型，可以包含斜线
return 'Subpath %s' % subpath
这样，我们就可以在 Flask 中灵活地处理各种类型的 URL 了。
在Flask的路由变量规则中，string和path都可以接收字符串类型的变量。但是，两者的主要区别在于，string不能接收包含斜线（/）的字符串，而path可以。这意味着，如果你在URL中需要传递包含斜线的字符串，应当使用path类型。
自定义转换器
除了 Flask 提供的内建转换器，我们还可以自定义转换器，以满足特定的 URL 规则需求。
自定义转换器需要继承自 werkzeug.routing.BaseConverter 类，并实现至少两个方法：to_python 和 to_url。
to_python 方法用于将 URL 中的字符串转换为 Python 对象；to_url 方法用于将 Python 对象转换回字符串。
以下是一个自定义转换器的例子，它接受三个字母的字符串：
from werkzeug.routing import BaseConverter
class ThreeLetterConverter(BaseConverter):
def to_python(self, value):
if len(value) != 3:
raise ValueError('Must be three letters.')
return value
def to_url(self, value):
if len(value) != 3:
raise ValueError('Must be three letters.')
return value
app.url_map.converters['three'] = ThreeLetterConverter
在这个例子中，我们首先从 werkzeug.routing 导入了 BaseConverter 类，然后创建了一个新的转换器类 ThreeLetterConverter，该类继承自 BaseConverter。在 ThreeLetterConverter 类中，我们实现了 to_python 和 to_url 方法，这两个方法都要求输入的值必须是三个字母的字符串。
最后，我们将新的转换器添加到 Flask 应用的 URL 映射转换器字典中，键是转换器的名字（在这个例子中是 ‘three’），值是转换器类。
现在，我们就可以在路由规则中使用新的转换器了：
@app.route('/
def three_letter_code(code):
return 'Three-letter code: %s' % code
在这个路由规则中，
通过自定义转换器，我们可以更灵活地处理各种复杂的 URL 规则。
常用自定义转换器用法示例
自定义转换器可以满足更复杂的URL规则需求，比如我们需要处理的URL中包含了日期信息，格式为yyyy-mm-dd，我们就可以自定义一个日期转换器。
from werkzeug.routing import BaseConverter
from datetime import datetime
class DateConverter(BaseConverter):
def to_python(self, value):
return datetime.strptime(value, '%Y-%m-%d')
def to_url(self, value):
return value.strftime('%Y-%m-%d')
app.url_map.converters['date'] = DateConverter
在这个例子中，我们定义了一个名为DateConverter的转换器，该转换器将URL中的字符串转换为datetime对象，反过来，将datetime对象转换为字符串。然后，我们将这个转换器添加到Flask应用的URL映射转换器字典中。
现在，我们就可以在路由规则中使用这个新的转换器：
@app.route('/
def start_date(start_date):
return 'Start date: %s' % start_date
在这个路由规则中，
网页渲染
Flask使用模板引擎来生成HTML，这个过程叫做网页渲染。Flask默认使用的模板引擎是Jinja2。
首先，我们需要在Flask应用的目录下创建一个名为templates的文件夹，在这个文件夹中，我们可以放置所有的HTML模板文件。
然后，我们可以使用render_template函数来渲染模板。render_template函数的第一个参数是模板的文件名（相对于templates文件夹的路径），后面的参数都是传递给模板的变量。
以下是一个例子：
from flask import Flask, render_template
app = Flask(__name__)
@app.route('/hello/
def hello(name):
return render_template('hello.html', name=name)
在这个例子中，我们在/hello/
在hello.html模板中，我们可以使用{{ name }}来获取并显示这个变量的值。例如：
Hello, {{ name }}!
在这个模板中，{{ name }}会被替换为传递给模板的name变量的值。
通过这种方式，我们可以动态地生成HTML页面，根据不同的数据显示不同的内容。
表单渲染
在 Flask 中，我们常常需要处理用户提交的表单数据。这通常包括两个步骤：渲染表单和处理表单数据。
首先，我们需要在模板中创建一个表单。例如，我们可以在 HTML 模板中创建一个简单的登录表单：
在这个表单中，我们有两个输入框分别用于输入用户名和密码，以及一个提交按钮。method="POST"表示这个表单会通过 POST 请求提交数据。
然后，我们可以在 Flask 路由中使用 request.form 来获取表单数据。例如：
@app.route('/login', methods=['POST'])
def login():
username = request.form['username']
password = request.form['password']
# 处理用户名和密码...
return '登录成功'
在这个路由中，我们首先通过 request.form 获取了用户名和密码，然后进行了一些处理（例如，验证用户名和密码是否正确），最后返回了一个消息。
除了手动创建表单和处理表单数据，我们也可以使用 Flask-WTF 扩展来简化这个过程。Flask-WTF 提供了一种简单的方式来处理表单数据和表单验证。
首先，我们需要定义一个表单类，这个类继承自 flask_wtf.FlaskForm，并定义了表单的字段：
from flask_wtf import FlaskForm
from wtforms import StringField, PasswordField, SubmitField
from wtforms.validators import DataRequired
class LoginForm(FlaskForm):
username = StringField('用户名', validators=[DataRequired()])
password = PasswordField('密码', validators=[DataRequired()])
submit = SubmitField('登录')
然后，我们可以在路由中创建一个表单实例，并使用 render_template 函数将表单渲染到模板中：
@app.route('/login', methods=['GET', 'POST'])
def login():
form = LoginForm()
if form.validate_on_submit():
username = form.username.data
password = form.password.data
# 处理用户名和密码...
return '登录成功'
return render_template('login.html', form=form)
最后，我们可以在模板中使用 form 变量来渲染表单：
在这个模板中，form.hidden_tag() 用于生成一个隐藏的 CSRF 令牌，这对于防止跨站请求伪造攻击是必要的。form.username.label 和 form.username() 分别用于生成用户名字段的标签和输入框，其他字段类似。
通过这种方式，我们可以更方便地处理表单数据和表单验证，而不需要手动处理每个表单字段。
POST请求页面渲染示例:
在Flask中，处理POST请求常见的场景是用户填写表单并提交数据，例如用户登录的场景。以下是一个用户登录的例子，包含了处理POST请求和页面渲染：
from flask import Flask, render_template, request
app = Flask(__name__)
@app.route('/login', methods=['GET', 'POST'])
def login():
if request.method == 'POST':
username = request.form['username']
password = request.form['password']
# 在此处处理用户名和密码，例如查看是否匹配、记录登录状态等
# ...
return render_template('welcome.html', username=username) # 渲染欢迎页面
else:
return render_template('login.html') # 渲染登录页面
在这个例子中，当用户首次访问登录页面时，因为是GET请求，所以会渲染并返回’login.html’页面。当用户填写完表单点击提交后，会发送POST请求，此时读取表单中的’username’和’password’，处理后再渲染并返回’welcome.html’页面。
GET请求页面渲染示例:
在Flask中，处理GET请求常见的场景是用户请求查看一些信息，例如用户查看个人资料的页面。以下是一个用户查看个人资料的例子：
from flask import Flask, render_template
app = Flask(__name__)
@app.route('/profile/
def profile(username):
# 在此处获取用户资料，例如从数据库中获取
# ...
user_profile = get_user_profile(username) # 假设是一个获取用户资料的函数
return render_template('profile.html', profile=user_profile) # 渲染个人资料页面
在这个例子中，当用户访问个人资料页面时，例如’/profile/john’，会发送GET请求，服务器会根据用户名’john’获取相应的用户资料，然后渲染并返回’profile.html’页面，页面中会展示用户的资料。
后端代码示例：
from flask import Flask, render_template
app = Flask(__name__)
@app.route('/info/
def info(id):
# 在此处获取页面信息，例如从数据库中获取
# ...
page_info = get_page_info(id) # 假设是一个获取页面信息的函数
return render_template('info.html', info=page_info) # 渲染页面信息
HTML代码示例：
{{ info.title }}
{{ info.content }}
在这个HTML代码示例中，{{ info.title }}和{{ info.content }}会被替换为传递给模板的info对象的title和content属性的值。
前端HTML代码：
后端Flask代码：
from flask import Flask, request
app = Flask(__name__)
@app.route('/submit', methods=['POST'])
def submit():
username = request.form['username']
password = request.form['password']
# 在此处处理用户名和密码，例如验证用户名和密码，记录登录状态等
# ...
return '表单提交成功，用户名：%s，密码：%s' % (username, password)
重定向
在 Flask 中，我们可以使用 redirect() 函数来重定向用户到另一个端点。redirect() 函数的参数是新的 URL。
重定向通常用于用户提交表单或执行操作后，让用户返回到另一个页面。例如，用户登录后，我们可以将用户重定向到主页。
以下是一个重定向的例子：
from flask import Flask, redirect, url_for
app = Flask(__name__)
@app.route('/')
def index():
return redirect(url_for('login'))
@app.route('/login')
def login():
return 'This is the login page.'
在这个例子中，当用户访问首页（‘/’）时，他们会被重定向到登录页面。
url_for() 函数用于生成一个 URL，它接受端点名称（函数名）作为参数。在这个例子中，url_for('login') 会生成 ‘/login’。
我们也可以给 url_for() 函数传递更多的参数来生成更复杂的 URL。例如，url_for('user', name='John') 会生成 ‘/user/John’。
重定向是一个非常有用的功能，我们可以用它来引导用户完成特定的工作流程，或者在用户完成某些操作后将他们引导到不同的页面。
url_for()函数用于生成URL，其参数是端点名称（通常是视图函数名）。我们可以使用这个函数生成URL，然后通过redirect()函数来重定向到这个URL。
例如，我们有一个名为profile的视图，该视图接受一个参数username：
@app.route('/user/
def profile(username):
pass
我们可以使用url_for()函数生成这个视图的URL：
url_for('profile', username='John') # 输出：'/user/John'
然后，我们可以使用redirect()函数将用户重定向到这个URL：
from flask import redirect, url_for
@app.route('/login')
def login():
# 用户登录成功后，重定向到他们的个人资料页面
return redirect(url_for('profile', username='John'))
在这个例子中，当用户访问/login并成功登录后，他们会被重定向到/user/John。
我们还可以给url_for()函数传递更多的参数来生成更复杂的URL。这些参数将被转化为URL中的查询参数。例如：
url_for('search', q='flask tutorial') # 输出：'/search?q=flask+tutorial'
使用url_for()和redirect()函数，我们可以方便地在Flask应用中进行URL重定向。
make_response()函数在Flask中用于生成HTTP响应。您可以使用它来创建自定义的HTTP响应，包括设置HTTP头部信息、设置cookie等。
以下是一些make_response()的用法示例：
创建带有自定义状态码和头部信息的HTTP响应： from flask import Flask, make_response
app = Flask(__name__)
@app.route('/')
def index():
response = make_response('
This document carries a cookie!
')response.set_cookie('answer', '42')
return response
在这个示例中，make_response()函数创建了一个新的HTTP响应，包含一个HTML文本。然后，我们使用set_cookie方法在响应中设置了一个cookie。 创建带有自定义状态码的HTTP响应： from flask import Flask, make_response
app = Flask(__name__)
@app.route('/')
def index():
response = make_response('
Resource not found!
', 404)return response
在这个示例中，make_response()函数创建了一个新的HTTP响应，包含一个HTML文本和一个自定义的状态码404。
通过make_response()函数，我们可以灵活地创建各种自定义的HTTP响应。
在 Flask 中，我们可以使用 jsonify() 函数将字典或者列表转换为 JSON 格式，并返回给前端。以下是一个例子：
from flask import Flask, jsonify
app = Flask(__name__)
@app.route('/api/data')
def get_data():
data = {'name': 'John', 'age': 30, 'city': 'New York'}
return jsonify(data)
在这个例子中，我们定义了一个名为 /api/data 的 API 路由。当前端访问这个路由时，服务器会返回一个 JSON 数据。前端可以使用 AJAX 或者其他方法来获取并处理这个数据。
jsonify() 函数在内部使用了 json.dumps() 函数将 Python 对象转换为 JSON 格式。它还设置了 HTTP 响应的 MIME 类型为 application/json，这样前端就知道返回的数据是 JSON 格式。
注意：jsonify() 函数不能直接处理复杂的 Python 对象，例如自定义类的实例。如果你需要将这些对象转换为 JSON，你需要先将它们转换为可以序列化的基本数据类型，例如字典或者列表。
当然，以下是一个完整的 Flask 应用示例，它定义了一个 API 路由来返回 JSON 数据，并将 JSON_AS_ASCII 配置项设置为 False：
from flask import Flask, jsonify
app = Flask(__name__)
app.config['JSON_AS_ASCII'] = False # 设置 JSON_AS_ASCII 为 False
@app.route('/api/data')
def get_data():
data = {'name': '张三', 'age': 30, 'city': '北京'}
return jsonify(data)
if __name__ == '__main__':
app.run()
在这个例子中，我们定义了一个名为 /api/data 的 API 路由。当前端访问这个路由时，服务器会返回一个 JSON 数据。由于我们将 JSON_AS_ASCII 配置项设置为 False，所以返回的 JSON 数据中的非 ASCII 字符（例如中文字符）不会被转换为 Unicode 转义序列，从而避免了乱码问题。
前端可以使用 AJAX 或者其他方法来获取并处理这个数据。如果你的前端是 HTML 页面，你可以在
标签中添加以下元素来设置字符编码为 UTF-8，以确保前端正确地显示非 ASCII 字符：
在 Flask 中，我们可以使用 abort() 函数来中止一个请求并返回一个 HTTP 错误代码。例如，如果用户请求了不存在的页面，我们可以返回一个 404 错误。
以下是一个例子：
from flask import Flask, abort
app = Flask(__name__)
@app.route('/user/
def get_user(id):
user = get_user_from_database(id) # 假设是一个从数据库获取用户的函数
if not user:
abort(404) # 如果用户不存在，返回 404 错误
return 'Hello, %s' % user.name
在这个例子中，当用户访问 /user/
abort() 函数也接受一个可选的第二个参数，这个参数是一个错误消息。如果提供了这个参数，它将会被添加到 HTTP 错误页面中。
除了 404 错误，还有许多其他的 HTTP 错误代码，例如 400（Bad Request），401（Unauthorized），403（Forbidden），500（Internal Server Error）等。我们可以根据需要使用 abort() 函数来返回这些错误。
注意：虽然 abort() 函数可以帮助我们方便地处理错误，但我们应该尽可能地避免在代码中直接硬编码 HTTP 错误代码。在大多数情况下，我们应该定义自己的错误处理函数或者错误处理器，来处理应用中可能发生的各种错误。
Flask通过使用Jinja2模板引擎，允许我们在HTML模板中使用后端的变量。我们可以通过传递变量到render_template函数来实现这一点。
例如，假设我们有一个名为greet.html的模板，我们想在其中使用一个名为username的变量：
Hello, {{ username }}!
在这个模板中，{{ username }}是一个模板变量，它会被Flask替换为传递给模板的实际username变量的值。
然后，我们可以在Flask路由中使用render_template函数来渲染这个模板，并传递username变量：
@app.route('/greet/
def greet(username):
return render_template('greet.html', username=username)
在这个路由中，username参数是从URL中获取的，然后被传递给greet.html模板。因此，当我们访问像/greet/John这样的URL时，我们会看到一个显示"Hello, John!"的页面。
这就是Flask如何使用HTML模板，并在模板中使用后端的变量。
Jinja2模板引擎在Flask中提供了多种过滤器，可以用来修改和过滤模板变量。在模板中，我们可以使用管道符（|）来应用过滤器。
例如，{{ name|lower }}会将name变量的值转换为小写。{{ list|length }}会返回list变量的长度。{{ text|trim }}会去掉text变量的首尾空格。
我们也可以将多个过滤器链式使用。例如，{{ text|trim|lower }}会先去掉text变量的首尾空格，然后将结果转换为小写。
Jinja2提供了很多有用的过滤器，例如capitalize、round、escape等等。我们可以根据需要在模板中使用这些过滤器。
此外，我们还可以自定义过滤器。要定义一个过滤器，我们可以编写一个函数，然后通过app.template_filter()装饰器将这个函数注册为过滤器。例如：
@app.template_filter('reverse')
def reverse_filter(s):
return s[::-1]
在这个例子中，我们定义了一个名为reverse的过滤器，这个过滤器将字符串反转。然后，我们可以在模板中使用这个过滤器，例如{{ name|reverse }}。
例如，以下是一些Jinja2过滤器的使用例子：
safe：禁用自动转义。这可以用于输出HTML代码，例如： {{ html_content|safe }}
在这个例子中，html_content变量的值不会被转义，因此可以包含HTML标签。 capitalize：将字符串的第一个字符转换为大写，其他字符转换为小写。例如： {{ 'hello WORLD'|capitalize }}
length：返回一个字符串或者列表的长度。例如： {{ 'hello'|length }}
{{ [1, 2, 3]|length }}
round：将浮点数四舍五入到最接近的整数。也可以接受一个可选的参数来指定小数位数。例如： {{ 3.14159|round }}
{{ 3.14159|round(2) }}
trim：去掉字符串的首尾空格。例如： {{ ' hello world '|trim }}
list：将一个字符串转换为字符列表。例如： {{ 'hello'|list }}
以上只是Jinja2过滤器的一部分，还有许多其他的过滤器，例如upper、lower、title、escape等等。您可以根据需要使用这些过滤器来处理模板变量。
在 Flask 中，我们经常需要与数据库进行交互。无论是从数据库中读取数据，还是将数据保存到数据库中，我们都可以使用 Flask-SQLAlchemy 扩展来简化这个过程。
首先，我们需要创建一个 SQLAlchemy 实例：
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:tmp/test.db' # SQLite 数据库文件路径
db = SQLAlchemy(app)
数据库文件路径应按照以下格式填写：
对于 SQLite，格式为：'sqlite:absolute/path/to/database'。例如，如果你的数据库文件名为 mydb.db 并且位于 /tmp 目录下，那么你应该填写 'sqlite:tmp/mydb.db'。对于 MySQL，格式为：'mysql://username:password@localhost/db_name'。其中，username 和 password 是你的 MySQL 用户名和密码，db_name 是数据库名。对于 PostgreSQL，格式为：'postgresql://username:password@localhost/db_name'。其中，username 和 password 是你的 PostgreSQL 用户名和密码，db_name 是数据库名。
注意，以上路径中的 localhost 表示数据库服务器在本地机器上，如果数据库服务器在其他机器上，你需要将其替换为相应的 IP 地址或主机名。
SQLite 和 MySQL 是两种非常流行的开源数据库系统，都被广泛应用于网站和应用的开发。下面是它们的一些主要差异和特色：
SQLite 是一个无服务器的数据库，它将整个数据库（包括数据、表结构和索引等）存储在一个单独的文件中，非常适合于小型应用，如桌面应用和小型网站。而 MySQL 是一个完整的数据库管理系统，适合于大型应用和高并发的网站。SQLite 的安装和配置非常简单，只需要一个库文件即可运行。而 MySQL 的安装和配置需要更多的步骤和知识。SQLite 支持的 SQL 功能较少，例如它不支持存储过程和视图。而 MySQL 支持更多的 SQL 功能和标准。SQLite 在并发写入时的性能较差，因为它使用文件级的锁来控制并发。而 MySQL 使用更复杂的锁机制，可以支持更高的并发写入。SQLite 的内存占用非常小，适合于资源受限的环境。而 MySQL 的内存占用较大，但它提供了更多的缓存和优化选项。SQLite 对于嵌入式应用和移动应用非常友好，因为它不需要一个单独的数据库服务器。而 MySQL 通常需要一个单独的数据库服务器，但它可以在网络上提供服务，支持远程访问。
SQLAlchemy是Python编程语言的一个开源项目，提供了一整套高效且高度灵活的数据库抽象层表达式，包括关系对象映射（ORM）和SQL操作。它为应用程序员提供了全面的工具，以在简单和复杂场景中进行有效的SQL操作。SQLAlchemy的主要目标是实现宽松的SQL数据库的完全抽象化，而且它在此过程中几乎不牺牲性能。
然后，我们可以定义一个模型类来表示数据库中的表：
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 '
在这个模型类中，我们定义了三个字段：id、username和email。id字段是主键，每个用户都有一个唯一的id。username和email字段都是字符串类型，并且不允许为空。
然后，我们可以使用这个模型类来操作数据库。例如，我们可以创建一个新的用户并将其保存到数据库中：
user = User(username='John', email='john@example.com')
db.session.add(user)
db.session.commit()
我们也可以从数据库中查询用户：
user = User.query.filter_by(username='John').first()
Flask-SQLAlchemy 提供了丰富的功能来操作数据库，包括基本的 CRUD 操作、事务管理、模型关系等。通过使用 Flask-SQLAlchemy，我们可以大大简化数据库操作的代码，使其更易于理解和维护。
推荐链接
发表评论