flask的进阶使用方法

已于 2024-07-04 23:31:26 修改
阅读量195 收藏 3
点赞数 3
文章标签： flask ios python
于 2024-07-04 23:30:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58310590/article/details/140138902
版权

【 一 】一对多关系

# 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

m0_58310590
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
闪存flash进阶知识
Zuoerfeng
12-17 4029
这一章关于闪存主要是SLC, MLC, TLC, 3D flash的比较，主要点如下： 1、FLASH的写步骤ISPP 2、在写数据之前要进行随机化编码 3、slc、mlc、tlc性能的比较 4、一个具体的flash读写的体系结构 5、目前定义的flash的IO接口规范 6、ssd里面并行性的体现 7、mlc为什么要采用格雷编码 8、tlc的三步编程操作 9、3D FLASH的相关特性 下面分...
Flask 进阶
XWenXiang的博客
08-11 572
flask 信号
flask 之进阶
wahaha
08-22 341
一.flask之路由 url_for方向解析路由 1.一个装饰器 @app.route('/') 1.end point没有指定时默认为函数的名endpoint='index' 就反向解析到路由 'index'----> '/' def index(): 2.指定endpoint = '...
Flask入门（非常详细）零基础入门到精通，收藏这一篇就够了
Python_paipai的博客
03-01 1843
Flask是基于Werkzeug，Jinja2的Python微框架，有很多内容和Django类似，特别是在模块渲染方面，还有包括if、for等语法和python代码的引用，如：{% %}和{{ }}等等，但是其中对于url的设置则是全新的，开启服务调用函数也要轻便不少。上述代码中，index()函数并没有直接返回字符串，而是使用render_template()方法来渲染模板，该方法的第一个参数"index.html"是渲染模板的名称，第二个参数“page_id”是要传递到渲染模板的变量，可以传多个变量。
Python轻量级Web框架Flask（10）——Flask进阶知识（caching插件和Flask自带的钩子函数）
sz1125218970的博客
04-21 1241
Flask插件可以去官网查看，有很多。插件安装流程：1、通过pip指令在对应环境中下载插件2、在项目的exts.py文件中初始化3、使用这个插件是一个和缓存相关的插件，缓存经常用来保留那些经常被访问的临时数据。
Python 之 Flask框架（进阶版）
最新发布
masterphp的博客
05-13 769
FlASK是一个轻量级的WSGI Web应用程序框架，Flask的核心包括Werkzeug工具箱和Jinja2模板引擎，它没有默认使用的数据库或窗体验证工具，这意味着用户可以根据自己的需求选择不同的数据库和验证工具。Flask的设计理念是保持核心简单，同时提供强大的扩展性，用户可以通过添加各种扩展来增加功能，如邮件发送、用户认证、数据库集成等pip升级命令：python -m pip install --upgrade pipFlask要求Python的版本在3.4以上。本文讲解flask框架进阶用法
flash进阶课程
01-18
《Flash进阶课程详解》 在数字化媒体领域，Flash曾是制作动态网页、交互式动画、游戏和在线应用程序的重要工具。本"Flash进阶课程"旨在深入探讨Flash的各项功能，帮助用户从基础知识过渡到高级应用，提升创作能力。...
flash入门与进阶教程
07-14
《Flash入门与进阶教程》是一份全面介绍Adobe Flash技术的教育资源，旨在帮助初学者快速掌握基础，并逐步提升到高级技能水平。这份教程涵盖了Flash的基础概念、操作界面、动画制作、交互设计以及发布设置等多个重要...
flash进阶 初学者最好的学习资料
12-29
《Flash进阶：初学者的最佳学习资源》 Flash，作为一款经典的动画制作和交互设计工具，深受初学者和专业人士的喜爱。对于那些希望深入探索Flash世界的新手来说，掌握其基本方法和技巧至关重要。本篇文章将根据提供...
flash图表进阶
11-29
这份文档详细介绍了FusionCharts的使用方法，包括如何在网页中嵌入图表、设置图表属性、处理数据源、自定义图表元素等。通过阅读，开发者可以掌握如何快速上手并创建出符合需求的图表。 **3. FusionCharts二次开发...
Flask快速入门与进阶
xiongsheng
03-26 1708
欢迎来到Flask的世界 1. Flask介绍 Flask诞生于2010年，是Armin ronacher 用 Python 语言基于 Werkzeug 工具箱编写的轻量级Web开发框架。 Flask是一个使用 Python 编写的轻量级 Web 应用框架。其 WSGI 工具箱采用 Werkzeug ，模板引擎则使用 Jinja2 。Flask使用 BSD 授权。Flask也被称为 “microframework” ，因为它使用简单的核心，用 extension 增加其他功能。Flask没有默认使用的数据库
【flask-进阶1】
alexliu2360的专栏
04-12 239
工具：postman 2.6最小原型与唯一URL原则 在flask中视图函数等价于MVC中的control 基于类的视图(即插视图) 路由的时候将不带’/’的地址重定向为带’/’的地址 (1) @app.route(‘/hello’) def fun(): pass 如果访问的地址为’localhost:5000/hello’，此时可以访问到 如果地址为’localho...
Python Flask框架（进阶1）
xiabenshu的博客
04-05 1258
项目布局 创建一个目录。 简单的flask只有一个文件。 然而，随着项目变得越来越大，将所有代码保存在一个文件中就变得非常困难。Python项目使用包将代码组织成多个模块，这些模块可以在需要时导入。 项目目录将包含: flaskr/, 一个包含应用程序代码和文件的python包。 tests/, 一个包含测试模块的目录。 venv/,一个python虚拟环境，其中安装了flask和其他以来项目。...
flask 进阶：准备
weixin_43690442的博客
04-10 183
鸽了好长时间，没有学习和更新flask web的项目 今天又开始学习 首先在项目开始之前我们要处理好包结构 一般的包结构为 举例我们将要开始的blog blog |____ | forms 表单包 | ------init.py | ------xxx.py | models 模板包 | ------init.py | ------xxx.py | static 静态文件包 | ------ini...
flask入门和进阶三（个人资料和头像）
spider_man
08-22 509
用户个人资料页面 要创建一个用户个人资料页面，首先编写一个映射到/user/<username>URL的新视图函数。 这个由@app.route装饰器下声明的视图函数看起来与前面的有点不同。在这个示例下，有一个动态组件，它被作为<username>URL组件 表示，并由<和>包围。当路由有动态组件时，Flask将接受URL部分中的任何文本，并将以实际...
Flask进阶
人的愤怒都是因为自己的无能。
06-27 531
每次请求之间都是独立的 - URL路径参数（动态路由） @app.route('/users/<user_id>') # 此处的<>就是一个转换器，默认为字符串类型，将该位置的数据以字符串格式进行匹配、并以字符串为数据类型类型、 user_id为参数名传入视图。 def user_info(user_id): print(type(user_id)) ...
flask 起步入门与强化进阶
那么的博客
09-09 528
flask 在学习python 的 flask 过程中,遇到了许多麻烦,个人感觉最有帮助的一本书就是 《Flask web 开发》这本书基本覆盖了所有flask基础知识. github上有个很好的新手项目 这是个完整的web网站实现,只要下载代码立马就能实现完整的一个web网站. 我自己就是跟着这个项目一步步进阶的,难度适宜且作者很友好,问的不少问题都积极回答. 大致的理解了这个...
PowerPoint使用技巧：进阶操作指南
5. 让文字闪烁不停: 虽然PowerPoint自带的“自定义动画”无法实现持续闪烁，但用户可以探索其他方法，如使用第三方插件或动画软件来创建连续闪烁效果。 6. 其他未详述的技巧包括: - 放映时进到下一张幻灯片，可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值