flask 之(三) --- 筛选|分页|过滤

筛选

查询数据筛选语法：类名.query.筛选符　

　　.all( )：获取结果集；.count( )：获取查询到的对象数量

　　类名.query.filter(类名.属性.运算符('xxx')).all()

　　类名.query.filter(类名.属性数学运算符值).all()

筛选符：

　　filter_by()：根据什么过滤，通常用在级连关系查询上，属性=值。不常用；　　　　 filter()：查询获取数据

　　offset()：　偏移，偏移前几条取数据；　limit()：　限制，限制取多少条数据；　　 order_by()：　根据什么字段排序；　　

　　get()：　　根据主键获取数据；　　　　first()：　取第一个元素；　　　　　　　 paginate()：分页

数学运算符：

　　　contains　包含，模糊查询；　startswith　以什么开始；　endswith　　以什么结束；

　　　in_　　在什么范围中；　　　 like　　包含，模糊查询；　__gt__　　大于　

　　　__ge__　　大于等于；　　　__lt__　　小于；　　　　　__le__　　小于等于

 import random

 from operator import or_, and_

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

 from flask_sqlalchemy import SQLAlchemy

 from sqlalchemy import text

 app = Flask(__name__)

 app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///flaskmodel.sqlite"

 app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

 db = SQLAlchemy(app)

 class Student(db.Model):

     id = db.Column(db.Integer, primary_key=True, autoincrement=True)

     name = db.Column(db.String(32), unique=True)

     score = db.Column(db.Integer, default=60)

     def save(self):     # 类方法。对数据进行保存提交

         db.session.add(self)

         db.session.commit()

 # 数据库初始化，新建一个数据库

 @app.route("/init/")

 def init():

     db.create_all() # 新建数据库

     return "初始化成功"

 # 新建一个学生表，在内加入学生信息

 @app.route("/addstudent/")

 def add_student():

     student = Student(name="小明%d" % random.randrange(10000), score=random.randrange(100))

     student.save()      # 调用save()类方法，对要添加的数据进行添加提交

     return "添加成功"

 @app.route("/students/")

 def students():

     # 获取成绩在 80分以上的学生信息

     student_list = Student.query.filter(Student.score > 80).all()

     student_list = Student.query.filter(Student.score.__gt__(80)).all()

     # 获取成绩在 60分以下的学生信息

     student_list = Student.query.filter(Student.score < 60).all()

     student_list = Student.query.filter(Student.score.__lt__(60)).all()

     # 获取成绩是 [60、81、100、200]列表内的学生信息

     student_list = Student.query.filter(Student.score.in_([60, 81, 100, 200])).all()

     # 获取成绩在 60分以上、80分一下的学生信息。

     # filter之后对象类型是BaseQuery，可以链式调用：Student.query.filter(xxx).filter().filter().filter()

     student_list = Student.query.filter(Student.score > 60).filter(Student.score < 80).all()

     # filter_by()：通常级联查询，条件是确切的=那种。条件 改成 属性=值

     student_list = Student.query.filter_by(score = 80).all()

     # offset():越过三条数据取3条数据的 学生数据结果

     student_list = Student.query.offset(3).limit(3).all()

     # 通过成绩从高到底排序，order_by(text("-score"))

     student_list = Student.query.order_by(text("-score")).all()

     # 通过order_by对成绩排序，越过前三条数据后offset(3)，取四条学生信息数据limit(4)

     # order_by必须放在最前面。limit和offset无顺序，实际上都是先offset再limit

     student_list = Student.query.order_by("score").limit(4).offset(3).all()

     # BaseQuery是可迭代元素，可以被for..in迭代出元素。all只是将格式转换为了列表。

     student_list = Student.query.order_by("score")

     # 获取学生数据的第一个元素，结果不再是复数。不可迭代。结果的类型是一个Student对象

     student = Student.query.first()

     return render_template("student_list1.html", student_list=student_list)

     # 原生分页。可以从客户端接受参数，参数是页码，每一个三条数据

     page = request.args.get("page", 1, type=int)  # 获取get请求数据：参数是page、默认值是1、类型是：int

     student_list = Student.query.offset(3*(page-1)).limit(3).all()

     return render_template("student_list1.html", student_list=student_list)

     # 对获取的数据进行分页

     pagination = Student.query.paginate()

     return render_template("student_list1.html", pagination=pagination)

 if __name__ == '__main__':

         app.run()

逻辑运算符：

　　与and_　　或or_　　非not_

　　filter(and_(条件),条件...)　　filter(or_(条件),条件...)　　filter(not_(条件),条件...)

# 与：and_   filter(and_(条件))

huochelist = kaihuoche.query.filter(and_(kaihuoche.id == 1,kaihuoche.name == 'lc'))

# 或：or_    filter(or_(条件))

huochelist = kaihuoche.query.filter(or_(kaihuoche.id == 1,kaihuoche.name =='lc'))

# 非：not_   filter(not_(条件))  注意条件只能有一个

huochelist = kaihuoche.query.filter(not_(kaihuoche.id == 1))

 # 查询指定范围内的数据。and_ 方法

 @app.route("/students2/")

 def students2():

     student_list = Student.query.filter(and_(Student.score.__gt__(60), Student.score.__lt__(90)))

     return render_template("student_list2.html", student_list=student_list)

 # 查询后 删除数据

 @app.route("/dropfirst/")

 def drop_first():

     student = Student.query.order_by(text("-score")).first()

     print(student.score)

     db.session.delete(student)

     db.session.commit()

     return ""

 # 查询后，修改数据值

 @app.route("/updatescore/")

 def update_score():

     student = Student.query.order_by(text("score")).first()

     print(student.score, student.id)

     student.score = 100

     db.session.add(student)

     db.session.commit()

     return "完成"

 if __name__ == '__main__':

     app.run()

分页

　　分页器：paginate。分页查询，需要想要的页码，每一页显示多少数据

　　分页对象：分页器(Pagination)返回的对象。包含了所有的分⻚页信息。

　　封装实现：persons = Person.query.paginate(page_num, per_page, False).items

　　原生实现：persons = Person.query.offset((page_num - 1) * per_page).limit(per_page)

　　　　　　　select * from users offset 0 limit 20　　　;select * from users offset 20 limit 40

使用：pagination(page，per_page, False(是否抛异常))
- 　page：当前的⻚页码
- 　per_page：每⻚页的条数
- 　error_out：当查询出错时是否报错

 @bp.route('/students/')

 def student_list():

     """

     /students/?page=2

     """

     page = int(request.args.get('page', 1))

     per_page = 2 　　# 每页显示2条数据

     students = Student.query.paginate(page=page, per_page=per_page)

     return render_template('students.html', students=students)

属性

　　　　page：当前⻚页码　　 pages：总⻚页数　　 total：总条数

　　　　prev_num：上⼀⻚页的⻚页码　　 next_num：下⼀⻚页的⻚页码

　　　　has_prev：是否有上一⻚页　　 has_next：是否有下一⻚页

　　　　items：当前⻚页的数据　　 per_page：每⻚页的条数，默认为20条

 <div>

     <a href="{{ url_for('blue.student_list') }}">首页</a>

     {% if students.has_prev %}   是否有上一页

         <a href="{{ url_for('blue.student_list', page=students.prev_num) }}">上一页</a>

     {% endif %}

     当前{{ students.page }}页，共{{ students.pages }}页，总共{{ students.total }}条

     {% if students.has_next %}　 是否有下一页

         <a href="{{ url_for('blue.student_list', page=students.next_num) }}">下一页</a>

     {% endif %}

     <a href="{{ url_for('blue.student_list', page=students.pages) }}">尾页</a>

 </div>

方法
- iter_pages:　　返回一个迭代器。在分页导航条上显示的页码列表。显示不完全时返回NOne
- prev:　　上⼀页的分页对象
- next: 下一⻚的分页对象

 <div>

     {% for page in students.iter_pages() %}

         {% if page %}

             {% if page == students.page %}

                 {{ page }}

             {% else %}

                 <a href="{{ url_for('blue.student_list', page=page) }}">{{ page }}</a>

             {% endif %}

         {% else %}

             ...

         {% endif %}

     {% endfor %}

 </div>

分页宏定义

{# 分页显示的宏 #}

{% macro pagination_widget(pagination, endpoint) %}

    <ul class="pagination">

        <li{% if not pagination.has_prev %} class="disabled"{% endif %}>

            <a href="{% if pagination.has_prev %}{{ url_for(endpoint,page = pagination.page - 1, **kwargs) }}

            {% else %}#{% endif %}">&laquo;

            </a>

        </li>

        {% for p in pagination.iter_pages() %}

            {% if p %}

                {% if p == pagination.page %}

                    <li class="active">

                        <a href="{{ url_for(endpoint, page = p, **kwargs) }}">{{ p }}</a>

                    </li>

                {% else %}

                <li>

                    <a href="{{ url_for(endpoint, page = p, **kwargs) }}">{{ p }}</a>

                </li>

                {% endif %}

            {% else %}

            <li class="disabled">

                <a href="#">&hellip;</a>

            </li>

            {% endif %}

        {% endfor %}

        <li{% if not pagination.has_next %} class="disabled"{% endif %}>

            <a href="{% if pagination.has_next %}{{ url_for(endpoint,page = pagination.page + 1, **kwargs) }}{% else %}#{% endif %}">&raquo;</a>

        </li>

    </ul>

{% endmacro %}

过滤

　过滤器:

　　　default：默认值　　　　capitalize：首字母大写　　　　lower：全小写　　　　upper：全大写　　　　

　　　trim：去除空格　　　　reverse：反转　　　　format：格式化输出　　　　safe：关闭转义(已审查，没有安全隐患)　　　　

　　　striptags：将值中标签去掉　　　　round：四舍五入(截取)　　　　abs：绝对值　　　　first：第一个元素　　　　

　　　last：最后一个元素　　　　length：列表长度　　　　sum：列表求和　　　　sort：列表排序(升序) 　　　　 join：合并字符串

模版文件中

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <title>Title</title>

</head>

<body>

语法:

    {{ 变量 | 过滤器 | 过滤器 }}

例子:

    {# 当变量未定义时，显示默认字符串，可以缩写为d #}

    <p>{{ name | default('No name') }}</p>

    {# 单词首字母大写 #}

    <p>{{ 'hello' | capitalize }}</p>

    {# 单词全小写 #}

    <p>{{ 'XML' | lower }}</p>

    {# 去除字符串前后的空白字符 #}

    <p>{{ 'hello' | trim }}</p>

    {# 字符串反转，返回"olleh" #}

    <p>{{ 'hello' | reverse }}</p>

    {# 格式化输出，返回"Number is 2" #}

    <p>{{ '%s is %d' | format("Number", 2) }}</p>

    {# 关闭HTML自动转义 #}

    <p>{{ '<em>name</em>' | safe }}</p>

    {# 四舍五入取整，返回13.0 #}

    <p>{{ 12.8888 | round }}</p>

    {# 向下截取到小数点后2位，返回12.88 #}

    <p>{{ 12.8888 | round(2, 'floor') }}</p>

    {# 绝对值，返回12 #}

    <p>{{ -12 | abs }}</p>

    {# 取第一个元素 #}

    <p>{{ [1,2,3,4,5] | first }}</p>

    {# 取最后一个元素 #}

    <p>{{ [1,2,3,4,5] | last }}</p>

    {# 返回列表长度，可以写为count #}

    <p>{{ [1,2,3,4,5] | length }}</p>

    {# 列表求和 #}

    <p>{{ [1,2,3,4,5] | sum }}</p>

    {# 列表排序，默认为升序 #}

    <p>{{ [3,2,1,5,4] | sort }}</p>

    {# 合并为字符串，返回"1 | 2 | 3 | 4 | 5" #}

    <p>{{ [1,2,3,4,5] | join(' | ') }}</p>

</body>

</html>

template_filter 自定义模板过滤器

 @bp.app_template_filter('mycut')

 def mycut(x):

     return x if len(x) < 6 else x[:5] + '...'

 """

 使用

 <p>{{ 'hello' | mycut }}</p>

 """

拾遗

 # 自定义上下文处理器。context_processor(模板的全局变量)

 import time

 @app.context_processor

 def client_ip():

   return dict(remote_ip=request.remote_addr)

 @app.context_processor

 def get_current_time():

   def get_time(fmt="%b %d, %Y - %H:%M:%S"):

     return time.strftime(fmt)

   return dict(current_time=get_time)

 # 使用：在任意模板页面都可以是使用 current_time 这个函数

 <p>Current Time is: {{ current_time() }}</p>

 <p>Current Day is: {{ current_time("%Y-%m-%d") }}</p> 

 # ————————————————————————————————————————————————————————————#

 # 自定义模板过滤器。template_filter

 @bp.app_template_filter('mycut')

 def mycut(x):

     return x if len(x) < 6 else x[:5] + '...'

 # 使用

 <p>{{ 'hello' | mycut }}</p>

巴特西

flask 之(三) --- 筛选|分页|过滤

筛选

分页

过滤

拾遗

最新文章

热门文章