盘点Flask与数据库的交互插件–Flask-Sqlalchemy

大家好，我是Python进阶者。

前言

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

一、安装并导入

pipinstallflask-sqlalchemy

fromflask_sqlalchemyimportSQLAlchemy
importos
importpymysqlasp
fromflaskimportFlask

二、基本用法

今天我们要了解的是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=False
SQLALCHEMY_TRACK_MODIFICATIONS=True

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

fromflask_sqlalchemyimportSQLAlchemy
fromflaskimportFlask
importconfig
app=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#设定连接池的连接超时时间，默认是10
SQLALCHEMY_POOL_RECYCLE#多少秒后自动回收连接，mysql默认为2小时
SQLALCHEMY_RECORD_QUERIES#可以用于显式地禁用或启用查询记录
SQLALCHEMY_ECHO#为Ture时用于调试，显示错误信息
SQLALCHEMY_BINDS#一个映射binds到连接URI的字典

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

fromsqlalchemyimportcreate_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'
bindkey内部存储在表的info字典中即：info={'bind_key':'users'}

2.建立数据表并插入值

1).继承"db.Model"类

fromflask_sqlalchemyimportSQLAlchemy
fromflaskimportFlask
importconfig
app=Flask(__name__)
app.config.from_object(config)#添加配置文件
db=SQLAlchemy(app)
classUser(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'%sis%r'%(self.__class__.__name__,self.username)


#请求钩子,第一次请求之前执行
@app.before_first_request
defcreate_table():
db.drop_all()#删除所有表
db.create_all()#创建新的表


@app.route('/')
defcreate():
use1=User('hwhrr','123321')
use2=User('hwzjj','123456')
use3=User('hwzzz','654321')
db.session.add_all([use1,use2,use3])#添加所有的用户,添加一个用户去掉_all后面加一个元祖即可
db.session.commit()#提交数据
returnuse1.__repr__()#返回用户1的值

if__name__=='__main__':
app.run(debug=True)

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

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

fromflaskimportFlask
fromsqlalchemyimportcreate_engine
fromsqlalchemy.ormimportsessionmaker
fromsqlalchemy.ext.declarativeimportdeclarative_base
fromsqlalchemyimportColumn,Integer,String
app=Flask(__name__)
Base=declarative_base()
#创建连接数据库的引擎并且打开回显
engine=create_engine("mysql+pymysql://root:123456@localhost/people",echo=True)
Session=sessionmaker(bind=engine)#创建会话标记
classUser(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'%sis%r'%(self.__class__.__name__,self.username)

@app.before_first_request
defcreate_table():
Base.metadata.drop_all(engine)#删除所有数据库
Base.metadata.create_all(engine)#创建所有数据库

@app.route('/')
defindex():
user=User("hwhrr","123321")
session=Session()#创建会话
session.add(user)#添加内容
session.commit()#提交
returnuser.__repr__()

if__name__=='__main__':
app.run(debug=True)

3.数据库之间的关系

1). 一对一

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

classfather(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'%sis%r'%(self.__class__.__name__,self.name)


classson(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'%sis%r'%(self.__class__.__name__,self.name)

2).一对多

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

classfather(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'%sis%r'%(self.__class__.__name__,self.name)


classson(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'%sis%r'%(self._class__.__name__,self.name)

@app.route('/')
defcreate():
use1=father('hw',45)
use2=son('hyy',20)
db.session.add_all([use1,use2])
db.session.commit()
returnuse1.__repr__()+'\n'+use2.__repr__()

3).多对一

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

classfather(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'%sis%r'%(self.__class__.__name__,self.name)


classson(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'%sis%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'))
)

#父表
classfather(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'%sis%r'%(self.__class__.__name__,self.name)

#子表
classson(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'%sis%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_)

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

6).与操作(and_)

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

7).或操作(or_)

fromsqlalchemyimportor_
#查找名字末尾是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支持很多表的建立和操作，通过对它的了解，我们可以很方便的操作数据库的数据从而与前端页面交互达到可视化的效果，通过这篇文章的学习，相信你可以独立开发一个小网站了。