title: flask框架整合大全（一）
date: 2023-01-29 19:40:56
tags:
- 框架应用
category:
- 后端

Flask是一个轻量级的Web框架，它是用Python编写的。它具有极高的灵活性和可扩展性, 它提供了一组基本的构建Web应用程序所需的工具。 Flask没有许多Django和Spring Boot提供的内置功能，因此它更适合用于小型项目或快速原型开发。开发人员可以根据项目需求自行选择和添加所需的第三方库。

安装

pip install Flask

引入

from flask import Flask

快速入门

创建一个名为Hello.py的文件，并在其中输入以下代码：

from flask import Flask
app = Flask(__name__)

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

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

在命令行中运行以下命令来启动应用程序

python Hello.py

shell中的出现一下字符证明开启成功：

* Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

这是一个最简单的flask应用程序, 通过@app.route装饰器创建路由并在函数中返回字符串 "Hello, World!" ,这样你就可以使用Flask开始构建你自己的Web应用程序了。

Web开发常见概念

在进行flask学习前，需要搞明白web开发中的常见概念，它们构成了一个完整的 Web 应用。

请求（Request）

请求（Request）是指用户向服务器发出的请求。在 Web 开发中，请求一般是通过 HTTP 协议发出的。用人话来说，就是在浏览器中输入网址，并按下enter键后，用户就对服务器进行了一次请求。

一个请求通常由请求报文（Request Message）和请求头（Request Header）组成，请求报文中包含了请求的方法（如 GET、POST）、URL 和数据等内容，请求头中包含了关于请求的附加信息，如客户端的类型、请求的来源等。

当服务器收到请求时，会根据请求的内容进行处理，并将处理结果以响应（Response）的形式返回给用户。此时用户才可以在网页中看到相应的内容。

控制器（Controller）

控制器（Controller）用于处理用户请求并执行相应的操作。控制器会读取用户请求，并调用相应的视图或模型来处理请求。在浏览器中输入url后，浏览器提交请求到服务器中，此时服务器中的函数开始向数据库进行数据获取，该函数则是控制器。

视图（View）

视图（View）是一种控制器（Controller）的设计模式，用于处理用户请求并将数据展示给用户。视图负责呈现数据，它会根据控制器传入的数据来渲染页面。视图通常会使用模板来渲染页面，并将渲染结果返回给控制器。

模板（Template）

模板（Template）是一种描述如何展示数据的语言。模板可以包含文本、HTML 标记和变量，用于描述数据如何被展示。模板引擎会将模板和数据结合起来，生成实际的 HTML 页面。

模板实际上就是html，只是被动态修饰的html

静态文件

静态文件是指在网站中固定的文件，例如图像、CSS 样式表、JavaScript 脚本和字体等。这些文件通常不会改变，或者变化非常少。由于静态文件通常不需要在服务器端进行任何处理，因此可以直接返回给客户端。

路由（Routing）

是指将用户请求与视图或控制器关联起来的过程。路由器会读取用户请求的 URL，并将其映射到对应的视图或控制器。浏览器中的网址就是路由

模型（Model）

是一种设计模式，用于表示数据和业务逻辑。模型会读取和保存数据，并执行相应的业务逻辑。它是与数据库直接交互的一个设计模式

中间件（Middleware）

是一种设计模式，用于在视图和控制器之间执行额外的处理。中间件可以用来实现认证、鉴权、日志记录等功能。

对象关系映射ORM（Object Relation Mapping）

ORM 是一种将面向对象编程语言的对象与关系数据库的表之间的映射的技术。它的目的是在数据库与应用程序之间提供一种简单的、透明的映射方法，使得开发人员可以以面向对象的方式编写代码，而不必编写 SQL 语句。

调试模式

当应用程序正在开发中时，应该为代码中的每个更改手动重新启动它，这样就会非常的不方便。

如果代码更改，服务器将自行重新加载，这种方式也称热启动。它还将提供一个有用的调试器来跟踪应用程序中的错误。在运行或将调试参数传递给run()方法之前，通过将application对象的debug属性设置为True来启用Debug模式。

app.debug = True
app.run()
app.run(debug = True)

路由构建

现代Web框架使用路由技术来帮助用户记住应用程序URL，也就是在浏览器中的地址栏中输入的url，即是web中的路由。

Flask中的route()装饰器用于将URL绑定到函数。例如：

@app.route('/hello')
def hello_world():
    return 'Hello, World!'

/ hello规则绑定到hello_world()函数，如果用户访问http://localhost:5000/hello，hello_world()函数的输出将在浏览器中呈现。当然，装饰器也可以用add_url_rule实现将URL与函数绑定的操作，上面的例子转换如下：

def hello_world():
   return 'hello world'
app.add_url_rule('/', 'hello', hello_world)

变量规则

url不仅仅是可以在视图函数中定义，也可以用户动态定义的，通过向规则参数添加变量部分，可以动态构建URL。

在路由中，可以使用形参来捕获 URL 中的动态变量。

from flask import Flask
app = Flask(__name__)

@app.route('/hello/<name>')
def hello_name(name):
    return f'Hello, {name}!'

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

因此，如果在浏览器中输入http://localhost:5000/hello/john作为URL，则john将作为参数提供给hello_name()函数。

除了默认字符串变量部分之外，还可以使用以下数据类型参数：

int：整数参数
float：浮点数参数
path：目录分隔符的斜杠

URL构建

有这样一个场景，若网址有两个权限，一个是管理员，一个是用户，如果输入admin，则进入管理员页面，输入其他的url，则进入游客界面，可以用url_for()函数，url_for()函数对于动态构建特定函数的URL非常有用。

url_for()函数接受函数的名称作为第一个参数，以及一个或多个关键字参数，每个参数对应于URL的变量部分。

以下DEMO演示了如何使用url_for()函数：

from flask import Flask, redirect, url_for
app = Flask(__name__)
@app.route('/admin')
def admin_page():
   return 'Admin Page Successful！'


@app.route('/<guest>')
def guest_page(guest):
   return f'Hello {guest} as Guest'


@app.route('/<name>')
def user_request(name):
   if name =='admin':
      return redirect(url_for('admin_page')) # 重定向
   else:
      return redirect(url_for('guest_page', guest = name))


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

上述脚本有一个函数user_request(name)，它接受来自URL的参数的值。user_request(name)函数检查接收的参数是否与admin匹配。

如果匹配，则使用url_for()将应用程序重定向到admin_page()函数，否则重定向到guest_page()函数并将接收的参数作为guest参数传递给该函数的形参。

模板

首先配置模板文件所在文件夹，方法如下：

from flask import Flask

app = Flask(__name__)
app.template_folder = 'path/to/templates'

或者

app = Flask(__name__, template_folder='path/to/templates')

在项目下创建 templates 文件夹，用于存放所有模板文件，并在目录下创建一个模板文件 html 文件 hello.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
首页
</body>
</html>

创建视图函数，将该模板内容进行渲染返回，返回需要调用render_template函数，并将模板的名称输入到参数里面

from flask import Flask, render_template

app = Flask(__name__, template_folder='path/to/templates')

@app.route('/')
def index():
    return render_template('hello.html')

模板变量

当html中需要动态展示数据库中的数据时，就需要使用flask将参数传入到模板中，使用方法如下:

在 Flask 程序中导入 render_template 方法
在视图函数中，调用 render_template 方法并将模板变量作为参数传入
在 HTML 模板中，使用双大括号{{ }}来表示在该位置展示该变量的值；使用大括号加%符号{% %}来执行控制逻辑，例如：循环，判断等。

例子：

from flask import Flask, render_template

app = Flask(__name__, template_folder='path/to/templates')

@app.route('/')
def index():
    # 往模板中传入的数据
    my_str = 'Hello Word'
    my_int = 10
    my_array = [3, 4, 2, 1, 7, 9]
    my_dict = {
        'name': 'xiaoming',
        'age': 18
    }
    return render_template('hello.html',
                           my_str=my_str,
                           my_int=my_int,
                           my_array=my_array,
                           my_dict=my_dict
                           )

模板中的代码：

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Title</title>
</head>
<body>
  展示内容：
  <br />{{ my_str }}
  <br />{{ my_int }}
  <br />{{ my_array }}
  <br />{{ my_dict }}
</body>
</html>

{{ }}也可以使用运算符和函数进行操作, 例如：

<p>The sum of 1 + 2 is {{ 1 + 2 }}</p>
<p>The current date is {{ datetime.now() }}</p>

{% %}的例子如下：

{% if name %}
  <h1>Hello {{ name }}</h1>
{% else %}
  <h1>Hello World</h1>
{% endif %}

静态文件

Flask 框架可以很容易地为静态文件配置一个 URL 前缀，并将其映射到一个文件夹中，这样就可以在网页中通过相对路径访问静态文件。

例如，如果你有一个文件夹 static，其中包含图像、CSS 样式表和 JavaScript 脚本，你可以使用下面的代码将其配置为静态文件：

app = Flask(__name__, static_folder='static')

这样就可以在网页中通过/static/前缀访问静态文件,例如:/static/images/logo.png

需要注意的是, 静态文件不应该放在应用程序代码文件的目录中，因为这些文件通常不需要被版本控制系统管理。应该将静态文件放在单独的文件夹中，并在应用程序中配置路径。

在下面的示例中，在index.html中的HTML按钮的OnClick事件上调用hello.js中定义的javascript函数，该函数在Flask应用程序的“/”URL上呈现。在下面的示例中，在index.html中的HTML按钮的OnClick事件上调用hello.js中定义的javascript函数，该函数在Flask应用程序的“/”URL上呈现。

from flask import Flask, render_template
app = Flask(__name__)

@app.route("/")
def index():
   return render_template("index.html")

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

模板文件如下：

<html>

   <head>
      <script type = "text/javascript" 
         src = "{{ url_for('static', filename = 'hello.js') }}" ></script>
   </head>
   
   <body>
      <input type = "button" onclick = "sayHello()" value = "Say Hello" />
   </body>
   
</html>

在static文件夹中的hello.js包含sayHello()函数。

function sayHello() {
   alert("Hello World")
}

返回值类型

flask一共有五种返回值，它们分别是：

字符串
redirect()重定向
render_template()界面渲染
send_file()文件
json

其中，字符串也可以手写html，它会在页面中显示相应的效果，例如：

@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        session['username'] = request.form['username']
        return redirect(url_for('index'))
    return """
        <form method="post">
            <input type="text" name="username">
            <input type="submit" value="Login">
        </form>
    """

在页面中，会显示以下html：

<form method="post">
    <input type="text" name="username">
    <input type="submit" value="Login">
</form>

Request对象

在 Flask 中，request 对象是用来访问请求信息的一个全局变量, 可以在视图函数中访问到。request 对象是一个 flask.wrappers.Request 类型的对象，它包含了客户端发送给服务器的请求信息, 包括请求的方法、请求的参数、请求的头信息、请求的数据等。

Request对象的重要属性如下所列：

Form - 它是一个字典对象，包含表单参数及其值的键和值对。
args - 解析查询字符串的内容，它是问号（？）之后的URL的一部分。
Cookies - 保存Cookie名称和值的字典对象。
files - 与上传文件有关的数据。
method - 当前请求方法。

举个例子：

from flask import Flask, render_template, request

app = Flask(__name__,template_folder="./")

@app.route('/')
def index():
    method = request.method
    args = request.args
    form = request.form
    headers = request.headers
    data = request.data
    return f'Method: {method}<br/><br/><br/>' \
           f'Args: {args}<br/><br/><br/>' \
           f'Form: {form}<br/><br/><br/>' \
           f'Headers: {headers}<br/><br/><br/>' \
           f'Data: {data}<br/><br/><br/>'

app.run(debug= True)

在上面的示例中, 我们通过 request.method 属性获取请求的方法(GET, POST, PUT, DELETE等), 通过 request.args 属性获取请求的参数, 通过 request.form 属性获取请求的表单数据, 通过 request.headers 属性获取请求的头信息, 通过 request.data 属性获取请求的数据.

将表单数据发送到模板

我们已经看到，可以在 URL 规则中指定 http 方法。触发函数接收的 Form 数据可以以字典对象的形式收集它并将其转发到模板以在相应的网页上呈现它。

在以下示例中，'/' URL 会呈现具有表单的网页（student.html）。

填入的数据会发布到触发 result() 函数的 '/result' URL。

result() 函数收集字典对象中的 request.form 中存在的表单数据，并将其发送给 result.html。

该模板动态呈现表单数据的 HTML 表格。

下面给出的是应用程序的 Python 代码：

from flask import Flask, render_template, request
app = Flask(__name__)
@app.route('/')
def student():
   return render_template('student.html')


@app.route('/result',methods = ['POST', 'GET'])
def result():
   if request.method == 'POST':
      result = request.form
      return render_template("result.html",result = result)


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

下面给出的是 student.html 的 HTML 脚本。

<form action="http://localhost:5000/result" method="POST">
     <p>Name <input type = "text" name = "Name" /></p>
     <p>Physics <input type = "text" name = "Physics" /></p>
     <p>Chemistry <input type = "text" name = "chemistry" /></p>
     <p>Maths <input type ="text" name = "Mathematics" /></p>
     <p><input type = "submit" value = "submit" /></p>
</form>

下面给出了模板（ result.html ）的代码：

<!doctype html>
  <table border = 1>
     {% for key, value in result.items() %}
    <tr>
       <th> {{ key }} </th>
       <td> {{ value }}</td>
    </tr>
 {% endfor %}
</table>

运行python脚本，在student.html中传入的form表单的内容体交后会被模板result.html接收到。

Restful

REST (Representational State Transfer) 是一种软件架构风格,它是一种在网络应用中的设计模式, 提供了一种简洁、高效的方式来实现Web服务.

RESTful 是指遵循REST风格的Web服务。RESTful服务使用标准的HTTP方法(GET, POST, PUT, DELETE等)来实现资源的创建、读取、更新、删除等操作。

在Flask中，你可以使用 @app.route() 装饰器来创建一个RESTful API，例如：

from flask import Flask, jsonify, request

app = Flask(__name__)

books = [
    {'id': 1, 'title': 'Book 1'},
    {'id': 2, 'title': 'Book 2'},
    {'id': 3, 'title': 'Book 3'},
]

@app.route('/books', methods=['GET'])
def get_books():
    return jsonify(books)

@app.route('/books/<int:id>', methods=['GET'])
def get_book(id):
    book = [book for book in books if book['id'] == id]
    return jsonify(book)

@app.route('/books', methods=['POST'])
def add_book():
    data = request.get_json()
    books.append(data)
    return jsonify(data), 201

@app.route('/books/<int:id>', methods=['PUT'])
def update_book(id):
    data = request.get_json()
    for book in books:
        if book['id'] == id:
            book.update(data)
            return jsonify(book)
    return jsonify({'error': 'Book not found'}), 404

@app.route('/books/<int:id>', methods=['DELETE'])
def delete_book(id):
    for book in books:
        if book['id'] == id:
            books.remove(book)
            return jsonify({'message': 'Book deleted'})
    return jsonify({'error': 'Book not found'}), 404

在这个例子中，我们使用了GET, POST, PUT, DELETE四种标准的 HTTP 方法来实现了对于书籍资源的增删改查操作，以及根据书籍 ID 获取特定书籍的操作。

在这些路由处理函数中，我们使用了Flask内置的 request 对象来获取客户端发送的数据。例如，在 add_book() 函数中，我们使用了 request.get_json() 方法来获取客户端发送的 JSON 数据。

同时，我们使用了 jsonify 函数来将服务器返回的数据转换为 JSON 形式。

Cookies

Cookie以文本文件的形式存储在客户端的计算机上。其目的是记住和跟踪与客户使用相关的数据，以获得更好的访问者体验和网站统计信息。

在 Flask 中，可以使用 response.set_cookie 方法设置Cookie，可以通过max_age设置有效期，单位是秒：

from flask import Flask, make_response

app = Flask(__name__)

@app.route('/')
def index():
    resp = make_response("Cookie set")
    resp.set_cookie('cookie_name', 'cookie_value', max_age=3600)
    return resp

可以使用 request.cookies 字典获取Cookie值：

from flask import Flask, request

app = Flask(__name__)

@app.route('/')
def index():
    cookie_value = request.cookies.get('cookie_name')
    return f"Cookie value: {cookie_value}"

可以使用 response.delete_cookie 方法删除Cookie：

from flask import Flask, make_response

app = Flask(__name__)

@app.route('/')
def index():
    resp = make_response("Cookie deleted")
    resp.delete_cookie('cookie_name')
    return resp

Cookie可以在浏览器中的网络菜单中查看到

Session

与Cookie不同，Session数据存储在服务器上。Session是客户端登录到服务器并注销服务器的时间间隔，需要在该会话中保存的数据会存储在服务器上的临时目录中，具有更多的安全性和灵活性。

Session 在 Flask 应用程序中的具体应用示例：

设置和读取 session：

from flask import Flask, session

app = Flask(__name__)
app.secret_key = 'secret_key'

@app.route('/')
def index():
    if 'username' in session:
        return "Logged in as {}".format(session['username'])
    return "You are not logged in"

@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        session['username'] = request.form['username']
        return redirect(url_for('index'))
    return """
        <form method="post">
            <input type="text" name="username">
            <input type="submit" value="Login">
        </form>
    """

在上面的代码中，当用户登录时，将其用户名存储到 session 中，然后重定向到首页；当用户请求首页时，如果已经登录，则显示用户名；否则显示 "You are not logged in"。

删除 session：

from flask import Flask, session, redirect, url_for

app = Flask(__name__)
app.secret_key = 'secret_key'

@app.route('/')
def index():
    if 'username' in session:
        return "Logged in as {}".format(session['username'])
    return "You are not logged in"

@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        session['username'] = request.form['username']
        return redirect(url_for('index'))
    return """
        <form method="post">
            <input type="text" name="username">
            <input type="submit" value="Login">
        </form>
    """

@app.route('/logout')
def logout():
    session.pop('username', None)
    return redirect(url_for('index'))

在上面的代码中，当用户请求 "/logout" 时，使用 session.pop 方法删除 "username" session，然后重定向到首页。

永久存储session

session 数据在浏览器关闭后将丢失，如果要永久保存 session，可以使用 Flask-Session 扩展。 Flask-Session 可以将 session 数据存储到服务器端，而不是客户端，以防止数据丢失。

首先，安装 Flask-Session：

pip install Flask-Session

然后，可以在代码中使用 Flask-Session：

from flask import Flask, session
from flask_session import Session

app = Flask(__name__)
app.secret_key = 'secret_key'

# Use Flask-Session to store session data on the server
Session(app)

# Your code here...

这样，当用户存储到 session 中的数据将永久保存，直到删除或过期。

重定向与终止请求

重定向是在服务器端请求 URL 转移到另一个 URL 的过程。在 Flask 中，可以使用 redirect 函数实现重定向。

redirect()函数的参数如下：

Flask.redirect(location, statuscode, response)

形参解释：

location参数是应该重定向响应的URL。
statuscode发送到浏览器标头，默认为302。
response参数用于实例化响应。

redirect()简单的应用如下：

from flask import Flask, redirect, url_for

app = Flask(__name__)

@app.route('/')
def index():
    return 'Welcome to the Homepage'

@app.route('/login')
def login():
    return 'Login Page'

@app.route('/admin')
def admin():
    return redirect(url_for('index'))

当需要终止请求处理并返回 HTTP 错误码，可以使用Flask.abort(code)函数，该函数接收一个整数类型的参数 code，表示要返回的 HTTP 错误码。详细的HTTP错误码如下：

400 - 用于错误请求
401 - 用于未身份验证的
403 - Forbidden
404 - 未找到
406 - 表示不接受
415 - 用于不支持的媒体类型
429 - 请求过多

以下是一个使用 abort 函数的示例：

from flask import Flask, abort

app = Flask(__name__)

@app.route('/')
def index():
    return 'Welcome to the Homepage'

@app.route('/admin')
def admin():
    abort(401)

在上面的代码中，当用户访问 /admin 路由时，将返回 HTTP 401 Unauthorized 错误。

abort 函数可以用于在缺少必要参数、用户未登录等情况下终止请求处理并返回 HTTP 错误。

消息闪现

Flask 消息闪现是一种在请求之间存储、显示的消息的技术。它常用于提示用户已成功执行某项操作或显示错误信息等。

可以使用 Flask 提供的 flash 函数来存储消息，并在模板中显示消息。要使用 flash 函数，需要先安装 Flask-Flash 模块：

pip install Flask-Flash

flash 函数参数如下：

flash(message, category)

其中，

message 参数是要闪现的实际消息。
category 参数是可选的。它可以是“error”，“info”或“warning”。

以下是一个使用 flash 函数的示例：

from flask import Flask, flash, redirect, render_template, request

app = Flask(__name__)
app.secret_key = 'secret_key'

@app.route('/')
def index():
    flash('Welcome to the Homepage')
    return render_template('index.html')

@app.route('/login', methods=['POST', 'GET'])
def login():
    if request.method == 'POST':
        if request.form['username'] == 'admin':
            flash('Login Successful')
            return redirect(url_for('index'))
        else:
            flash('Login Failed')
            return redirect(url_for('login'))
    return render_template('login.html')

在模板中，可以使用 get_flashed_messages 函数来显示并清理闪现的消息：

<!DOCTYPE html>
<html>
    <head>
        <title>Flask Message Flash</title>
    </head>
    <body>
        \{\% for message in get_flashed_messages() \%\}
            <p>\{\{ message \}\}</p>
        \{\% endfor \%\}
        <form action="\{\{ url_for('login') \}\}" method="post">
            <input type="text" name="username" placeholder="Enter username">
            <input type="submit" value="Submit">
        </form>
    </body>
</html>

文件上传

当用户在 HTML 表单中选择并上传文件时，它会发送到服务器端。为了处理文件上传，请在 HTML 表单中使用一个文件输入字段，还需要设置表单的enctype属性为multipart/form-data，以指示表单包含文件数据。

在 Flask 中，可以使用 request.files 字典来访问上传的文件。以下是 Flask 中实现文件上传的示例：

upload.html代码：

<html>
<head>
  <title>File Upload</title>
</head>
<body>
    <form action="http://localhost:5000/upload" method="POST" enctype="multipart/form-data">
        <input type="file" name="file"  />
        <input type="submit" value="提交" />
    </form>
</body>
</html>

flask：

from flask import Flask, request, render_template

app = Flask(__name__)

@app.route('/')
def index():
    return render_template('upload.html')

@app.route('/upload', methods=['POST'])
def upload():
    file = request.files['file']
    if file:
        file.save(file.filename)
        return 'File uploaded successfully'
    else:
        return 'No file found'

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

在上面的代码中，index 视图返回了一个上传文件的 HTML 表单，而 upload 视图处理了用户提交的文件。在 upload 视图中，首先通过 request.files 字典访问文件，然后使用 save 方法将文件存储在磁盘上。

Flask-SQLAlchemy

在Flask Web应用程序中使用原始SQL对数据库执行CRUD操作可能很繁琐。Python工具包SQLAlchemy是一个强大的数据库操作库，它为应用程序开发人员提供了SQL的全部功能和灵活性。

Flask-SQLAlchemy是一个为Flask提供的SQLAlchemy的扩展。SQLAlchemy是一个开源的关系型数据库映射工具，提供了一个高效的 ORM 系统。Flask-SQLAlchemy为Flask提供了一个简单易用的接口，用于操作数据库。

使用Flask-SQLAlchemy可以实现以下功能：

简化数据库配置
定义数据模型（可以通过类的方式定义数据表）
数据库查询（支持复杂的查询）
数据库的CRUD操作
支持自动创建数据表（如果不存在）

因此，Flask-SQLAlchemy是 Flask 开发者进行数据库操作的首选工具之一。

要使用Flask-SQLAlchemy，需要执行以下命令安装它：

pip install flask-sqlalchemy

使用Flask-SQLAlchemy进行数据库操作需要以下几步：

创建一个SQLAlchemy实例：可以在Flask应用程序中创建一个SQLAlchemy实例，代码如下：

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///test.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 '<User %r>' % self.username

创建数据表：可以使用Flask-SQLAlchemy的db.create_all()方法创建数据表。

Flask-SQLAlchemy提供了多种数据库操作方法，具体操作如下：

增加数据：使用db.session.add()方法增加数据，代码如下：

user = User(username='john', email='john@example.com')
db.session.add(user)
db.session.commit()

查询数据：使用db.session.query()方法查询数据，代码如下：

# 查询所有用户
users = User.query.all()
# 查询第一个用户
user = User.query.first()
# 根据条件查询
user = User.query.filter_by(username='john').first()

修改数据：修改数据需要先查询出数据再修改，代码如下：

user = User.query.filter_by(username='john').first()
user.email = 'john_new@example.com'
db.session.commit()

删除数据：使用db.session.delete()方法删除数据，代码如下：

user = User.query.filter_by(username='john').first()
db.session.delete(user)
db.session.commit()