Flask筛选数据、分页、一对多关联_flask处理数据筛选-优快云博客

flask筛选数据

添加多条学生信息

s_list = [学生对象1，学生对象2，..]
db.session.add_all(s_list)

运算符

filter(模型名.字段.运算符(‘xxx’))
filter(模型名.字段运算符值 )
运算符
lt 小于
le 小于等于
gt 大于
ge 大于等于
in_ 在范围内
order_by 排序
limit 截取几个信息
offset 跳过几个信息
get 获取主键对应的信息
and_ 并且条件
or_ 或者条件
not_ 非


from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy()


class Student(db.Model):

    s_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    s_name = db.Column(db.String(20), unique=True)
    s_age = db.Column(db.Integer, default=18)

    __tablename__ = 'student'

    # 初始化，通过这种方式就可以直接通过传参数的方式，创建数据
    def __init__(self, name, age):

        self.s_name = name
        self.s_age = age

import random

from flask import Blueprint, render_template, request
# 注意导入的包
from sqlalchemy import and_, or_, not_

from Stu.models import db, Student

stu = Blueprint('stu', __name__)


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


@stu.route('/createdb')
def create_db():
    db.create_all()
    return '创建数据库成功'


@stu.route('/dropdb')
def drop_db():
    db.drop_all()
    return '删除数据库成功，可以跑路了'


@stu.route('/createstu', methods=['GET', 'POST'])
def create_stu():
    if request.method == 'GET':
        return render_template('create_stu.html')

    if request.method == 'POST':
        username1 = request.form.get('username1')
        age1 = request.form.get('age1')
        stus = Student(username1, age1)

        db.session.add(stus)
        db.session.commit()
        return '创建成功'


@stu.route('/createstus', methods=['GET', 'POST'])
def create_stus():
    if request.method == 'GET':
        return render_template('create_stu.html')

    else:
        stus_list =[]
        username1 = request.form.get('username1')
        age1 = request.form.get('age1')

        username2 = request.form.get('username2')
        age2 = request.form.get('age2')

        stu1 = Student(username1, age1)
        stu2 = Student(username2, age2)

        stus_list.append(stu1)
        stus_list.append(stu2)
        # 注意传送的是一个列表，添加的方式也有变化，add_all
        db.session.add_all(stus_list)
        db.session.commit()
        return '添加成功'


@stu.route('/selectstu')
def select_stu():
    # 年龄小于16岁的学生信息
    # stus = Student.query.filter(Student.s_age < 16)

    # 也可以用这种方法lt 小于， le小于等于
    # stus = Student.query.filter(Student.s_age.__lt__(16))

    # 小于等于16
    # stus = Student.query.filter(Student.s_age.__le__(16))

    # 大于16
    # tus = Student.query.filter(Student.s_age.__gt__(16))

    # 大于等于16
    # stus = Student.query.filter(Student.s_age.__ge__(16))

    # 年龄在16，1，20, 23
    # stus = Student.query.filter(Student.s_age.in_([16, 1, 20, 23]))

    # 原生sql查所有学生
    # sql = 'select * from student'
    # stus = db.session.execute(sql)

    # 按照id降序排列，注意是在query后面接order_by，如果加了all取到的是一个列表，没有order_by方法
    # stus = Student.query.order_by('-s_id')

    # 降序获取3个
    # stus = Student.query.order_by('-s_id').limit(3)

    # 获取年龄最大的一个
    # stus = Student.query.order_by('-s_age').limit(1)

    # 跳过2个数据，取两个
    # stus = Student.query.order_by('-s_age').offset(2).limit(2)

    # 获取s_id等于24的学生
    # stus = Student.query.filter(Student.s_id == 24).all()

    # get方法，只会匹配主键，并且取到的是一个值，不能被迭代
    # stu = Student.query.get(24)

    # 查询多个条件
    # stus = Student.query.filter(Student.s_age == 20, Student.s_name == '关羽').all()

    # and_并且条件
    # stus = Student.query.filter(and_(Student.s_age == 18, Student.s_name == '刘备'))

    # or_或者条件
    # stus = Student.query.filter(or_(Student.s_age == 18,Student.s_name == '刘备'))

    # not_非 只能加一个条件
    # stus = Student.query.filter(not_(Student.s_age == 18))

    # 表示年龄不等于18， 姓名是关羽的数据
    # stus = Student.query.filter(not_(Student.s_age == 18), (Student.s_name == '关羽'))

    return render_template('student_list.html', stus=stus)


@stu.route('/createstubyrange')
def create_random_stus():
    stus_list = []
    for i in range(20):
        stu = Student('小明%d' % random.randrange(1000),
                '%d' % random.randrange(30))
        stus_list.append(stu)
    db.session.add_all(stus_list)
    db.session.commit()
    return '创建成功'

分页

paginate对象
pages 总页数
total 总条数
has_prev 是否有上页
has_next 是否有下页
prev_num
next_num
iter_pages() 当前一共多少页[1,2,3]

@stu.route('/stupage')
def stu_page():
    # 获取当前页数
    page = int(request.args.get('page', 1))
    # 设置每页数据
    per_page = int(request.args.get('per_page', 10))
    # 将学生数据分页
    paginate = Student.query.order_by('-s_id').paginate(page, per_page, error_out=False)
    # 获取学生信息
    stus = paginate.items
    return render_template('stupage.html', paginate=paginate, stus=stus)

{% extends 'base_main.html' %}

{% block title %}
    学生分页页面
{% endblock %}

{% block content %}
    <h3>学生信息</h3>
    {% for stu in stus %}
        {{ stu.s_name }}
        {{ stu.s_age }}
        <br>
    {% endfor %}
    <br>
    总页数：{{ paginate.pages }}
    <br>
    一共有{{ paginate.total }}条数据
    <br>

    当前页数：{{ paginate.page }}
    <br>
    {% if paginate.has_prev %}
        <a href=" /stu/stupage?page={{ paginate.prev_num }} ">上一页：{{ paginate.prev_num }}</a>
    {% endif %}
    {% if paginate.has_next %}
        <a href=" /stu/stupage?page={{ paginate.next_num }} ">下一页：{{ paginate.next_num }}</a>
    {% endif %}
    <br>
    页码：{% for i in  paginate.iter_pages() %}
    <a href="/stu/stupage?page={{ i }}"> {{ i }} </a>
    {% endfor %}
{% endblock %}

one_to_many

在one的model中定义relationship字段
students = db.relationship(‘Student’, backref=’stu’, lazy=True)
- 通过one找many，one的对象.students，结果为many的结果
- 通过many找one，many的对象.stu，结果为one的对象

# Grade app下的models.py文件
from datetime import datetime

from flask_sqlalchemy import SQLAlchemy
# 注意为了是两个表可以互相关联需要从另一model中导入db
from Stu.models import db


class Grade(db.Model):

    g_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    g_name = db.Column(db.String(10), unique=True)
    g_desc = db.Column(db.String(100), nullable=True)
    g_time = db.Column(db.Date, default=datetime.now)
    # 在没有设置外键的表中，设置关系，第一个参数是另一model的类名，第二参数用于反向查找这个表
    # lazy懒加载，使用的时候才加载
    students = db.relationship('Student', backref='grade', lazy=True)  

    __tablename__ = 'grade'

    def __init__(self, name, desc):
        self.g_name=name
        self.g_desc=desc

# Stu app下的models.py文件
from flask_sqlalchemy import SQLAlchemy


db = SQLAlchemy()


class Student(db.Model):

    s_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    s_name = db.Column(db.String(20), unique=True)
    s_age = db.Column(db.Integer, default=18)
    # 注意参数顺序，不要写反， grade.g_id表示的是tablename，点关联的字段名
    # 在通过这个表找关联表时不要直接点s_g,需要点上一个model中的反选的变量（grade）
    s_g = db.Column(db.Integer, db.ForeignKey('grade.g_id'), nullable=True)

    __tablename__ = 'student'

    # 初始化
    def __init__(self, name, age):

        self.s_name = name
        self.s_age = age

# Stu app下的views.py文件
@stu.route('/selectgradebystu/<int:id>/')
def select_grade_by_stu(id):
    # 通过id找到学生
    stu = Student.query.get(id)
    # 学生通过反选变量找到班级
    grade = stu.grade

    return render_template('stu_grade.html', stu=stu, grade=grade)

# Grade app下的views.py文件
@grade.route('/selectstubygrade/<int:id>/' )
def select_stu_by_grade(id):
    # 通过班级id找到班级
    grade = Grade.query.get(id)
    # 通过班级的关联字段找到学生
    stus = grade.students
    # 通过反选变量还可以找到班级
    grade1 = stus[0].grade
    return render_template('grade_student.html', stus=stus, grade=grade, grade1=grade1)