Flask插件

flask-session

下载
```
pip install Flask-session
```
导入
```
from flask_session import Session
```

实例化session

在__init__文件中

def create_app():

	app = Flask(__name__)

	Session(app)

	return app

配置文件
```
SESSION_TYPE = 'redis'
```
用法和内置session一样
实现原理
- 内置的session调用 session_interface = xxxx
  - xxxx.open_session 解密cookie转化成字典给session
  - xxxx.save_session 将session加密给cookie
- Flask-session 修改session_interface 制定的类
  - 来改变session存储的位置

SQLALchemy

创建连接

from sqlalchemy import create_engine

conn = create_engine(

    # 'mysql+pymysql://rout用户:密码@连接地址:端口号/数据库名?charset=编码方式'

	'mysql+pymysql://root:123@127.0.0.1:3306/day103?charset=ustf8',

    max_overflow = 0,   # 超过连接池大小外最多创建的连接数

    pool_size = 5,	# 连接池大小

    pool_timeout=30,	# 连接池中没有线程最多等待时间,否则报错

    pool_recycle=-1,	# 多久之后对连接池中的连接进行回收(重置), -1不回收

)

如何创建表

导入

from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

单表创建

class Book(Base):

   __tablename__ = "book"

   id = Column(Integer, primary_key=True)

   title = Column(String(32), nullable=False，index=True)

   def __repr__(self):

      return self.title

   __table_args__ = (

      # 联合唯一

      UniqueConstraint("id", "title", name="uni_id_title"),

      # 联合索引

      Index("id", "title")

   )

from sqlalchemy import create_engine

from sqlalchemy.ext.declarative import declarative_base

from sqlalchemy import Column, Integer, String, DateTime

from sqlalchemy import Index, UniqueConstraint

import datetime

# 连接数据库

ENGINE = create_engine("mysql+pymysql://root:root1234@127.0.0.1:3306/code_record?charset=utf8",)

# 实例化

Base = declarative_base()

# 创建单表,继承Base

class UserInfo(Base):

    __tablename__ = "user_info"

    id = Column(Integer, primary_key=True)

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

    email = Column(String(32), unique=True)

    create_time = Column(DateTime, default=datetime.datetime.now)

# 类似与django中的class Meta, 针对于本表

    __table_args__ = (

        # 设置联合唯一

        UniqueConstraint("id", "name", name="uni_id_name"),

        # 设置联合索引

        Index("name", "email")

    )

# 函数,方便创建表

def create_db():

    Base.metadata.create_all(ENGINE)

# 方便删除

def drop_db():

    Base.metadata.drop_all(ENGINE)

if __name__ == '__main__':

    # 执行

    create_db()

一对多表创建

class Book(Base):

   __tablename__ = "book"

   id = Column(Integer, primary_key=True)

   title = Column(String(32), nullable=False)

   publisher_id = Column(Integer, ForeignKey("publisher.id"))

   # 不生成字段建立关系 方便操作

   # 一对多

   publisher = relationship("Publisher", backref="books")

from sqlalchemy import create_engine

from sqlalchemy.ext.declarative import declarative_base

from sqlalchemy import Column, Integer, String, DateTime

from sqlalchemy import Index, UniqueConstraint, ForeignKey

from sqlalchemy.orm import relationship

import datetime

ENGINE = create_engine("mysql+pymysql://root:root1234@127.0.0.1:3306/code_record?charset=utf8",)

Base = declarative_base()

# ======一对多示例=======

class UserInfo(Base):

    __tablename__ = "user_info"

    id = Column(Integer, primary_key=True)

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

    email = Column(String(32), unique=True)

    create_time = Column(DateTime, default=datetime.datetime.now)

    # FK字段的建立

    hobby_id = Column(Integer, ForeignKey("hobby.id"))

    # 不生成表结构 方便查询使用

    hobby = relationship("Hobby", backref="user")

    __table_args__ = (

        UniqueConstraint("id", "name", name="uni_id_name"),

        Index("name", "email")

    )

class Hobby(Base):

    __tablename__ = "hobby"

    id = Column(Integer, primary_key=True)

    title = Column(String(32), default="码代码")

def create_db():

    Base.metadata.create_all(ENGINE)

def drop_db():

    Base.metadata.drop_all(ENGINE)

if __name__ == '__main__':

    create_db()

    # drop_db()

多对对创建

第三张表自己生成

class Book(Base):

   __tablename__ = "book"

   id = Column(Integer, primary_key=True)

   title = Column(String(32), nullable=False)

   publisher_id = Column(Integer, ForeignKey("publisher.id"))

   # 不生成字段建立关系 方便操作

   # 一对多

   publisher = relationship("Publisher", backref="books")

   # 多对多

   tags = relationship("Tag", secondary="book2tag", backref="books")

class Book2Tag(Base):

   __tablename__ = "book2tag"

   id = Column(Integer, primary_key=True)

   book_id = Column(Integer, ForeignKey("book.id"))

   tag_id = Column(Integer, ForeignKey("tag.id"))

from sqlalchemy import create_engine

from sqlalchemy.ext.declarative import declarative_base

from sqlalchemy import Column, Integer, String, DateTime

from sqlalchemy import Index, UniqueConstraint, ForeignKey

from sqlalchemy.orm import relationship

import datetime

ENGINE = create_engine("mysql+pymysql://root:root1234@127.0.0.1:3306/code_record?charset=utf8",)

Base = declarative_base()

# ======多对多示例=======

class Book(Base):

    __tablename__ = "book"

    id = Column(Integer, primary_key=True)

    title = Column(String(32))

    # 不生成表字段 仅用于查询方便

    tags = relationship("Tag", secondary="book2tag", backref="books")

class Tag(Base):

    __tablename__ = "tag"

    id = Column(Integer, primary_key=True)

    title = Column(String(32))

class Book2Tag(Base):

    __tablename__ = "book2tag"

    id = Column(Integer, primary_key=True)

    book_id = Column(Integer, ForeignKey("book.id"))

    tag_id = Column(Integer, ForeignKey("tag.id"))

def create_db():

    Base.metadata.create_all(ENGINE)

def drop_db():

    Base.metadata.drop_all(ENGINE)

if __name__ == '__main__':

    create_db()

    # drop_db()

创建表命令

Base.metadata.create_all(conn) # conn是连接池对象

对数据库表的操作(增删改查)

创建管理器

from sqlalchemy.orm import sessionmaker, scoped_session

Session = sessionmaker(bind=conn)

# 线程安全 根本本地线程会使用一个session

session = scoped_session(Session)

from sqlalchemy import create_engine

from sqlalchemy.orm import sessionmaker, scoped_session

from models_demo import Tag

ENGINE = create_engine("mysql+pymysql://root:root1234@127.0.0.1:3306/code_record?charset=utf8",)

Session = sessionmaker(bind=ENGINE)

# 每次执行数据库操作的时候，都需要创建一个session

# 线程安全，基于本地线程实现每个线程用同一个session

session = scoped_session(Session)

# =======执行ORM操作==========

tag_obj = Tag(title="SQLAlchemy")

# 添加

session.add(tag_obj)

# 提交

session.commit()

# 关闭session

session.close()

基本增删改查

from sqlalchemy import create_engine

from sqlalchemy.orm import sessionmaker, scoped_session

from models_demo import Tag, UserInfo

import threading

ENGINE = create_engine("mysql+pymysql://root:root1234@127.0.0.1:3306/code_record?charset=utf8",)

Session = sessionmaker(bind=ENGINE)

# 每次执行数据库操作的时候，都需要创建一个session

session = Session()

session = scoped_session(Session)

# ============添加============

# tag_obj = Tag(title="SQLAlchemy")

# # 添加

# session.add(tag_obj)

# session.add_all([

#     Tag(title="Python"),

#     Tag(title="Django"),

# ])

# # 提交

# session.commit()

# # 关闭session

# session.close()

# ============基础查询============

# ret1 = session.query(Tag).all()

# ret2 = session.query(Tag).filter(Tag.title == "Python").all()

# ret3 = session.query(Tag).filter_by(title="Python").all()

# ret4 = session.query(Tag).filter_by(title="Python").first()

# print(ret1, ret2, ret3, ret4)

# ============删除===========

# session.query(Tag).filter_by(id=1).delete()

# session.commit()

# ===========修改===========

session.query(Tag).filter_by(id=22).update({Tag.title: "LOL"})

session.query(Tag).filter_by(id=23).update({"title": "王者毒药"})

session.query(Tag).filter_by(id=24).update({"title": Tag.title + "~"}, synchronize_session=False)

# synchronize_session="evaluate" 默认值进行数字加减

session.commit()

常用操作

# 条件查询

ret1 = session.query(Tag).filter_by(id=22).first()

ret2 = session.query(Tag).filter(Tag.id > 1, Tag.title == "LOL").all()

ret3 = session.query(Tag).filter(Tag.id.between(22, 24)).all()

ret4 = session.query(Tag).filter(~Tag.id.in_([22, 24])).first()

from sqlalchemy import and_, or_

ret5 = session.query(Tag).filter(and_(Tag.id > 1, Tag.title == "LOL")).first()

ret6 = session.query(Tag).filter(or_(Tag.id > 1, Tag.title == "LOL")).first()

ret7 = session.query(Tag).filter(or_(

    Tag.id>1,

    and_(Tag.id>3, Tag.title=="LOL")

)).all()

# 通配符

ret8 = session.query(Tag).filter(Tag.title.like("L%")).all()

ret9 = session.query(Tag).filter(~Tag.title.like("L%")).all()

# 限制

ret10 = session.query(Tag).filter(~Tag.title.like("L%")).all()[1:2]

# 排序

ret11 = session.query(Tag).order_by(Tag.id.desc()).all()  # 倒序

ret12 = session.query(Tag).order_by(Tag.id.asc()).all()  # 正序

# 分组

ret13 = session.query(Tag.test).group_by(Tag.test).all()

# 聚合函数

from sqlalchemy.sql import func

ret14 = session.query(

    func.max(Tag.id),

    func.sum(Tag.test),

    func.min(Tag.id)

).group_by(Tag.title).having(func.max(Tag.id > 22)).all()

# 连表

ret15 = session.query(UserInfo, Hobby).filter(UserInfo.hobby_id == Hobby.id).all()

# print(ret15) 得到一个列表套元组 元组里是两个对象

ret16 = session.query(UserInfo).join(Hobby).all()

# print(ret16) 得到列表里面是前一个对象

# 相当于inner join

# for i in ret16:

#     # print(i[0].name, i[1].title)

#     print(i.hobby.title)

ret17 = session.query(Hobby).join(UserInfo, isouter=True).all()

ret17_1 = session.query(UserInfo).join(Hobby, isouter=True).all()

ret18 = session.query(Hobby).outerjoin(UserInfo).all()

ret18_1 = session.query(UserInfo).outerjoin(Hobby).all()

# 相当于left join

print(ret17)

print(ret17_1)

print(ret18)

print(ret18_1)

基于relationship的Fk

# 基于relationship的FK

# 添加

user_obj = UserInfo(name="提莫", hobby=Hobby(title="种蘑菇"))

session.add(user_obj)

hobby = Hobby(title="弹奏一曲")

hobby.user = [UserInfo(name="琴女"), UserInfo(name="妹纸")]

session.add(hobby)

session.commit()

# 基于relationship的正向查询

user_obj_1 = session.query(UserInfo).first()

print(user_obj_1.name)

print(user_obj_1.hobby.title)

# 基于relationship的反向查询

hb = session.query(Hobby).first()

print(hb.title)

for i in hb.user:

    print(i.name)

session.close()

基于relationship的M2M

# 添加

book_obj = Book(title="Python源码剖析")

tag_obj = Tag(title="Python")

b2t = Book2Tag(book_id=book_obj.id, tag_id=tag_obj.id)

session.add_all([

    book_obj,

    tag_obj,

    b2t,

])

session.commit()

#  上面有坑哦~~~~

book = Book(title="测试")

book.tags = [Tag(title="测试标签1"), Tag(title="测试标签2")]

session.add(book)

session.commit()

tag = Tag(title="LOL")

tag.books = [Book(title="大龙刷新时间"), Book(title="小龙刷新时间")]

session.add(tag)

session.commit()

# 基于relationship的正向查询

book_obj = session.query(Book).filter_by(id=4).first()

print(book_obj.title)

print(book_obj.tags)

# 基于relationship的反向查询

tag_obj = session.query(Tag).first()

print(tag_obj.title)

print(tag_obj.books)

Flask_Script

下载
```
pip install flask-script
```

导入

from flask_demo import create_app

from flask_script import Manager

实例化

app = create_app()

# 实例化

manager = Manager(app)

if __name__ == '__main__':

   # app.run()

   manager.run()

自定义的命令

位置传参

@manager.command

	def mycommad(arg):

        prin(arg)

    # python manange.py my_command 123

关键字

@manager.option('-n','--name', dest='name')

@manager.option('-u','--url', dest='url')

def cmd(name, url):

	print(name, url)

# python manager.py cmd -n xiatian -u www.xxx

详细用法:https://www.cnblogs.com/buyisan/p/8270283.html

Flask-Migrate

!!! 依赖flask-script
下载
```
pip install flask-migrate
```

导入

from flask_Migrate import Migrate, MigrateCommand

实例化

Migrate(app)

manager.add_command('db', MigrateCommand)

"""

	python manager.py db init

	python manager.py db migrate # 类型于makemigrations

	python manager.py db uprade  # migrate

"""

师博客:

https://www.cnblogs.com/GGGG-XXXX/articles/9447619.html

FLask插件的更多相关文章

Flask插件wtforms、Flask文件上传和Echarts柱状图
一.wtforms 类比Django的Form组件Form组件的主要应用是帮助我们自动生成HTML代码和做一些表单数据的验证 flask的wtforms用法跟Form组件大同小异参考文章:https: ...
flask插件系列之flask_uploads上传文件
前言 flask可以实现上传文件和下载文件的基本功能,但如果想要健壮的功能,使用flask_uploads插件是十分方便的. 安装 pip install flask_uploads 基本使用 # e ...
flask插件系列之flask_caching缓存
前言为了尽量减少缓存穿透,同时减少web的响应时间,我们可以针对那些需要一定时间才能获取结果的函数和那些不需要频繁更新的视图函数提供缓存服务,可以在一定的时间内直接返回结果而不是每次都需要计算或者从 ...
flask插件系列之flask_session会话机制
flask_session是flask框架实现session功能的一个插件,用来替代flask自带的session实现机制. 配置参数详解 SESSION_COOKIE_NAME 设置返回给客户端的c ...
在SAE上使用Flask插件
因为我之前学习的时候使用的是虚拟环境,下载的所有需要用到的插件都在flask这个文件夹里面,SAE上Flask的版本和我本地用的版本对不上,导致有时候import都不对,于是我就把本地的环境直接放到S ...
flask插件全家桶集成学习---持续更新ing
不得不说flask的设计要比django要小巧精妙的多了,没有那么臃肿,只保留核心功能,其他的都需要自己引入,即各种各样的插件来满足我们的需求,我这里记录一下自己学习项目中用的插件使用方法和一些技巧总 ...
flask插件系列之Flask-WTF表单
flask_wtf是flask框架的表单验证模块,可以很方便生成表单,也可以当做json数据交互的验证工具,支持热插拔. 安装 pip install Flask-WTF Flask-WTF其实是对w ...
flask插件系列之flask_restful设计API
前言 flask框架默认的路由和视图函数映射规则是通过在视图函数上直接添加路由装饰器来实现的,这使得路由和视图函数的对应关系变得清晰,但对于统一的API开发就变得不怎么美妙了,尤其是当路由接口足够多的 ...
flask插件系列之flask_celery异步任务神器
现在继续学习在集成的框架中如何使用celery. 在Flask中使用celery 在Flask中集成celery需要做到两点: 创建celery的实例对象的名字必须是flask应用程序app的名字,否 ...

随机推荐

Spring IOC-基于XML配置的容器
Spring IOC-基于XML配置的容器我们先分析一下AbstractXmlApplicationContext这个容器的加载过程. AbstractXmlApplicationContext的老 ...
大地坐标BLH转平面坐标xyh(高斯投影坐标正算) Java版
技术背景做过位置数据处理的小伙伴基本上都会遇到坐标转换,而基于高斯投影原理的大地坐标转平面坐标就是其中一种坐标转换,坐标转换的目的就是方便后面数据的处理工作,大地坐标转高斯平面坐标常用的有两种,即3 ...
5、Linux基础--etc（文件系统）、启动模式、单用户模式修改密码、安装目录、日志目录、状态目录
笔记 1.晨考 1.存放系统配置文件的目录 /etc 2.存储系统实时运行状态的目录 /proc 3.存储系统硬件接口的目录 /dev 4.查看系统挂载情况的命令 df -h 5.系统网卡文件路径 / ...
详解Spring DI循环依赖实现机制
一个对象引用另一个对象递归注入属性即可实现后续的实例化,同时如果两个或者两个以上的 Bean 互相持有对⽅,最终形成闭环即所谓的循环依赖怎么实现呢属性的互相注入呢? Spring bean生命周期具体 ...
图解python | for循环
作者:韩信子@ShowMeAI 教程地址:http://www.showmeai.tech/tutorials/56 本文地址:http://www.showmeai.tech/article-det ...
一位资深IT技术员的心声
引言我对于本科时光的印象,还停留在那所普通 211 大学的建筑物之间,我坐在大学的时光长廊里,满眼望去,都是经历的过的故事.可毕业后回首,却很少有人能说,自己从来没有迷茫过.迷茫,仿佛就是一团乌云, ...
更快的网络文件系統 — Oxfs
什麽时候需要网络文件系统 ? 做嵌入式的同学经常会使用 NFS 将 host 上的某个目录挂载到开发板上,方便 host 上编译构建后能直接在板子上运行,减少手工拷贝操作.网站开发时,在 host 上 ...
WPF中RichTextBox中添加文字的两种方法
RichTextBox控件不同于TextBox控件,后者可以直接通过其Text属性绑定或者在后台动态添加文字. (一)使用数据绑定 <RichTextBox FontSize="12& ...
Java高级部分概要笔记
复习多线程程序.进程.线程的概念.区别并行.并发创建线程的四种方式:继承Thread.实现Runnable接口.实现Callable接口.线程池线程的生命周期线程的同步方式,三种:同步方法 ...
ElementUI Tree树形控件renderContent return时报错
问题描述: 使用Tree树形控件使用render-content渲染时return后报错或npm run dev时候报错,报错信息相同,如下: 问题分析: renderContent函数中需要使用js ...

FLask插件

Flask插件

flask-session

SQLALchemy

创建连接

如何创建表

对数据库表的操作(增删改查)

Flask_Script

Flask-Migrate

师博客:

FLask插件的更多相关文章

随机推荐

热门专题