盘点Flask与数据库的交互插件--Flask-Sqlalchemy-技术圈

点击上方“Python爬虫与数据挖掘”，进行关注

回复“书籍”即可获赠Python从入门到进阶共10本电子书

今

日

鸡

汤

感时花溅泪,恨别鸟惊心。

大家好，我是Python进阶者。

前言

在我们做web开发的时候，经常需要用到与数据库交互，因为我们的数据通常都是保存在数据库中的，如果有人需要访问，就必须与数据库访问，所以今天我们介绍一个Flask中与数据库交互的插件---Flask-Sqlalchemy。

一、安装并导入

pip install flask-sqlalchemy
from flask_sqlalchemy import SQLAlchemyimport osimport pymysql as pfrom flask import Flask

二、基本用法

今天我们要了解的是Mysql数据库，所以这里重点介绍连接Mysql数据库的方法。

1.连接数据库

1).写在配置文件中然后读取

首先创建一个配置文件"config.py"，内容为：

db_type='mysql'db_conn='pymysql'host='127.0.0.1'username='root'password='123456'port='3306'db_name='people'SQLALCHEMY_DATABASE_URI='{}+{}://{}:{}@{}:{}/{}?charset=utf8'.format(db_type,db_conn,username,password,host,port,db_name)SQLALCHEMY_COMMIT_ON_TEARDOWN=FalseSQLALCHEMY_TRACK_MODIFICATIONS=True

然后在应用中导入配置文件：

from flask_sqlalchemy import SQLAlchemyfrom flask import Flaskimport configapp=Flask(__name__)app.config.from_object(config) # 连接数据库配置文件db=SQLAlchemy(app)db.create_all()  # 创建所有的数据库

2).直接写在应用中读取

app=Flask(__name__)p.install_as_MySQLdb()   # mysql连接器，因为不支持py3版本，所以必须加上这行app.config['SECRET_KEY']=os.urandom(50)app.config['SQLALCHEMY_DATABASE_URI']='mysql+pymysql://root:123456@127.0.0.1:3306/people'app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN']=True   # 每次请求结束后都会自动提交数据库中的变动app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True  # 动态追踪修改设置，如未设置只会提示警告db = SQLAlchemy(app)

还有许多其它的配置参数，比如：

SQLALCHEMY_NATIVE_UNICODE    # 可以用于显式禁用原生 unicode 支持SQLALCHEMY_POOL_SIZE         # 数据库连接池的大小，默认是引擎默认值（5） SQLALCHEMY_POOL_TIMEOUT      # 设定连接池的连接超时时间，默认是 10SQLALCHEMY_POOL_RECYCLE      # 多少秒后自动回收连接，mysql默认为2小时SQLALCHEMY_RECORD_QUERIES    # 可以用于显式地禁用或启用查询记录SQLALCHEMY_ECHO              # 为Ture时用于调试，显示错误信息SQLALCHEMY_BINDS             # 一个映射 binds 到连接 URI 的字典

3).使用独特的创建引擎

from sqlalchemy import create_engine# echo参数为True时，会显示每条执行的SQL语句，为False时关闭engine = create_engine('mysql+pymysql://root:123456@127.0.0.1:3306/people',echo=True)engine.connect()

这样我们就算与People数据库建立连接了，接下来我们来建立一张表。

4).创建连接多个数据库

app.config['SQLALCHEMY_BINDS']={'users': "mysql+pymysql://root:123456@127.0.0.1:3306/user",    'admin': 'sqlite://C:/Users/Administrator/Desktop/admin',    'buy':   'postgresql://root:123321@127.0.0.1/buy'}

然后引用表：

db.create_all(bind=['users'])db.create_all(bind='admin')

指定Users数据库中的表：

__bind_key__ = 'users'bind key 内部存储在表的 info 字典中  即：info={'bind_key': 'users'}

2.建立数据表并插入值

1).继承"db.Model"类

from flask_sqlalchemy import SQLAlchemyfrom flask import Flaskimport configapp=Flask(__name__)app.config.from_object(config) # 添加配置文件db=SQLAlchemy(app)class User(db.Model):    __tablename__='users'    id=db.Column(db.Integer, primary_key=True,autoincrement=True) # 整数类型的自增主键    username=db.Column(db.String(100),nullable=False)  # 字符类型不为空    password=db.Column(db.String(100),nullable=False)  # 字符类型不为空
    def __init__(self,username,password):        self.username=username        self.password=password
    def __repr__(self):        # 打印当前类名和它的实例化后的值        return ' %s is %r' %(self.__class__.__name__,self.username)         # 请求钩子,第一次请求之前执行@app.before_first_requestdef create_table():     db.drop_all()  # 删除所有表    db.create_all() # 创建新的表
    @app.route('/')def create():    use1= User('hwhrr', '123321')      use2= User('hwzjj', '123456')    use3= User('hwzzz', '654321')    db.session.add_all([use1,use2,use3]) # 添加所有的用户,添加一个用户去掉_all后面加一个元祖即可     db.session.commit()  # 提交数据    return use1.__repr__() # 返回用户1的值
if __name__ == '__main__':      app.run(debug=True)

Column        参数列表  name          列名type_         类型*args         列表参数Constraint（约束）, ForeignKey（外键）, ColumnDefault（默认）, Sequenceobjects（序列）定义key         列名的别名primary_key 如果为True，则是主键nullable    如果是True，则可以为nulldefault     设置默认值，默认是Noneindex       是否是索引，默认是Trueunique      是否唯一键，默认是Falseonupdate    指定一个更新时候的值autoincrement 设置为整型自动增长quote         如果列明是关键字，则强制转义，默认False

2).利用原始引擎来创建会话（稍微复杂点）

from flask import Flaskfrom sqlalchemy import create_enginefrom sqlalchemy.orm import sessionmakerfrom sqlalchemy.ext.declarative import declarative_basefrom sqlalchemy import Column, Integer, Stringapp=Flask(__name__)Base = declarative_base()# 创建连接数据库的引擎并且打开回显engine = create_engine("mysql+pymysql://root:123456@localhost/people",echo=True)Session = sessionmaker(bind=engine) # 创建会话标记class User(Base):    __tablename__ = 'article'    id = Column(Integer, primary_key=True,autoincrement=True)    username = Column(String(100),nullable=False)    password = Column(String(100),nullable=False)    def __init__(self, username,password):        self.username = username        self.password=password    def __repr__(self):        return ' %s is %r' %(self.__class__.__name__,self.username)    @app.before_first_requestdef create_table():    Base.metadata.drop_all(engine) # 删除所有数据库    Base.metadata.create_all(engine) # 创建所有数据库    @app.route('/')def index():    user= User("hwhrr","123321")    session = Session()   # 创建会话    session.add(user)  # 添加内容    session.commit()  # 提交    return user.__repr__()
if __name__ == '__main__':      app.run(debug=True)

3.数据库之间的关系

1). 一对一

只需让两张表都在同等的位置上，属于双向关系。

class father(db.Model):    __tablename__='Father'    id=db.Column(db.Integer, primary_key=True,autoincrement=True)    name= db.Column(db.String(100),nullable=False)    age= db.Column(db.Integer,nullable=False)    #主要是要在一个表上设置uselist 然后设置back_populates的值为其它表的映射返回值    son_fa=db.relationship('son',uselist=False, back_populates='fa_son')     def __init__(self,name,age):        self.name=name        self.age=age    def __repr__(self):        return '%s is %r'%(self.__class__.__name__,self.name)

class son(db.Model):    __tablename__='Son'    id=db.Column(db.Integer, primary_key=True,autoincrement=True)    name= db.Column(db.String(100),nullable=False)    age= db.Column(db.Integer,nullable=False)    # 这里无需设置uselist    fa_son=db.relationship('father',back_populates='son_fa')    def __init__(self,name,age):        self.name=name        self.age=age    def __repr__(self):        return '%s is %r'%(self.__class__.__name__,self.name)

2).一对多

我们需要建立一个主表和一个子表，分别命名为“father”和‘son’，然后需要建立外键和反射来互相引用建立一种关系，我们来看看：

class father(db.Model):    __tablename__='Father'    id=db.Column(db.Integer, primary_key=True,autoincrement=True)    name= db.Column(db.String(100),nullable=False)    age= db.Column(db.Integer,nullable=False)    # 表示另一端是son这个模型，backref可替代Father.id访问father模型    son_fa=db.relationship('son',backref='fa'，lazy='dynamic')    # lazy表示加载方式：    # dynamic：动态加载，只有用到了才加载 只可以用在一对多和多对多关系中    # subquery：全部加载    def __init__(self,name,age):        self.name=name        self.age=age    def __repr__(self):        return '%s is %r'%(self.__class__.__name__,self.name)

class son(db.Model):    __tablename__='Son'    id=db.Column(db.Integer, primary_key=True,autoincrement=True)    name= db.Column(db.String(100),nullable=False)    age= db.Column(db.Integer,nullable=False)    f_id=db.Column(db.Integer,db.ForeignKey('Father.id')) # 建立外键关联，指明表名和字段    def __init__(self,name,age):        self.name=name        self.age=age            def __repr__(self):        return '%s is %r'%(self._class__.__name__,self.name)
@app.route('/')def create():    use1= father('hw', 45)    use2= son('hyy', 20)    db.session.add_all([use1,use2])    db.session.commit()    return use1.__repr__()+'\n'+use2.__repr__()

3).多对一

就是将反射应用在子表上，与父表同时进行关联。

class father(db.Model):    __tablename__='Father'    id=db.Column(db.Integer, primary_key=True,autoincrement=True)    name= db.Column(db.String(100),nullable=False)    age= db.Column(db.Integer,nullable=False)    # 表示另一端是son这个模型    son_fa=db.relationship('son', back_populates="fath")     def __init__(self,name,age):        self.name=name        self.age=age    def __repr__(self):        return '%s is %r'%(self.__class__.__name__,self.name)

class son(db.Model):    __tablename__='Son'    id=db.Column(db.Integer, primary_key=True,autoincrement=True)    name= db.Column(db.String(100),nullable=False)    age= db.Column(db.Integer,nullable=False)    f_id=db.Column(db.Integer,db.ForeignKey('Father.id')) # 建立外键关联    # 表示另一端是father这个模型    fa_son=db.relationship('father',back_populates="so")     def __init__(self,name,age):        self.name=name        self.age=age    def __repr__(self):        return '%s is %r'%(self.__class__.__name__,self.name)

4).多对多

设置一个关联表来对两个表同时进行管理。

# 设置关联表gl=db.Table('glb',    db.Column('id',db.Integer,primary_key=True,autoincrement=True),    db.Column('son_id',db.Integer,db.ForeignKey('Son.id')),    db.Column('father_id',db.Integer,db.ForeignKey('Father.id')))
# 父表class father(db.Model):    __tablename__='Father'    id=db.Column(db.Integer, primary_key=True,autoincrement=True)    name= db.Column(db.String(100),nullable=False)    age= db.Column(db.Integer,nullable=False)    # 设置关联表 动态加载    son_fa=db.relationship('son',secondary=gl,backref="fas",lazy="dynamic")    def __init__(self,name,age):        self.name=name        self.age=age    def __repr__(self):        return '%s is %r'%(self.__class__.__name__,self.name)
# 子表class son(db.Model):    __tablename__='Son'    id=db.Column(db.Integer, primary_key=True,autoincrement=True)    name= db.Column(db.String(100),nullable=False)    age= db.Column(db.Integer,nullable=False)    def __init__(self,name,age):        self.name=name        self.age=age    def __repr__(self):        return '%s is %r'%(self.__class__.__name__,self.name)

可以看出我们已经创建出了一张关联表，名字就是我们设置的“glb”。

4.查看数据

1).查看全部数据(all)

father.query.all()

2).精准查询(filter_by)

father.query.filter_by(name='hw').all()  # 查找所有名字为hw的记录

3).模糊查询(filter)

father.query.filter(father.name.startswith('h').all() # 查找所有名字首字母为h的记录

4).主键查询(get)

father.query.get(1) # 查看id为1的记录

5).取反操作(not_)

from sqlalchemy import not_father.query.filter(not_(father.name=='hw')).all() # 查找所有除了名字不是hw的记录

6).与操作(and_)

from sqlalchemy import and_# 查找名字末尾是h并且年龄等于50的记录father.query.filter(and_(father.name.endswith('h'),father.age==50)).all()

7).或操作(or_)

from sqlalchemy import or_# 查找名字末尾是h或者年龄等于50的记录father.query.filter(or_(father.name.endswith('h'),father.age==50)).all()

8).一对多正向查询

son.query.filter_by(f_id=2).all()

9).一对多反向查询

son.query.filter_by(fa=use1).all()

10).查询第一个出现的数据

son.query.filter(son.age==10).first()son.query.filter(son.age==10)[0]

11).查询对象并返回指定数量的结果

son.query.filter(son.age==10).limit(10).all() # 返回十个查找到的对象

12).查询时指定偏移量

son.query.filter(son.age==10).offset(2).all() # 返回偏移了2的对象

13).查找对象并排序

son.query.filter(son.age==10).order_by(son.create_time.desc()).all() # 返回按降序排序的记录

14).查找对象返回分组结果

son.query.filter(son.age==10).group_by(son.name).all() # 返回age为10的名字对象分组

15).返回查询结果的数量

son.query.filter(son.age==10).count() # son的年龄为10的数量

16).返回切片结果

son.query(son).slice(10,40).all()   # son从10到40的记录son.query(son)[10:40]

17).分页获取数据

p=request.args.get('p')# 从请求的查询字符串中获取当前页面，返回一个每页显示3条记录的分页对象paginate=son.query.paginate(p=int(p),per_page=3) paginate 属性：pages     # 总共生成页面数量page      # 当前页数has_next  # 判断是否有下一页has_prev  # 判断是否有上一页next_num  # 获取下一页的页码数prev_num  # 获取上一页的页码数items     # 获取当前页的记录total     # 查询返回的记录总数

18).查询仅显示一条记录

son.query(son).one()

5.更新数据

ss=son.query.get(1)ss.name='fasd'     # 更改name的值来达到更新的目的db.session.commit()

6.删除数据

ss=son.query.get(1)db.session.delete(ss)db.session.commit()

三、总结

Sqlalchemy支持很多表的建立和操作，通过对它的了解，我们可以很方便的操作数据库的数据从而与前端页面交互达到可视化的效果，通过这篇文章的学习，相信你可以独立开发一个小网站了。

------------------- End -------------------

往期精彩文章推荐：

Python也能操作Mysql数据库
一部手机不用任何软件轻松下载闲鱼短视频
我是如何利用Python下载酷狗音乐的
干货文——一文带你搞懂爬虫储存数据库MongoDB

欢迎大家点赞，留言，转发，转载，感谢大家的相伴与支持

想加入Python学习群请在后台回复【入群】

万水千山总是情，点个【在看】行不行

/今日留言主题/

随便说一两句吧~~