python 全栈开发，Day141(flask之应用上下文,SQLAlchemy)

最新推荐文章于 2024-09-30 10:46:34 发布
最新推荐文章于 2024-09-30 10:46:34 发布
阅读量221 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shykevin/article/details/90103109
版权

python 全栈开发，Day141(flask之应用上下文,SQLAlchemy)

 

一、flask之应用上下文

由于时间关系，详细过程略...

草稿图

 

 

参考链接：

http://www.cnblogs.com/zhaopanpan/p/9457343.html

 

总结：

上下文管理（应用上下文）
关键点
请求上线文:
ctx = RequestContext(request/session)
应用上下文:
app_ctx = AppContext(app/g)

问：flask中g的作用？一次请求周期中保存一个公用值。

g应用示例：
    from flask import Flask,request,session,g,current_app

    app = Flask(__name__)

    @app.before_request
    def b1():
        g.x1 = 123


    @app.route('/index')
    def index():
        print(g.x1)

    if __name__ == '__main__':
        app.run()
View Code

 

二、SQLAlchemy

介绍

SQLAlchemy是一个基于Python实现的ORM框架。该框架建立在 DB API之上，使用关系对象映射进行数据库操作，简言之便是：将类和对象转换成SQL，然后使用数据API执行SQL并获取执行结果。

pip3 install sqlalchemy

流程图

组成部分

  • Engine，框架的引擎
  • Connection Pooling ，数据库连接池
  • Dialect，选择连接数据库的DB API种类
  • Schema/Types，架构和类型
  • SQL Exprression Language，SQL表达式语言

SQLAlchemy本身无法操作数据库，其必须以来pymsql等第三方插件，Dialect用于和数据API进行交流，根据配置文件的不同调用不同的数据库API，从而实现对数据库的操作，如：

MySQL-Python
    mysql+mysqldb://<user>:<password>@<host>[:<port>]/<dbname>
    
pymysql
    mysql+pymysql://<username>:<password>@<host>/<dbname>[?<options>]
    
MySQL-Connector
    mysql+mysqlconnector://<user>:<password>@<host>[:<port>]/<dbname>
    
cx_Oracle
    oracle+cx_oracle://user:pass@host:port/dbname[?key=value&key=value...]
    
更多：http://docs.sqlalchemy.org/en/latest/dialects/index.html

 

使用

1. 执行原生SQL语句

举例1

import time
import threading
import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.engine.base import Engine
 
engine = create_engine(
    "mysql+pymysql://root:123@127.0.0.1:3306/t1?charset=utf8",
    max_overflow=0,  # 超过连接池大小外最多创建的连接
    pool_size=5,  # 连接池大小
    pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错
    pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）
)
 
 
def task(arg):
    conn = engine.raw_connection()
    cursor = conn.cursor()
    cursor.execute(
        "select * from t1"
    )
    result = cursor.fetchall()
    cursor.close()
    conn.close()
 
 
for i in range(20):
    t = threading.Thread(target=task, args=(i,))
    t.start()
View Code

 

举例2

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import time
import threading
import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.engine.base import Engine

engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/t1", max_overflow=0, pool_size=5)


def task(arg):
    conn = engine.contextual_connect()
    with conn:
        cur = conn.execute(
            "select * from t1"
        )
        result = cur.fetchall()
        print(result)


for i in range(20):
    t = threading.Thread(target=task, args=(i,))
    t.start()
View Code

 

举例3

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import time
import threading
import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.engine.base import Engine
from sqlalchemy.engine.result import ResultProxy
engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/t1", max_overflow=0, pool_size=5)


def task(arg):
    cur = engine.execute("select * from t1")
    result = cur.fetchall()
    cur.close()
    print(result)


for i in range(20):
    t = threading.Thread(target=task, args=(i,))
    t.start()
View Code

注意: 查看连接 show status like 'Threads%';

 

2. ORM

a. 创建数据库表

创建单表
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import datetime
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, Text, ForeignKey, DateTime, UniqueConstraint, Index

Base = declarative_base()


class Users(Base):
    __tablename__ = 'users'

    id = Column(Integer, primary_key=True)
    name = Column(String(32), index=True, nullable=False)
    # email = Column(String(32), unique=True)
    # ctime = Column(DateTime, default=datetime.datetime.now)
    # extra = Column(Text, nullable=True)

    __table_args__ = (
        # UniqueConstraint('id', 'name', name='uix_id_name'),
        # Index('ix_id_name', 'name', 'email'),
    )


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

    Base.metadata.create_all(engine)


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

    Base.metadata.drop_all(engine)


if __name__ == '__main__':
    drop_db()
    init_db()

创建单表
View Code

 

创建多个表并包含Fk、M2M关系
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import datetime
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, Text, ForeignKey, DateTime, UniqueConstraint, Index
from sqlalchemy.orm import relationship

Base = declarative_base()


# ##################### 单表示例 #########################
class Users(Base):
    __tablename__ = 'users'

    id = Column(Integer, primary_key=True)
    name = Column(String(32), index=True)
    age = Column(Integer, default=18)
    email = Column(String(32), unique=True)
    ctime = Column(DateTime, default=datetime.datetime.now)
    extra = Column(Text, nullable=True)

    __table_args__ = (
        # UniqueConstraint('id', 'name', name='uix_id_name'),
        # Index('ix_id_name', 'name', 'extra'),
    )


class Hosts(Base):
    __tablename__ = 'hosts'

    id = Column(Integer, primary_key=True)
    name = Column(String(32), index=True)
    ctime = Column(DateTime, default=datetime.datetime.now)


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


class Person(Base):
    __tablename__ = 'person'
    nid = Column(Integer, primary_key=True)
    name = Column(String(32), index=True, nullable=True)
    hobby_id = Column(Integer, ForeignKey("hobby.id"))

    # 与生成表结构无关，仅用于查询方便
    hobby = relationship("Hobby", backref='pers')


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

class Server2Group(Base):
    __tablename__ = 'server2group'
    id = Column(Integer, primary_key=True, autoincrement=True)
    server_id = Column(Integer, ForeignKey('server.id'))
    group_id = Column(Integer, ForeignKey('group.id'))


class Group(Base):
    __tablename__ = 'group'
    id = Column(Integer, primary_key=True)
    name = Column(String(64), unique=True, nullable=False)

    # 与生成表结构无关，仅用于查询方便
    servers = relationship('Server', secondary='server2group', backref='groups')


class Server(Base):
    __tablename__ = 'server'

    id = Column(Integer, primary_key=True, autoincrement=True)
    hostname = Column(String(64), unique=True, nullable=False)


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

    Base.metadata.create_all(engine)


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

    Base.metadata.drop_all(engine)


if __name__ == '__main__':
    drop_db()
    init_db()

创建多个表并包含Fk、M2M关系
View Code

指定关联列：hobby = relationship("Hobby", backref='pers',foreign_keys="Person.hobby_id")

 

b. 操作数据库表

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine
from models import Users
  
engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/s6", max_overflow=0, pool_size=5)
Session = sessionmaker(bind=engine)
  
# 每次执行数据库操作时，都需要创建一个session
session = Session()
  
# ############# 执行ORM操作 #############
obj1 = Users(name="alex1")
session.add(obj1)
  
# 提交事务
session.commit()
# 关闭session
session.close()
View Code

 

基于scoped_session实现线程安全
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine
from sqlalchemy.orm import scoped_session
from models import Users

engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/s6", max_overflow=0, pool_size=5)
Session = sessionmaker(bind=engine)

"""
# 线程安全，基于本地线程实现每个线程用同一个session
# 特殊的：scoped_session中有原来方法的Session中的一下方法：

public_methods = (
    '__contains__', '__iter__', 'add', 'add_all', 'begin', 'begin_nested',
    'close', 'commit', 'connection', 'delete', 'execute', 'expire',
    'expire_all', 'expunge', 'expunge_all', 'flush', 'get_bind',
    'is_modified', 'bulk_save_objects', 'bulk_insert_mappings',
    'bulk_update_mappings',
    'merge', 'query', 'refresh', 'rollback',
    'scalar'
)
"""
session = scoped_session(Session)


# ############# 执行ORM操作 #############
obj1 = Users(name="alex1")
session.add(obj1)



# 提交事务
session.commit()
# 关闭session
session.close()

基于scoped_session实现线程安全
View Code

 

多线程执行示例
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import time
import threading

from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import create_engine
from db import Users

engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/s6", max_overflow=0, pool_size=5)
Session = sessionmaker(bind=engine)


def task(arg):
    session = Session()

    obj1 = Users(name="alex1")
    session.add(obj1)

    session.commit()


for i in range(10):
    t = threading.Thread(target=task, args=(i,))
    t.start()

多线程执行示例
View Code

 

基本增删改查示例
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import time
import threading

from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import create_engine
from sqlalchemy.sql import text

from db import Users, Hosts

engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/s6", max_overflow=0, pool_size=5)
Session = sessionmaker(bind=engine)

session = Session()

# ################ 添加 ################
"""
obj1 = Users(name="wupeiqi")
session.add(obj1)

session.add_all([
    Users(name="wupeiqi"),
    Users(name="alex"),
    Hosts(name="c1.com"),
])
session.commit()
"""

# ################ 删除 ################
"""
session.query(Users).filter(Users.id > 2).delete()
session.commit()
"""
# ################ 修改 ################
"""
session.query(Users).filter(Users.id > 0).update({"name" : "099"})
session.query(Users).filter(Users.id > 0).update({Users.name: Users.name + "099"}, synchronize_session=False)
session.query(Users).filter(Users.id > 0).update({"age": Users.age + 1}, synchronize_session="evaluate")
session.commit()
"""
# ################ 查询 ################
"""
r1 = session.query(Users).all()
r2 = session.query(Users.name.label('xx'), Users.age).all()
r3 = session.query(Users).filter(Users.name == "alex").all()
r4 = session.query(Users).filter_by(name='alex').all()
r5 = session.query(Users).filter_by(name='alex').first()
r6 = session.query(Users).filter(text("id<:value and name=:name")).params(value=224, name='fred').order_by(Users.id).all()
r7 = session.query(Users).from_statement(text("SELECT * FROM users where name=:name")).params(name='ed').all()
"""


session.close()

基本增删改查示例
View Code

 

常用操作
#　条件
ret = session.query(Users).filter_by(name='alex').all()
ret = session.query(Users).filter(Users.id > 1, Users.name == 'eric').all()
ret = session.query(Users).filter(Users.id.between(1, 3), Users.name == 'eric').all()
ret = session.query(Users).filter(Users.id.in_([1,3,4])).all()
ret = session.query(Users).filter(~Users.id.in_([1,3,4])).all()
ret = session.query(Users).filter(Users.id.in_(session.query(Users.id).filter_by(name='eric'))).all()
from sqlalchemy import and_, or_
ret = session.query(Users).filter(and_(Users.id > 3, Users.name == 'eric')).all()
ret = session.query(Users).filter(or_(Users.id < 2, Users.name == 'eric')).all()
ret = session.query(Users).filter(
    or_(
        Users.id < 2,
        and_(Users.name == 'eric', Users.id > 3),
        Users.extra != ""
    )).all()


# 通配符
ret = session.query(Users).filter(Users.name.like('e%')).all()
ret = session.query(Users).filter(~Users.name.like('e%')).all()

# 限制
ret = session.query(Users)[1:2]

# 排序
ret = session.query(Users).order_by(Users.name.desc()).all()
ret = session.query(Users).order_by(Users.name.desc(), Users.id.asc()).all()

# 分组
from sqlalchemy.sql import func

ret = session.query(Users).group_by(Users.extra).all()
ret = session.query(
    func.max(Users.id),
    func.sum(Users.id),
    func.min(Users.id)).group_by(Users.name).all()

ret = session.query(
    func.max(Users.id),
    func.sum(Users.id),
    func.min(Users.id)).group_by(Users.name).having(func.min(Users.id) >2).all()

# 连表

ret = session.query(Users, Favor).filter(Users.id == Favor.nid).all()

ret = session.query(Person).join(Favor).all()

ret = session.query(Person).join(Favor, isouter=True).all()


# 组合
q1 = session.query(Users.name).filter(Users.id > 2)
q2 = session.query(Favor.caption).filter(Favor.nid < 2)
ret = q1.union(q2).all()

q1 = session.query(Users.name).filter(Users.id > 2)
q2 = session.query(Favor.caption).filter(Favor.nid < 2)
ret = q1.union_all(q2).all()

常用操作
View Code

 

原生SQL语句
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import time
import threading

from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import create_engine
from sqlalchemy.sql import text
from sqlalchemy.engine.result import ResultProxy
from db import Users, Hosts

engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/s6", max_overflow=0, pool_size=5)
Session = sessionmaker(bind=engine)

session = Session()

# 查询
# cursor = session.execute('select * from users')
# result = cursor.fetchall()

# 添加
cursor = session.execute('insert into users(name) values(:value)',params={"value":'wupeiqi'})
session.commit()
print(cursor.lastrowid)

session.close()

原生SQL语句
View Code

 

基于relationship操作ForeignKey
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import time
import threading

from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import create_engine
from sqlalchemy.sql import text
from sqlalchemy.engine.result import ResultProxy
from db import Users, Hosts, Hobby, Person

engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/s6?charset=utf8", max_overflow=0, pool_size=5)
Session = sessionmaker(bind=engine)
session = Session()
# 添加
"""
session.add_all([
    Hobby(caption='乒乓球'),
    Hobby(caption='羽毛球'),
    Person(name='张三', hobby_id=3),
    Person(name='李四', hobby_id=4),
])

person = Person(name='张九', hobby=Hobby(caption='姑娘'))
session.add(person)

hb = Hobby(caption='人妖')
hb.pers = [Person(name='文飞'), Person(name='博雅')]
session.add(hb)

session.commit()
"""

# 使用relationship正向查询
"""
v = session.query(Person).first()
print(v.name)
print(v.hobby.caption)
"""

# 使用relationship反向查询
"""
v = session.query(Hobby).first()
print(v.caption)
print(v.pers)
"""

session.close()

基于relationship操作ForeignKey
View Code

 

基于relationship操作m2m
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import time
import threading

from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import create_engine
from sqlalchemy.sql import text
from sqlalchemy.engine.result import ResultProxy
from db import Users, Hosts, Hobby, Person, Group, Server, Server2Group

engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/s6?charset=utf8", max_overflow=0, pool_size=5)
Session = sessionmaker(bind=engine)
session = Session()
# 添加
"""
session.add_all([
    Server(hostname='c1.com'),
    Server(hostname='c2.com'),
    Group(name='A组'),
    Group(name='B组'),
])
session.commit()

s2g = Server2Group(server_id=1, group_id=1)
session.add(s2g)
session.commit()


gp = Group(name='C组')
gp.servers = [Server(hostname='c3.com'),Server(hostname='c4.com')]
session.add(gp)
session.commit()


ser = Server(hostname='c6.com')
ser.groups = [Group(name='F组'),Group(name='G组')]
session.add(ser)
session.commit()
"""


# 使用relationship正向查询
"""
v = session.query(Group).first()
print(v.name)
print(v.servers)
"""

# 使用relationship反向查询
"""
v = session.query(Server).first()
print(v.hostname)
print(v.groups)
"""


session.close()

基于relationship操作m2m
View Code

 

其他
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import time
import threading

from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import create_engine
from sqlalchemy.sql import text, func
from sqlalchemy.engine.result import ResultProxy
from db import Users, Hosts, Hobby, Person, Group, Server, Server2Group

engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/s6?charset=utf8", max_overflow=0, pool_size=5)
Session = sessionmaker(bind=engine)
session = Session()

# 关联子查询
subqry = session.query(func.count(Server.id).label("sid")).filter(Server.id == Group.id).correlate(Group).as_scalar()
result = session.query(Group.name, subqry)
"""
SELECT `group`.name AS group_name, (SELECT count(server.id) AS sid 
FROM server 
WHERE server.id = `group`.id) AS anon_1 
FROM `group`
"""


# 原生SQL
"""
# 查询
cursor = session.execute('select * from users')
result = cursor.fetchall()

# 添加
cursor = session.execute('insert into users(name) values(:value)',params={"value":'wupeiqi'})
session.commit()
print(cursor.lastrowid)
"""

session.close()

其他
View Code

 

 

由于时间关系，详细过程略...

 

本文参考链接：

https://www.cnblogs.com/wupeiqi/articles/8259356.html

 

未完待续...

 

posted @ 2018-10-11 20:19 肖祥 阅读( ...) 评论( ...) 编辑 收藏
shykevin
关注
flask web开发中关于flask-SQLAlchemy的使用解释和完整代码 - Gavin_Hall的博客 - CSDN博客
Gavin_Hall的博客
04-19 608
@flask web development中关于flask-SQLAlchemy的使用解释和完整代码 >>>前言 在自学《flask网络开发》一书时遇到的问题，由于书讲的不太清楚，而在网上搜索到的基本都是和书一样的代码片段，不是很懂其中的整个流程，始终没有找到合适的解决办法。于是又返回前面看了一下那些基本的知识点，又琢磨了一下，终于把它给解决了，这个博文的 主要目的 是给出一个...
python flask项目结构规范_python 全栈开发，Day142(flask标准目录结构, flask使用SQLAlchemy,flask离线脚本,flask多app应用,flask-scr...
weixin_39630762的博客
12-16 778
昨日内容回顾1. 简述flask上下文管理-threading.local-偏函数-栈2. 原生SQL和ORM有什么优缺点？开发效率： ORM>原生SQL执行效率： 原生SQL>ORM如：SQLAlchemy依赖pymysql3. SQLAlchemy多线程连接的情况View Code一、flask标准目录结构标准flask目录结构Project name/ #项目名├── Proj...
flask-sqlalchemy(包含离线脚本，with在上下文管理的应用)
平头哥(Adger)的博客
03-13 501
flask-sqlalchemy(包含离线脚本，with在上下文管理的应用) 将SQLAlchemy相关的所有功能都封装到db=flask_sqlalchemy.SQLAlchemy()对象中 - 创建表 class User(db.Model): pass - 操作表 db.session 具体使用 项目目录结构 步骤： 1. 在 __init__.py中创建db对象 ...
flask-sqlalchemy使用上下文管理器更优雅的commit
S1unday的博客
03-29 1194
在我们使用 flask-sqlalchemy 的时候， 在提交事务的时候， 都需要 commit： try: user = User() .... db.session.commit() except: db.session.rollback() 现在可以使用更优雅的方式去做这件事： from flask_sqlalchemy import SQLAlchemy as _SQLAlche...
Flask-SQLAlchemy：在Flask应用中优雅地操作数据库
最新发布
zhangkexin_z的博客
09-30 2285
SQLAlchemy是一个强大的Python SQL工具包，它提供了一套完整的企业级持久化模式，用于将数据库操作抽象为Python代码。它允许我们使用面向对象的方式来操作数据库，而不必编写繁琐的SQL语句。SQLAlchemy支持多种数据库，包括MySQL、PostgreSQL、SQLite等，这使得我们在切换数据库时只需修改少量配置，而无需更改大量的代码。在Flask-SQLAlchemy中，我们使用Python类来定义数据库表的结构，这些类被称为模型类。
sqlalchemy使用上下文管理员处理Session的异常的两种with方法：python中关于with及contextlib的用法【自动生成了一个兼容with语句调用的上下文管理员】
weixin_43343144的博客
02-22 2022
参考别人的：https://www.cnblogs.com/coser/archive/2013/01/28/2880328.html 参考官方文档：https://docs.python.org/zh-cn/3/library/contextlib.html#module-contextlib 第一种方式：传统自己实现__enter__ 和 __exit__方法也是可行的,但是需...
【Flask学习笔记：四】Flask 应用和请求上下文
Mr_Zhang2的博客
03-17 377
目录：   【Flask学习笔记：一】开发环境部署   【Flask学习笔记：二】Flask 入门基础知识   【Flask学习笔记：三】Flask 中的 request、response   【Flask学习笔记：四】Flask 应用和请求上下文 【Flask学习笔记：四】Flask 应用和请求上下文   Flask 从客户端收到请求时，要让视图函数能访问一些对象，这样才能处理请求。请求对象就是...
Day5 --- Flask-RESTful请求响应与SQLAlchemy基础
weixin_45228198的博客
06-12 351
flask-restful
python框架Flask带你从入门到精通
黑技的博客
01-08 408
flask从入门到精通教程可视化学习。
第4天：在Flask应用中使用数据库—Flask_SQLAlchemy
猫姐的博客
06-11 780
原文： http://www.catonlinepy.tech/ 声明：原创不易，未经许可，不得转载 1. 你将学会什么 接第3天表单的使用课程，今天的课程主要涉及到与数据库相关的两个插件的使用，一个是Flask_SQLAlchemy，另外一个是Flask_Migrate。通过今天的学习，你将学会如何对数据库进行基本的操作，以及如何完成数据库的迁移。教程中的代码都会托管到github上，猫姐不厌其...
Flask 上下文机制和线程隔离
haozige888的博客
07-08 886
计算机科学领域的任何问题都可以通过增加一个间接的中间层来解决， 上下文机制就是这句话的体现。 如果一次封装解决不了问题，那就再来一次 上下文：相当于一个容器，保存了Flask程序运行过程中的一些信息 源码：flask/ctx.py 请求上下文：Flask从客户端收到请求时，要让视图函数能访问一些对象，这样才能处理请求，要想让视图函数能够访问请求对象，一个显而易见的方式是将其作为参数传入视图函数，不过这会导致程序中的每个视图函数都增加一个参数，除了访问请求对象,如果视图函数在处理请求时还要访问其他..
db.create_all() 报错上下文？flask_sqlalchemy创建数据库找不到上下文？那是你版本有问题
小袁同学的学习日常
01-22 3067
flask用的sqlite，orm用的flask_sqlalchemy。查了之后是flask_sqlalchemy版本太高导致。卸载flask_sqlalchemy或者直接删除文件夹。本来可以正常生成一个db文件的，但是现在出现这个报错。之后再用，就没有这个问题了,成功搞起。在创建数据库文件的时候报错上下文。至于更深的理论就不追究了。毕竟能跑就行，出问题再说。
sqlalchemy 批量插入 各种方法速度对比 bulk_save_objects
nongcunqq的博客
10-12 1726
各种写入方法速度对比。
Python SQLAlchemy 批量插入时忽略重复键
α-geek的专栏
12-14 1702
精简的 SQLAlchemy 批量插入时，遇到重复键忽略的实现
Flask中SqlAlchemy的读写分离配置
会飞的大老虎
05-03 5775
缘起最近有个项目，需要提供web api出来，我很自然的选择了flask + sqlalchemy的搭配。逻辑实现上没有说的，但是到后面打算做读写分离的时候，突然发现 flask跟sqlalchemy都没有直接提供读写分离的配置。到时再最开始时使用Flask-SqlAlchemy的时候提到了有bind，但是使用起来不是很方便，不能满足我的要求。于是在网上搜索了一些，中文的资料也没有满足我的要求的。到
Flask Web 开发 数据库操作 Sqlalchemy
bestallen的博客
08-08 4496
讲数据库操作了 创建表 首先，我们要让Flask-SQLAlchemy 根据模型类创建数据库。方法是使用db.create_all() 函数： (venv) $ python hello.py shell >>> from hello import db >>> db.create_all() 插入行 下面这段代码创建了一些角色和用户： >>> from hell
sqlalchemy 批量更新，批量删除，批量添加
热门推荐
零渡的博客
05-08 2万+
【批量删除】 session.query(User).filter(User.home=='shanghai').delete() session.commit() 【批量更新】 session.query(User).filter(User.home=='shanghai').update({JyUser.login_num:0}) session.commit() 【批量...
flask 多线程上下文管理
Codnn的专栏
09-27 1434
1、在flask主线程中利用多线程拉取数据并存储到数据库。 在线程中会遇到没有flask的上下文，导致找不到数据库问题。 解决方案： 1）在创建线程时候，传入app参数 app = create_app(config_mode) Migrate(app, db) # 我的逻辑 thread_dau = threading.Thread(target=get_dau_by_inteval, args=(app,)) thread_dau.start() thread_dau.join() 2）在
Python全栈开发：Flask与Django实战Web应用
"本资源是一份关于Python全栈开发的指南，主要涵盖了Flask和Django两个著名的Python Web框架，适合想要学习或提升Python Web开发技能的人员。内容包括Python基础知识、后端开发、前端开发，以及Flask和Django的具体...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值