flask的进阶使用方法

news2024/11/20 9:33:48

【 一 】一对多关系

# 1 一对一   [本质就是一对多--》多的那个唯一]
# 2 一对多
# 3 多对多

1.1 关系

####  一对多关系
class Hobby(Base):
    __tablename__ = 'hobby'
    id = Column(Integer, primary_key=True)
    caption = Column(String(50), default='篮球')
    def __str__(self):
        return self.caption


class Person(Base):
    __tablename__ = 'person'
    nid = Column(Integer, primary_key=True)
    name = Column(String(32), index=True, nullable=True)
    # hobby指的是tablename而不是类名
    hobby_id = Column(Integer, ForeignKey("hobby.id"))  # 一个爱好，可以被多个人喜欢，一个人只能喜欢一个爱好

    # 跟数据库无关，不会新增字段，只用于快速链表操作
    # 类名，backref用于反向查询
    hobby = relationship('Hobby', backref='pers')
    def __str__(self):
        return self.name

    def __repr__(self):
        return self.name

from models import Person,Hobby
# 第一步：创建engine
from sqlalchemy import create_engine
engine = create_engine(
    "mysql+pymysql://root:1234@127.0.0.1:3306/sqlalchemy001?charset=utf8",
    max_overflow=0,  # 超过连接池大小外最多创建的连接
    pool_size=5,  # 连接池大小
    pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错
    pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）
)

# 第二步：创建 session对象---老方式
from sqlalchemy.orm import Session
session=Session(engine)


if __name__ == '__main__':
    ### 笨办法增加
    #1 先增加一个hobby
    # hobby=Hobby()
    # session.add(hobby)
    # session.commit()
    #2 增加Person---》必须要有hobby_id
    # person=Person(name='lqz',hobby_id=1)
    # session.add(person)
    # session.commit()

    ### 简便方法--》增加person的同时，增加了Hobby
    # person = Person(name='lqz', hobby=Hobby(caption='乒乓球'))
    # session.add(person)
    # session.commit()
    # hobby=session.query(Hobby).filter_by(id=1).first()
    # person = Person(name='lqz3', hobby=hobby)
    # session.add(person)
    # session.commit()


    # 基于对象的跨表查询--->正向
    # person=session.query(Person).filter_by(nid=2).first()
    # print(person)
    # print(person.hobby_id)
    # print(person.hobby)

    # 基于对象的跨表查询--->反向
    hobby = session.query(Hobby).filter_by(id=1).first()
    print(hobby.caption)
    print(hobby.pers)

models.py

from sqlalchemy import Column, Integer, String, Text, ForeignKey, DateTime, UniqueConstraint, Index
import datetime

# 新版本创建基类
# 第一步：创建基类，以后所有类，都必须继承基类
from sqlalchemy.orm import DeclarativeBase, relationship


class Base(DeclarativeBase):
    pass


### 第二步：写个类，继承
### 第三步：写字段：传统方式，类型方式

class User(Base):
    __tablename__ = 'user'

    id = Column(Integer, primary_key=True, autoincrement=True)
    # name列varchar32，索引，不可为空 nullable=False
    name = Column(String(32), index=True, nullable=False)
    # email 列，varchar32，唯一
    email = Column(String(32), unique=True)
    ctime = Column(DateTime, default=datetime.datetime.now)
    extra = Column(Text, nullable=True)

    def __repr__(self):
        return f"<User(name={self.name}, email={self.email})>"


####  一对多关系
class Hobby(Base):
    __tablename__ = 'hobby'
    id = Column(Integer, primary_key=True)
    caption = Column(String(50), default='篮球')

    def __str__(self):
        return self.caption


class Person(Base):
    __tablename__ = 'person'
    nid = Column(Integer, primary_key=True)
    name = Column(String(32), index=True, nullable=True)
    # hobby指的是tablename而不是类名
    hobby_id = Column(Integer, ForeignKey("hobby.id"))  # 一个爱好，可以被多个人喜欢，一个人只能喜欢一个爱好

    # 跟数据库无关，不会新增字段，只用于快速链表操作
    # 类名，backref用于反向查询
    hobby = relationship('Hobby', backref='pers')

    def __str__(self):
        return self.name

    def __repr__(self):
        return self.name


if __name__ == '__main__':
    from sqlalchemy import create_engine

    engine = create_engine(
        "mysql+pymysql://root:123123@127.0.0.1:3306/school?charset=utf8",
        max_overflow=0,  # 超过连接池大小外最多创建的连接
        pool_size=5,  # 连接池大小
        pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错
        pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）
    )
    # 第四步 创建user表
    Base.metadata.create_all(engine)

    ## 第五步：删除表
    # Base.metadata.drop_all(engine)


from models import Person, Hobby

# 第一步：创建engine
from sqlalchemy import create_engine

engine = create_engine(
    "mysql+pymysql://root:123123@127.0.0.1:3306/school?charset=utf8",
    max_overflow=0,  # 超过连接池大小外最多创建的连接
    pool_size=5,  # 连接池大小
    pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错
    pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）
)

# 第二步 创建 session对象---老方式
from sqlalchemy.orm import Session

session = Session(engine)

# # 增加一个hobby
res1 = Hobby(caption='rapper')
session.add(res1)

# # person ---->>> 必须要有hobby_id
person = Person(name='jingyi', hobby_id=1)
session.add(person)
session.commit()
session.close()



## 简便方法--》增加person的同时，增加了Hobby
person = Person(name='jingyi', hobby=Hobby(caption='乒乓球'))
session.add(person)
session.commit()
hobby=session.query(Hobby).filter_by(id=1).first()
person = Person(name='jing', hobby=hobby)
session.add(person)
session.commit()


# 基于对象的跨表查询--->正向
person = session.query(Person).filter_by(nid=1).first()
print(person)
print(person.hobby_id)
print(person.hobby)

# 基于对象的跨表查询--->反向
hobby = session.query(Hobby).filter_by(id=1).first()
print(hobby.caption)
print(hobby.pers)

  • 基于对象的跨表查询—>正向

image-20240618172833794

  • 基于对象的跨表查询—>反向

image-20240618173136759

【 二 】多对多关系

  • modelss.py

from sqlalchemy import Column, Integer, String, Text, ForeignKey, DateTime, UniqueConstraint, Index, Table
import datetime

# 新版本创建基类
# 第一步：创建基类，以后所有类，都必须继承基类
from sqlalchemy.orm import DeclarativeBase, relationship


class Base(DeclarativeBase):
    pass


### 第二步：写个类，继承
### 第三步：写字段：传统方式，类型方式


# 定义关联表 多对多必备可少的参数
association_table = Table('user1_group_association', Base.metadata,
                          Column('user1_id', Integer, ForeignKey('user1.id')),
                          Column('group_id', Integer, ForeignKey('group.id')),
                          UniqueConstraint('user1_id', 'group_id')  # 如果需要的话，可以添加唯一约束
                          )


# 定义 User1 模型
class User1(Base):
    __tablename__ = 'user1'

    id = Column(Integer, primary_key=True)
    name = Column(String(32), index=True, nullable=False)
    groups = relationship("Group", secondary=association_table, backref="users")


# 定义 Group 模型
class Group(Base):
    __tablename__ = 'group'

    id = Column(Integer, primary_key=True)
    name = Column(String(32), index=True, nullable=False)



if __name__ == '__main__':
    from sqlalchemy import create_engine

    engine = create_engine(
        "mysql+pymysql://root:123123@127.0.0.1:3306/school?charset=utf8",
        max_overflow=0,  # 超过连接池大小外最多创建的连接
        pool_size=5,  # 连接池大小
        pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错
        pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）
    )
    # 第四步 创建user表
    Base.metadata.create_all(engine)

    ## 第五步：删除表
    # Base.metadata.drop_all(engine)

  • py

  • 增加

from modelss import User1, Group

# 第一步：创建engine
from sqlalchemy import create_engine

engine = create_engine(
    "mysql+pymysql://root:123123@127.0.0.1:3306/school?charset=utf8",
    max_overflow=0,  # 超过连接池大小外最多创建的连接
    pool_size=5,  # 连接池大小
    pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错
    pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）
)

# 第二步 创建 session对象---老方式
from sqlalchemy.orm import Session

session = Session(engine)
# # 增加一个group
group1 = Group(name='5A风景区')
group2 = Group(name='大清败家子慈溪')

# session.add_all([group1, group2])
# # 增加一个User1
res1 = User1(name='刘亦菲')
res2 = User1(name='赵敏')


res1.groups.append(group1)
res2.groups.append(group2)
session.add_all([res1,res2])


# 基于对象的跨表查--》正向

user = session.query(User1).filter(User1.id == 3).all()[0]
print(user.name)
print(user.groups)

session.commit()
session.close()

image-20240618190135414

# 基于对象的跨表查--》正向

user = session.query(User1).filter(User1.id == 2).all()[0]
print(user.name)
print(user.groups)



group = session.query(Group).filter(Group.id == 3).all()[0]
print(group.name)
print(group.users)
  • # 基于对象的跨表查–》正向

image-20240618191810231

  • 如果user1表中的字段没有关系可以

user1 = session.query(User1).filter_by(id=2).first()
if user1 is None:
    print("用户不存在")
else:
    # 假设你想要关联一个已经存在的组，其id为group_id
    group_id = 2 # 这里替换为你想要关联的组的ID

    # 查询该组
    group_to_add = session.query(Group).filter_by(id=group_id).first()
    if group_to_add is None:
        print("组不存在")
    else:
        # 将组添加到用户的groups列表中
        user1.groups.append(group_to_add)

        # 提交事务以保存更改
        session.commit()

        print("关联已添加")

        # 关闭session
    session.close()

image-20240618191320318

filter[where]查询 写条件

# #filter[where]查询  写条件
user1 = session.query(User1).where(User1.id >= 2)
# SELECT user1.id AS user1_id, user1.name AS user1_name
# FROM user1
# WHERE user1.id >= %(id_1)s
user2 = session.query(User1).where(User1.id >= 2).all()
#filter[where]查询  写条件
user3 = session.query(User1).filter(User1.id >= 2).all()
# [小昭, 刘亦菲, 赵敏, 小玲, 小妹]
group1 = session.query(Group).filter_by(name='5A风景区').first()
# 5A风景区
print(user1)
print(user2)
print(user3)
print(group1)

image-20240618193530312

between

## 3 between

res = session.query(User1).where(User1.id.between(1,7),User1.name == '刘亦菲').all()

print(res)
# 这个就代表有两个复合条件
# [刘亦菲, 刘亦菲]

image-20240618193929854

in

## 4 in
res = session.query(User1).filter(User1.id.in_([1,2,7])).all()
print(res)
# [李保平, 小昭, 刘亦菲]

image-20240618194126190

~非，除。。外

# 5 ~非，除。。外
res = session.query(User1).filter(~User1.id.in_([3, 4]),User1.name=='刘亦菲').all()
print(res)
# 原本是有两个刘亦菲的因为我用了~User1.id.in_([3, 4] 中的3 就是一个刘亦菲
# [刘亦菲]

二次筛选

session.query(User1).filter(User1.id.in_(session.query(Group.id).filter_by(name='刘亦菲'))).all()

and,or条件

# 7 and,or条件
from sqlalchemy import and_, or_
# and_
res1 = session.query(User1).filter(and_(User1.id > 1, User1.name == '刘亦菲')).all()
# or_
res2 = session.query(User1).filter(or_(User1.id >= 3, User1.name == '刘亦菲')).all()
print(res1)
# [刘亦菲, 刘亦菲, 刘亦菲]
print(res2)
# [刘亦菲, 刘亦菲, 刘亦菲, 小妹, 小玲, 赵敏]

通配符，以小开头，不以小开头

# 8 通配符，以小开头，不以小开头
res1 = session.query(User1).filter(User1.name.like('小%')).all()

res2 = session.query(User1).filter(~User1.name.like('小%')).all()

res3 = session.query(User1).filter(~User1.name.like('小%'))
print(res1)
# [小妹, 小昭, 小玲]
print(res2)
# [刘亦菲, 刘亦菲, 刘亦菲, 赵保平, 赵敏]
print(res3) # 原声sql语句
# SELECT user1.id AS user1_id, user1.name AS user1_name 
# FROM user1 
# WHERE user1.name NOT LIKE %(name_1)s

限制，用于分页，区间

# 9 限制，用于分页，区间
res1 = session.query(User1)[5:9]
res2 = session.query(User1)[0:4]
print(res1)
# [小玲, 赵保平, 赵敏]
print(res2)
# [刘亦菲, 刘亦菲, 刘亦菲, 小妹]

排序

# 10 排序，根据name降序排列（从大到小） desc   asc
res = session.query(User1).order_by(User1.name.asc()).all()
print(res)
# [刘亦菲, 刘亦菲, 刘亦菲, 小妹, 小昭, 小玲, 赵保平, 赵敏]

res = session.query(User1).order_by(User1.name.desc(), User1.id.asc()).all()
print(res)
# [赵敏, 赵保平, 小玲, 小昭, 小妹, 刘亦菲, 刘亦菲, 刘亦菲]

分组

# 12 分组      一旦分组后，select 字段必须是 分组字段或聚合函数的字段

from sqlalchemy.sql import func

ret = session.query(
    # 按 User1.name 分组，并选择每个组的最大 ID、ID 总和、最小 ID 和名称
    func.max(User1.id).label('max_id'),
    func.sum(User1.id).label('sum_id'),
    func.min(User1.id).label('min_id'),
    User1.name
).group_by(User1.name).all()

user1 = session.query(User1).filter(User1.name)
print(user1)
# SELECT user1.id AS user1_id, user1.name AS user1_name
# FROM user1
# WHERE user1.name
# 输出结果
for row in ret:
    print(row.max_id, row.sum_id, row.min_id, row.name)

image-20240618204150063

连表查询

# 连表查询

ret = session.query(Person, Hobby).filter(Person.hobby_id == Hobby.id).all()
print(ret)

ret1 = session.query(Person).join(Hobby, Person.nid == Hobby.id, isouter=True)
print(ret1)
# SELECT person.nid AS person_nid, person.name AS person_name, person.hobby_id AS person_hobby_id
# FROM person LEFT OUTER JOIN hobby ON person.nid = hobby.id

image-20240618204059136

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1896098.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

C++ | Leetcode C++题解之第213题打家劫舍II

C++ | Leetcode C++题解之第213题打家劫舍II

题目&#xff1a; 题解&#xff1a; class Solution { public:int robRange(vector<int>& nums, int start, int end) {int first nums[start], second max(nums[start], nums[start 1]);for (int i start 2; i < end; i) {int temp second;second max(fi…
阅读更多...
django学习入门系列之第四点《案例 博客案例》

django学习入门系列之第四点《案例 博客案例》

文章目录 container面板案例 博客案例往期回顾 container 堆叠到两边 <div class"container-fluid clearfix"><div class"col-sm-9">1</div><div class"col-sm-3">2</div> </div>放在中间 <div clas…
阅读更多...
嵌入式Linux系统编程 — 6.7 实时信号

嵌入式Linux系统编程 — 6.7 实时信号

目录 1 什么是实时信号 2 sigqueue函数 3 sigpending()函数 1 什么是实时信号 等待信号集只是一个掩码&#xff0c;它并不追踪信号的发生次数。这意味着&#xff0c;如果相同的信号在被阻塞的状态下多次产生&#xff0c;它只会在信号集中被记录一次&#xff0c;并且在信号集…
阅读更多...
【Python实战因果推断】20_线性回归的不合理效果10

【Python实战因果推断】20_线性回归的不合理效果10

目录 Neutral Controls Noise Inducing Control Feature Selection: A Bias-Variance Trade-Off Neutral Controls 现在&#xff0c;您可能已经对回归如何调整混杂变量有了一定的了解。如果您想知道干预 T 对 Y 的影响&#xff0c;同时调整混杂变量 X&#xff0c;您所要做的…
阅读更多...
项目基础知识

项目基础知识

1.JDBC编程和MySQL数据库 数据库的连接&#xff08;以前写qq项目时的代码&#xff09; package com.wu.Util; import java.sql.*; public class JDBCUtil {private static JDBCUtil jdbcUtil null;private JDBCUtil() {}public static JDBCUtil getJdbcUtil() {if (jdbcUtil…
阅读更多...
RUP开发模型-系统架构师（二十三）

RUP开发模型-系统架构师（二十三）

1、RUP是一个二维软件开发模型&#xff0c;其核心特点之一是&#xff08;&#xff09;。RUP将软件开发周期划分多个循环&#xff0c;每个循环由4个连续阶段组成&#xff0c;每个阶段完成确定的任务。设计及确定系统的体系结构&#xff0c;制定工作计划及资源要求在&#xff08;…
阅读更多...
Edge浏览器油猴插件的安装与使用

Edge浏览器油猴插件的安装与使用

油猴 (又称篡改猴或Tampermonkey) 是最流行的浏览器扩展之一。它允许用户自定义并增强网页的功能。用户脚本是小型 JavaScript 程序&#xff0c;可用于向网页添加新功能或修改现有功能。使用油猴&#xff0c;您可以轻松在任何网站上创建、管理和运行这些用户脚本。 1.插件的安…
阅读更多...
标量场与向量场

标量场与向量场

标量场与向量场 flyfish 场 是一个函数&#xff0c;它把空间中的每一点关联到一个数值或一个数学对象&#xff08;如向量、张量等&#xff09;。在物理学中&#xff0c;场可以描述许多物理现象&#xff0c;例如温度分布、电场、磁场、压力场等。 标量场 标量场 是一个函数&…
阅读更多...
2024 年最佳 Figma 字体

2024 年最佳 Figma 字体

字体不仅仅是文本字符&#xff0c;它们还塑造了用户体验。从引导用户浏览界面到传达品牌个性&#xff0c;字体对于设计​​至关重要。然而&#xff0c;找到适合您的网站或应用风格的完美字体可能具有挑战性。 但不要害怕&#xff0c;我们会帮助您&#xff01;请继续关注&#x…
阅读更多...
c语言----队列

c语言----队列

很久没有写文章了。因为放假了嘛&#xff0c;给自己稍微放松了一下&#xff0c;所以最近的更新很慢。呜呜下一次一定改。然后咧。今天我想与大家分享的是队列。虽然这个知识点我们应该在讲了堆的实现就应该写的&#xff0c;但是后面忘了&#xff0c;以为自己是写了的。但是昨天…
阅读更多...
SQL二次注入原理分析

SQL二次注入原理分析

二次注入在测试的时候比较少见&#xff0c;或者说很难被测出来&#xff0c;因为测的时候首先要去找注入的位置&#xff0c;其次是去判断第一次执行的SQL语句&#xff0c;然后还要去判断第二次进行调用的 SQL 语句。而关键问题就出在第二次的调用上面。 下面以一个常用过滤方法…
阅读更多...
STM32学习历程（day2）

STM32学习历程（day2）

GPIO解释 GPIO(General-purpose input/output) 可以配置为八种输入输出模式 引脚电平 0V-3.3V 部分引脚可容忍5v 输出模式可控制端口输出高低电平 用以驱动LED、控制蜂鸣器、模拟通信协议输出时序 输入模式可读取端口的高低电平或电压&#xff0c;用于读取按键输入、外界…
阅读更多...
网络IO模型之多路复用器.md

网络IO模型之多路复用器.md

多路复用是什么&#xff1f;怎么理解&#xff1f; 本文主要涉及为 程序中处理网络IO时的模型&#xff0c;对于系统内核而言网络IO模型。这里只做普及使用 前置知识&#xff0c;什么是IO&#xff1f;怎么理解IO IO其实就是In和Out。中文翻译是输入和输出&#xff0c;只要涉及到输…
阅读更多...
js 递归调用 相同对象--数组递归调用

js 递归调用 相同对象--数组递归调用

<div class="save-cl"> <a-button @click="saveCl" >保存为常用策略</a-button> </div> saveCl(){ console.log(this.form.filterList[0],--------常用策略)// 此对象为上图对象 console.log(this.allElementsHaveValue(thi…
阅读更多...
【BUUCTF-PWN】7-[第五空间2019 决赛]PWN5

【BUUCTF-PWN】7-[第五空间2019 决赛]PWN5

参考&#xff1a;BUU pwn [第五空间2019 决赛]PWN5 //格式化字符串漏洞 - Nemuzuki - 博客园 (cnblogs.com) 格式化字符串漏洞原理详解_printf 任意内存读取-CSDN博客 32位小端排序&#xff0c;有栈溢出保护 运行效果&#xff1a; 查看main函数 存在格式化字符串漏洞 输…
阅读更多...
Ubuntu 22.04.4 LTS 安装配置 MySQL Community Server 8.0.37 LTS

Ubuntu 22.04.4 LTS 安装配置 MySQL Community Server 8.0.37 LTS

1 安装mysql-server sudo apt update sudo apt-get install mysql-server 2 启动mysql服务 sudo systemctl restart mysql.service sudo systemctl enable mysql.service #查看服务 sudo systemctl status mysql.service 3 修改mysql root密码 #默认密码为空 sudo mysql …
阅读更多...
数据结构(3.8)——栈的应用

数据结构(3.8)——栈的应用

栈在括号匹配中的应用 流程图 代码 #include <stdio.h> #include <stdlib.h> #define MaxSize 10typedef struct {char data[MaxSize];int top; } SqStack;// 初始化栈 void InitStack(SqStack* S) {S->top -1; // 初始化栈顶指针 }// 判空 bool StackEmpty(…
阅读更多...
在线签约如何选择？2024年10款顶级app大比拼

在线签约如何选择？2024年10款顶级app大比拼

支持电子合同签约的10大app&#xff1a;e签宝、上上签、DocuSign、契约锁、Adobe Sign、法大大、SignNow、安心签、HelloSign、PandaDoc。 无论是企业之间的交易还是个人服务合同&#xff0c;线上电子合同签约提供了一种便捷、高效且安全的方式来处理法律文档。本文将介绍几款优…
阅读更多...
什么是YUV和IPB，PTS和DTS，视频编码解码过程

什么是YUV和IPB，PTS和DTS，视频编码解码过程

YUV 是一种在视频处理和压缩中常用的颜色空间。 它将图像的亮度 (Y) 与色度 (U 和 V) 成分分开。 这种分离对视频压缩和广播非常有益&#xff0c; 因为人眼对亮度变化比对颜色变化更敏感。 YUV 组件简介 Y (亮度)&#xff1a;表示图像的亮度或灰度信息。U (色度)&#xff1a;…
阅读更多...
泛微开发修炼之旅--29用计划任务定时发送邮件提醒

泛微开发修炼之旅--29用计划任务定时发送邮件提醒

文章链接&#xff1a;29用计划任务定时发送邮件提醒
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023