Flask 基础（二）

持续创作，加速成长！这是我参与「掘金日新计划 · 6 月更文挑战」的第25天，点击查看活动详情

声明变量

{% set username='zhangsan' %}
{{ username }}


{% with num=1000 %}
{{ num }}
#可以使用
{% endwith %}
{{ num }}
#不可使用

总结：

#变量：
{{ 变量 }}

#块：
{% if 条件 %}...{% endif %}
{% for 条件 %}...{% endfor %}
{% block name %}...{% endblock%}
{% macro 条件 %}...{% endmacro %}

{% include '' %}  包含文件
{% import '' %}  导入宏
{% extends '' %}  继承

{{ url_for('static',filename=' ' ) }}
{{ marconame(xxx) }}

#view:
@app.route('/',endpoint='',method=['GET','POST'])
def index():
    return response/''/render_template('xxx.html')

蓝图

回顾类 self

blog.csdn.net/xrinosvip/a…

init 方法的第一个参数永远是 self ，表示创建的实例本身，因此，在 init 方法的内部，就可以把各种属性绑定到 self，因为 self 就指向创建的 实例本身

拆分app.py

将 app.py 文件按功能进行拆分

apps

__init__.py包的初始化文件

from flask import Flask

import settings

def create_app():
    app = Flask(__name__)  #app是一个核心对象
    app.config.from_object(settings)

    return app

app.py

from apps import create_app

app = create_app()

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

蓝图和视图

视图是一个应用对请求进行相应的函数，Flask 通过模型把进来的请求 URL 匹配到对应的处理视图。试图返回数据，Flask 把数据变成出去的响应。Flask 也可以反过来，根据视图的名称和参数生成 URL

蓝图 Blueprint 是一种组织一组相关视图及其他代码的方式。与把视图及其他代码直接注册到应用的方式不同，蓝图方式是把他们注册到蓝图，然后到工厂函数中把蓝图注册到应用。

蓝图是路由的一种表现方式

例，简单蓝图

用户信息注册，更新，删除功能实现

app.py

from apps import create_app

app = create_app()

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

setting.py

ENC = 'development'
DEBUG = True

apps/__init__.py

实现了把 app.py 功能拆分，导入配置文件，注册蓝图函数

from flask import Flask
import settings
from apps.user.view import user_bp


def create_app():
    app = Flask(__name__, template_folder='../templates', static_folder='../templates')
    # app是一个核心对象
    # 用这种写法，因为 app 是在 apps/user 目录创建所以默认 templates static等目录 实在同级，所以需要手动指定
    app.config.from_object(settings)

    app.register_blueprint(user_bp)
    # 将app.user.view user_bp蓝图注册到app.py
    print(app.url_map)

    return app

apps/user/view.py

实现：创建蓝图对象，路由，视图函数，整个逻辑功能实现

from flask import Blueprint, render_template, request, redirect, url_for

from apps.user.model import User

user_bp = Blueprint('user', __name__)
# 创建蓝图对象 user_bp

users = []
#对象列表

@user_bp.route('/')
def user_center():
    return render_template('user/show.html', users=users)


@user_bp.route('/del')
def delete():
    username = request.args.get('username')
    # 从url中获取 username 的值
    for user in users:
        if user.username == username:
            users.remove(user)
            return redirect('/')
        else:
            return 'username is not exist'


@user_bp.route('/register', methods=['GET', 'POST'])
def user_register():
    if request.method == 'POST':
        # post 提交数据
        username = request.form.get('username')
        password = request.form.get('password')
        repassword = request.form.get('repassword')
        phone = request.form.get('phone')

        if password == repassword:
            for user in users:
                # 遍历判断用户名是否存在
                if user.username == username:
                    return render_template('user/register.html', msg='username is exist')
            user = User(username, password, phone)
            # 创建 user 对象
            users.append(user)
            # 添加到用户列表 users
            return redirect('/')
            # 此处添 路由 不是页面
        else:
            return 'password is different'
    return render_template('user/register.html')


@user_bp.route('/update', methods=['GET', 'POST'], endpoint='update')
def user_update():
    if request.method == 'POST':
        #此处 POST 必须为大写 GET、POST尽量都是大写
        realname = request.form.get('realname')
        username = request.form.get('username')
        password = request.form.get('password')
        phone = request.form.get('phone')
        for user in users:
            if realname == user.username:
                user.username = username
                user.password = password
                user.phone = phone
                return redirect('/')
    else:
        old_username = request.args.get('username')
        for user in users:
            if old_username == user.username:
                return render_template('user/update.html', user=user, msg='update is ok')
            else:
                return 'username is not register'


@user_bp.route('/login', methods=['get', 'post'])
def user_login():
    return 'user_login'


@user_bp.route('/logout', methods=['get', 'post'])
def user_logout():
    return 'user_logout'

apps/user/model.py

class User:
    def __init__(self, username, password, phone=None):
        self.username = username
        self.password = password
        self.phone = phone
#此例用对象实现，没有使用数据库

templates/base.html

父模板

<!--页面不变的地方写上，变的地方挖坑-->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>{% block title %}user center{% endblock %}</title>

    <style>
        #head{
            background-color: cadetblue;
            width: 100%;
            height: 50px;
            border-color: aquamarine;
        }
        #head ul{
            list-style: none;
            height: 50px;
        }
        #head ul li{
            width:20%;
            float: left;
            text-align: center;
            font-size: medium;
            line-height: 50px;
        }
        #middle{
            height: 500px;
        }
        {% block mycss %}

        {% endblock %}
    </style>


</head>

<body>


<div id="head">
    <ul>
        <li>user center<li>
        <li>shopping</li>
        <li>browser</li>
        <li>going</li>
        <li>order</li>
    </ul>
</div>


<div id="middle">
    {% block middle %}

    {% endblock %}
</div>


<div id="foot">
    <ul>
        <li>aaa<li>
    </ul>
</div>


{% block myjs %}

{% endblock %}
</body>
</html>

templates/user/register.html

{% extends 'base.html' %}


{% block title %}
user register
{% endblock %}


{% block mycss %}
        #head{
            background-color: red;
            width: 100%;
            height: 50px;
            border-color: aquamarine;
        }
{% endblock %}

{{ msg }}
{% block middle %}
    
{# 快捷写法from*1>p*5>input*1 #}
    
    <form action="/register" method="post" >
<!--<form action="{{ url_for('user.user_register') }}" method="post" > 推荐使用-->
        <p><input type="text" name="username" placeholder="username"></p>
        <p><input type="password" name="password" placeholder="password"></p>
        <p><input type="password" name="repassword" placeholder="re again"></p>
        <p><input type="number" name="phone" placeholder="phone"></p>
        <p><input type="submit" value="submit"> </p>
    </form>
{% endblock %}


{% block myjs %}

    <script>
    btn=document.getElementById('submit')
    btn.onclick=function ()
    {
        alert('next very good')
    }
    </script>
{% endblock %}

templates/user/show.html

{% extends 'base.html' %}

{% block title %}
show
{% endblock %}

<h1>用户信息</h1>
<span>
    当前用户人数{{ users |length }}
</span>
{% block middle %}
    <table border="1" cellspacing="0">
    {% for user in users %}
        <tr>
            <td>{{ loop.index }}</td>
            <td>{{ user.username }}</td>
            <td>{{ user.password }}</td>
            <td>{{ user.phone }}</td>
            <td><a href="">change</a> <a href="javascript:;" onclick="del('{{ user.username }}')">delete</a></td>
            {# a 标签默认点击走 href ，使用JavaScript:;停用                 del('要删除的内容') #}
        </tr>
    {% endfor %}
    </table>
{% endblock %}

{% block myjs %}
<script>
    function del(username){
        location.href='/del?username='+username
        #相当于浏览器地址栏ip地址加端口拼接上字符串并跳转
    }
</script>
{% endblock %}

templates/user/update.html

{% extends 'base.html' %}

{% block title %}
user_update
{% endblock %}

{% block middle %}
    <h1>{{ msg }}</h1>
    <form action="{{ url_for('user.update') }}" method="post">
        {# p*5>input #}
        <p><input type="hidden" name="realname" value="{{ user.username }}"></p>
        {# 直接更改 username 就没法坐后边的查寻了 #}
        <p><input type="text" name="username" placeholder="username" value="{{ user.username }}"></p>
        {# placeholder相当于提示是鼠标单击输入框就消失了，value相当于是默认值是可以在此基础上更改 #}
        <p><input type="password" name="password" value="{{ user.password }}"></p>
        <p><input type="number" name="phone" value="{{ user.phone }}"></p>
        <p><input type="submit"></p>
    </form>
{% endblock %}

蓝图url_for

1. 使用endpoint 蓝图名.endpoint

2. 使用 蓝图名.视图函数名 作为 url_for() 内容

   view.py创建蓝图

   user_bp = Blueprint('user', __name__)
   # 创建蓝图对象 user_bp, user为蓝图名
   

   使用 url_for('蓝图名.视图函数名')

   @user_bp.route('/')
   def user_center():
   	print(url_for('user.user_register'))
             #url_for('蓝图名.视图函数名')
   
   @user_bp.route('/register', methods=['GET', 'POST'])
   def user_register():
       return 'ok'
   
   输出：/register
   

Model 模型

Flask-Script

让命令行支持自定义命令的工具，它为 Flask 程序添加一个命令行解释器，可以让我们的程序从命令行直接执行相应命令

• 安装：

  pip install flask-script

• 引入：

  manager 实例

  from flask_script import Manager

  manager = Manager(app = app)

  manager.run()

  #完整app.py
  from flask_script import Manager
  
  from apps import create_app
  
  app = create_app()
  manager = Manager(app=app)
  
  if __name__ == '__main__':
      manager.run()
  

• 启动

  终端：python app.py runserver -p 端口 -h 主机

• 自定义命令

  @manager.command()
  def init():
      print('aaaa')
      
  #终端 python app.py init
  

数据库

• 关系型

  关系型数据库：指采用了关系模型来组织数据的数据库。 关系模型指的就是二维表格模型，而一个关系型数据库就是由二维表及其之间的联系所组成的一个数据组织。

• 非关系型

  非关系型数据库：指非关系型的，分布式的，且一般不保证遵循ACID原则的数据存储系统。

  非关系型数据库结构：

  非关系型数据库以键值对存储，且结构不固定，每一个元组可以有不一样的字段，每个元组可以根据需要增加一些自己的键值对，不局限于固定的结构，可以减少一些时间和空间的开销。

  www.jianshu.com/p/fd7b422d5…

  数据持久化使用关系型数据库

ORM 对象关系映射

ORM 将数据库中的表与面向对象语言中的类建立了一种对应关系，这样，操作数据库，数据库中的表或者表中的一条记录就可以直接通过操作类或者类实例来完成

SQLAlchemy 是 python 社区最知名的 ORM 工具之一，为高效和高性能的数据库访问设计，实现了完整的企业级持久模型

flask-sqlalchemy 是基于SQLAIchemy，做了提升，更方便使用

• 安装pymysql 建工路

  pip install pymysql

• 安装flask-sqlalchemy 实现ORM映射

  pip install flask-sqlalchemy -i pypi.tuna.tsinghua.edu.cn/simple

• pip install flask-migrate 发布命令工具

  SQLAlchemy作者开发数据迁移工具

1.配置数据库链接文件

1.设置数据库配置文件，连接sqlalchemy

SQLALCHEMY_DATABASE_URI='mysql+pymysql://root:root@127.0.0.1:3306/flask'

格式：数据库+驱动://user:password@hostip:port/database_name?charset=utf-8

提前设置数据库 create database flask charset=utf-8

其他配置：

配置选项	说明
* SQLALCHEMY_DATABASE_URI	连接数据库。示例：mysql://username:password@host/post/db?charset=utf-8
SQLALCHEMY_BINDS	一个将会绑定多种数据库的字典。 更多详细信息请看官文 绑定多种数据库.
* SQLALCHEMY_ECHO	调试设置为true
SQLALCHEMY_POOL_SIZE	数据库池的大小，默认值为5。
SQLALCHEMY_POOL_TIMEOUT	连接超时时间
SQLALCHEMY_POOL_RECYCLE	自动回收连接的秒数。
SQLALCHEMY_MAX_OVERFLOW	控制在连接池达到最大值后可以创建的连接数。当这些额外的 连接回收到连接池后将会被断开和抛弃。
* SQLALCHEMY_TRACK_MODIFICATIONS	如果设置成 True (默认情况)，Flask-SQLAlchemy 将会追踪对象的修改并且发送信号。这需要额外的内存， 如果不必要的可以禁用它。

一般设置标星三项就可以

# settings.py 文件

class Config:
    SQLALCHEMY_DATABASE_URI = 'mysql+pymysql://root:root@127.0.0.1:3306/flask'
    SQLALCHEMY_TRACK_MODIFICATIONS= False
    SQLALCHEMY_ECHO = True


class DevelopmentConfig(Config):
    #继承 Config 类
    #定义开发环境配置
    ENC = 'development'
    DEBUG = True


class ProductionConfig(Config):
    #单独定义生产环境配置
    #这样在user/__init__.py下使用    app.config.from_object(settings.DevelopmentConfig)
    ENC = 'production'
    DEBUG = False

2.实现映射

第二种方法：

创建包 ext

__init__.py中添加：

db = SQLAlchemy() 必须跟app联系

#ext/__init__.py
#创建一个映射对象
from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy()

apps/__init__.py

def create_app():
    ......
    db.init_app(app)
    ......

3.migrate

app.py

from flask_migrate import Migrate, MigrateCommand
from flask_script import Manager

from apps import create_app, db

app = create_app()
manager = Manager(app=app)

#命令工具
migrate = Migrate(app=app, db=db)

manager.add_command('db', MigrateCommand)


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

(flask) C:\Users\q2723\PycharmProjects\flaskProject1>python app.py
Map([<Rule '/register' (OPTIONS, POST, GET, HEAD) -> user.user_register>,
 <Rule '/update' (OPTIONS, POST, GET, HEAD) -> user.update>,
 <Rule '/logout' (OPTIONS, POST, GET, HEAD) -> user.user_logout>,
 <Rule '/login' (OPTIONS, POST, GET, HEAD) -> user.user_login>,
 <Rule '/del' (OPTIONS, GET, HEAD) -> user.delete>,
 <Rule '/' (OPTIONS, GET, HEAD) -> user.user_center>,
 <Rule '/templates/<filename>' (OPTIONS, GET, HEAD) -> static>])
usage: app.py [-?] {db,shell,runserver} ...

positional arguments:
  {db,shell,runserver}
    db                  Perform database migrations
    shell               Runs a Python shell inside Flask application context.
    runserver           Runs the Flask development server i.e. app.run()

optional arguments:
  -?, --help            show this help message and exit
  
  
 (flask) C:\Users\q2723\PycharmProjects\flaskProject1>python app.py db --help

4.创建模型

models.py

模型就是类

from datetime import datetime

from apps import db
#如果导入库的这一行在 pycharm 中为灰色说明没有用到

class User(db.Model):
    id = db.Column(db.Integer,primary_key=True,autoincrement=True)
    #设为主键，自动补充
    username=db.Column(db.String(15),nullable=False)
    #不能为空
    username=db.Column(db.String(15),nullable=False)
    #不能为空
    phone=db.Column(db.String(12),unique=True)
    #值不能重复
    phone=db.Column(db.DateTime,default=datetime.now)
    #default 为默认值 datetime.now 没有()

5.使用命令

• ***** 在 app.py 中导入模型，必须导入

  from apps.user.models import User

• 终端中使用命令：db

  1.python app.py db init

  会产生一个文件夹 migrations，一个项目只需要执行一次

  

  2.python app.py db migrate

  每执行一次自动产生了一个版本文件，方便降级(downgrade)

  

  3.python app.py db upgrade 同步到数据库

  若文件有修改则只需执行2、3两步

pycharm数据库窗口

界面右侧 database -> 加号 -> DateSource -> 选择数据库

填写数据，test，如果有提示，则点击下方 set time zone 再进行连接

例：用户注册写入数据库

app.py

from flask import Flask
from flask_migrate import Migrate, MigrateCommand
from apps.user.model import User
from flask_script import Manager
from apps import create_app
from ext import db

app = create_app()
manager = Manager(app=app)

migrate = Migrate(app=app, db=db)
manager.add_command('db', MigrateCommand)

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

setting.py

class Config:
    SQLALCHEMY_DATABASE_URI = 'mysql+pymysql://root:root@127.0.0.1:3306/flask'
    SQLALCHEMY_TRACK_MODIFICATIONS = False
    SQLALCHEMY_ECHO = True


class DevelopmentConfig(Config):
    # 继承 Config 类
    # 定义开发环境配置
    ENC = 'development'
    DEBUG = True


class ProductionConfig(Config):
    # 单独定义生产环境配置
    # 这样在user/__init__.py下使用    app.config.from_object(settings.DevelopmentConfig)
    ENC = 'production'
    DEBUG = False

apps/__init__.py

from flask import Flask
import settings
from apps.user.view import user_bp
from ext import db


def create_app():
    app=Flask(__name__, template_folder='../templates', static_folder='../static')
    app.config.from_object(settings.DevelopmentConfig)
    #初始化配置db
    db.init_app(app=app)
    app.register_blueprint(user_bp)
    return app

apps/user/model.py

from datetime import datetime

from ext import db


class User(db.Model):
    id =db.Column(db.Integer,primary_key=True, autoincrement=True)
    username = db.Column(db.String(15),nullable=False)
    password = db.Column(db.String(15), nullable=False)
    phone = db.Column(db.String(15), nullable=False,unique=True)
    rdatatime = db.Column(db.DateTime, default=datetime.now())

    def __str__(self):
        return self.username

apps/user/view.py

from flask import Blueprint, request, render_template, redirect, url_for

from apps.user.model import User
from ext import db

user_bp = Blueprint('user', __name__)


@user_bp.route('/')
def index():
    return 'index'

@user_bp.route('/register', methods=['GET', 'POST'],endpoint='register')
def register():
    if request.method == 'POST':
        username = request.form.get('username')
        password = request.form.get('password')
        repassword = request.form.get('repassword')
        phone = request.form.get('phone')
        if password == repassword:
            user = User()
            # 与模型相结合
            # 1.找到模型类并创建对象

            user.username = username
            user.password = password
            user.phone = phone
            # 2.给对象的属性赋值

            db.session.add(user)
            # 添加
            # 3.将user对象添加到session中（类似于缓存）

            db.session.commit()
            # 4.提交数据
            return 'ok'

    else:
        return render_template('user/register.html')

ext/__init__.py

from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy()

templastes和之前写的一样

数据加密

md5 sha1 sha256 sha512

import hashlib

str = 'helloworld'

md5 = hashlib.md5(str.encode('utf-8')).hexdigest()
print("md5  {}  len:{}".format(md5, len(md5)))

sha1 = hashlib.sha1(str.encode('utf-8')).hexdigest()
print("sha1  {}  len:{}".format(sha1, len(sha1)))

sha256 = hashlib.sha256(str.encode('utf-8')).hexdigest()
print("sha256  {}  len:{}".format(sha256, len(sha256)))

sha512 = hashlib.sha512(str.encode('utf-8')).hexdigest()
print("sha512  {}  len:{}".format(sha512, len(sha512)))


#结果
md5  fc5e038d38a57032085441e7fe7010b0  len:32
sha1  6adfb183a4a2c94a2f92dab5ade762a47889a5a1  len:40
sha256  936a185caaa266bb9cbe981e9e05cb78cd732b0b3280eb944412bb6f8f8f07af  len:64
sha512  1594244d52f2d8c12b142bb61f47bc2eaf503d6d9ca8480cae9fcf112f66e4967dc5e8fa98285e36db8af1b8ffa8b84cb15e0fbcf836c3deb803c13f37659a60  len:128
#要加密成什么存入数据库时要注意长度

逻辑删除

from datetime import datetime
from ext import db

class User(db.Model):
    isdelete = db.Column(db.Boolean,default=False)
    
    def __str__(self):
        return self.username

数据库查询（重要）

@user_bp.route('/', methods=['GET', 'POST'],endpoint='index')
def index():
    users = User.query.all()
    # 查询数据库中的数据，返回一个对象列表
    # 相当于 select * from user

    return render_template('user/index.html',users=users)

• 查询所有：模型类.query.all()

• 有条件查询：

  模型类.query.filter_by(字段名=字段值)

  users = User.query.filter_by(username=username)

  相当于 select * from user where username = username

  如果查询结果是多个，则返回一个对象列表

  users = User.query.filter_by(username=username).first()

  取出第一个，注意：没有 last() 用法

  

• 根据主键查询

  模型类.query.get( 键值 )

  get() 返回指定主键对应的行，如不存在，返回None

• 重点

模型类.query.filter() 里面是一个布尔的条件 模型类.query.filter().all()

如果要检索的数据是字符串类型

```bash
模型类.query.filter( 模型名.字段名 == 值 )


模型类.query.filter( 模型类.字段.startwith( '值' ) ).all()  以。。开始的数据
#select * from user where username like 'a%'


模型类.query.filter( 模型类.字段.endwith( '值'  ) ).all()  以。。结尾的数据
#select * from user where username like '%a'


模型类.query.filter( 模型类.字段.contains( '值'  ) ).all()  包含。。。的数据
#select * from user where username like '%a%'


模型类.query.filter( in_(['','']))).all()  包列表值的数据
#select * from user where username not like '%a%'


模型类.query.filter( not_(模型类.字段.contains( '值'  ))).all()  不包含。。。的数据
#select * from user where username not like '%a%'


模型类.query.filter( 模型类.字段.like( 'a%'  ) ).all()  以。。开头的数据
#like()里边的写法和 sql 语句一致
#select * from user where username like 'a%'


模型类.query.filter(or_(模型类.字段.like( 'a%' ), 模型类.字段.contains( '值'  ))).all()  以。。开头或者包含。。的数据
#select * from user where username like 'a%' or username like %a%

如果要检索的数据是整型或日期类型

模型类.query.filter(and_(模型类.字段.like( 'a%' ), 模型类.字段.__gt__( '值'  ))).all()  以。。开头且字段大于某个值的数据
#select * from user where username like 'a%' and rdatetime > %a%
#补充 __gt__,__lt__,__ge__  (gt equal),__le__  (le equal)    通常应用在整形
#也可以直接使用  > , < , >= , <= , !=
#使用需要导入对应包 

between

多个条件

and_   or_  not_ 
#需要导入包
from sqlalchemy import or_

排序 order_by

order_by

模型类.query.order_by(模型类.字段名)
1.直接是字符串:'字段名' 但是不能倒序
2.填字段名:模型.字段 order_by(-模型.字段) 可以倒序

如果是这个报错说明返回值不是列表解决：查询语句后加.all()

限制 limit

user_list = 模型类.query.limit(2).all()
#默认获取前两条

user_list = 模型类.query.offset(2).limit(2).all()
#跳过前两条在获取两条数据

_template('user/index.html',users=users)

- 查询所有：模型类.query.all()

- 有条件查询：

  模型类.query.filter_by(字段名=字段值)

  users = User.query.filter_by(username=username)

  相当于 select * from user where username = username

  如果查询结果是多个，则返回一个对象列表

  users = User.query.filter_by(username=username).first()

  取出第一个，注意：没有 last() 用法

  [外链图片转存中...(img-ZX4OdjQ9-1615810321534)]

- 根据主键查询

  模型类.query.get( 键值 )

  get()	返回指定主键对应的行，如不存在，返回None

- **重点**

  ```bash
模型类.query.filter()  里面是一个布尔的条件
  模型类.query.filter().all() 

如果要检索的数据是字符串类型

模型类.query.filter( 模型名.字段名 == 值 )


模型类.query.filter( 模型类.字段.startwith( '值' ) ).all()  以。。开始的数据
#select * from user where username like 'a%'


模型类.query.filter( 模型类.字段.endwith( '值'  ) ).all()  以。。结尾的数据
#select * from user where username like '%a'


模型类.query.filter( 模型类.字段.contains( '值'  ) ).all()  包含。。。的数据
#select * from user where username like '%a%'


模型类.query.filter( in_(['','']))).all()  包列表值的数据
#select * from user where username not like '%a%'


模型类.query.filter( not_(模型类.字段.contains( '值'  ))).all()  不包含。。。的数据
#select * from user where username not like '%a%'


模型类.query.filter( 模型类.字段.like( 'a%'  ) ).all()  以。。开头的数据
#like()里边的写法和 sql 语句一致
#select * from user where username like 'a%'


模型类.query.filter(or_(模型类.字段.like( 'a%' ), 模型类.字段.contains( '值'  ))).all()  以。。开头或者包含。。的数据
#select * from user where username like 'a%' or username like %a%

如果要检索的数据是整型或日期类型

模型类.query.filter(and_(模型类.字段.like( 'a%' ), 模型类.字段.__gt__( '值'  ))).all()  以。。开头且字段大于某个值的数据
#select * from user where username like 'a%' and rdatetime > %a%
#补充 __gt__,__lt__,__ge__  (gt equal),__le__  (le equal)    通常应用在整形
#也可以直接使用  > , < , >= , <= , !=
#使用需要导入对应包 

between

多个条件

and_   or_  not_ 
#需要导入包
from sqlalchemy import or_

排序 order_by

order_by

模型类.query.order_by(模型类.字段名)
1.直接是字符串:'字段名' 但是不能倒序
2.填字段名:模型.字段 order_by(-模型.字段) 可以倒序

如果是这个报错说明返回值不是列表解决：查询语句后加.all()[外链图片转存中...(img-8RYfUwV0-1615810321535)]

限制 limit

user_list = 模型类.query.limit(2).all()
#默认获取前两条

user_list = 模型类.query.offset(2).limit(2).all()
#跳过前两条在获取两条数据