Python支持的数据库有不少,MySQL做为主流数据库之一,咱们不妨了解下它们之间的小故事
Python操做MySQL的库有三个,python-MySQL(MySQLdb),PyMySQL跟SQLAlchemy。python
python2中通常使用python-MySQL(MySQLdb),核心由C语言打造,性能最好,缺点是安装复杂,已中止更新,不支持python3。
PyMySQL为代替它而生,纯python打造,安装方便,支持python3。
SQLAlchemy是一个ORM框架,ORM框架的做用就是把数据库表的一行记录与一个对象互相作自动转换,它自己没法操做数据库,而是要依赖于MySQLdb、PyMySQL等第三方库来完成,目前SQLAlchemy在Web编程领域应用普遍。
本文将主要拿SQLAlchemy来进行了解学习。mysql
安装工具
首先安装基本的数据库驱动pymysqlsql
pip3 install pymysql
而后安装ORM框架SQLAlchemy数据库
pip3 install sqlalchemy
平常工做中,若是不想每次经过命令行来查看数据的话。推荐安装Navicat for MySQL,经过这个图形化工具可以方便快捷地操做数据库,实时查询数据。编程
初始化数据库
安装好必要工具后,咱们开始尝试建立个用户数据user表来。
首先,使用SQLAlchemy链接数据库并定义表结构初始化DBSession。session
# 导入SQLAlchemy
from sqlalchemy import Column, BIGINT, String, create_engine
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base
# 建立基类
Base = declarative_base()
# 初始化数据库链接:
# '数据库类型+数据库驱动名称://用户名:密码@数据库地址:端口号/数据库名'
engine = create_engine('mysql+pymysql://root:123123@mysql:3306/test')
# 建立DBSession类型:
DBSession = sessionmaker(bind=engine)
# 建立session对象:
session = DBSession()
# 数据库操做方法
# 初始化数据库
def init_db():
Base.metadata.create_all(engine)
# 删除数据库
def drop_db():
Base.metadata.drop_all(engine)
创建user数据表模型:框架
# 定义user类
class User(Base):
# 表名
__tablename__ = "user"
# 表的结构
# 设置id为主键 并自增加
id = Column(BIGINT, primary_key=True, autoincrement=True)
name = Column(String(20))
gender = Column(String(2))
# 正式初始化数据库,若是没有user表的话,这里将自动建立
init_db()
这里有个须要注意的地方就是在初始化数据库以前须要先定义user数据表模型,不然的话没法正常建立user数据表。
session(会话),能够当作一个管理数据库持久链接的对象,后面的操做都将基于session对象进行。函数
若是使用INT自增类型,那么当一张表的记录数超过2147483647(约21亿)时,会达到上限而出错。使用BIGINT自增类型则能够最多约922亿亿条记录。
增删改查操做
增
初始化ORM对象后,咱们插入一条记录试试。工具
# 建立新User对象:
new_user = User(name='mrlizi', gender='man')
# 添加到session:
session.add(new_user)
# 批量添加
session.add_all([
User(name='子非鱼', gender='M'),
User(name='虞姬', gender='F'),
User(name='花木兰', gender='F')
])
# 提交即保存到数据库:
session.commit()
结果:性能
查
Session的query函数会返回一个Query对象。query函数能够接受多种参数类型。
# query: 输出全部的用户名
result = session.query(User.name)
# order: 按倒序输出全部用户
result = session.query(User).order_by(User.id.desc())
result = session.query(User).order_by(-User.id)
# label: 自定义字段名,查询结果可经过item.my_name来获取用户名
for item in session.query(User.name.label('my_name')).all()
# filter和filter_by: 筛选用户名为'mrlizi'的用户
result = session.query(User).filter(User.name=='mrlizi').one()
result = session.query(User).filter_by(name='mrlizi').one()
# offset和limit:组合起来可作分页查询(经过python的切片其实也同样),下面的两种语句的查询结果是相同的
result = session.query(User).offset(2).limit(1).all()
result = session.query(User)[1:3]
# AND: 与查询
result = session.query(User).filter(and_(User.name=='mrlizi', User.gender=='M')).all()
result = session.query(User).filter(User.name=='mrlizi', User.gender=='M')
result = session.query(User).filter(User.name=='mrlizi').filter(User.gender=='M').all()
# OR: 或查询
result = session.query(User).filter(or_(User.name == '子非鱼', User.name == '花木兰'))
# 模糊查询
result = session.query(User).filter(User.name.like('子%')).all()
基本平常用到的查询方法就是这些,面向对象操做的用法都比较灵活多变,你们能够根据不一样的场景自由组合。
改
相比去查询来说,修改就显得简单不少,找到命中的记录,而后经过update方法来进行修改。
update方法的synchronize_session参数用于在更新数据后是否对当前的session进行更新,
synchronize_session = False 不一样步更新当前session
synchronize_session = 'fetch' 更新以前从数据库中拉取实时数据,更新到session对象
synchronize_session = 'evaluate' 更新以前先记录符合的对象,更新完后对记录的对象进行删除。(意思是不与数据库进行同步更新,仅更新当前的session记录)
# 方法一
session.query(User).filter(User.name == 'mrlizi').update({'name': '李白'})
# 方法二
user = session.query(User).filter(User.name == '李白').first()
user.name = '铠'
# 操做方式
result = session.query(User).filter(User.name == '虞姬').update({User.name: '孙尚香'}, synchronize_session='fetch')
# 提交
session.commit()
删
删除的话,无非就是查询到目标记录,而后进行删除。
# 使用查询语句,filter是where条件,最后调用delete()进行删除记录:
session.query(User).filter_by(name="铠").delete()
session.commit()
关联表查询
MySQL做为关系型数据库,能够经过设置外键来进行多个表互相关联查询。相应的,SQLAlchemy也提供了对象之间的一对1、一对多、多对多关联功能。
一对多
在SQLAlchemy的一对多关系中,使用ForeignKey()来表示表的外键,relationship()表示表与表之间关联的属性。
def one_to_many():
# 定义user类
class User(Base):
# 表名
__tablename__ = "user"
# 表的结构
# 设置id为主键 并自增加
id = Column(BIGINT, primary_key=True, autoincrement=True)
name = Column(String(20))
# 定义用户关注的公众号属性,指明二者的关系
account = relationship('Account', back_populates="user")
class Account(Base):
__tablename__ = 'account'
id = Column(BIGINT, primary_key=True, autoincrement=True)
name = Column(String(20))
# 设置外键关联到user表的:
user_id = Column(BIGINT, ForeignKey('user.id'))
# 定义 Account 的 user 属性,指明二者关系
user = relationship("User", back_populates="account")
# 清空数据库并从新初始化
drop_db()
init_db()
mrlizi = User(name='mrlizi')
mrlizi.account = [
Account(name='攻城狮峡谷'),
Account(name='zone7')
]
session.add(mrlizi)
result = session.query(User).filter(User.name == 'mrlizi').one()
for item in result.account:
print(item.name)
result = session.query(Account).filter(Account.name == '攻城狮峡谷').one()
print(result.user.name)
session.commit()
one_to_many()
上面代码的实现过程:
创建一对多数据表模型
将以前的数据清空后从新初始化,用新的表模型建立个新的user,并添加关注的公众号account
增长name为mrlizi的user表记录,同时建立相关联的公众号信息记录。
经过user表查询相关联的公众号数据
经过account表查询相关联的用户数据
一对一
一对一其实就是两个表互相关联,咱们只须要在一对多关系基础上的父表中使用uselist参数来表示。实现代码以下:
def one_to_one():
# 定义user类
class User(Base):
__tablename__ = "user"
id = Column(BIGINT, primary_key=True, autoincrement=True)
name = Column(String(20))
account = relationship('Account', uselist=False, back_populates="user")
# 公众号类
class Account(Base):
__tablename__ = 'account'
id = Column(BIGINT, primary_key=True, autoincrement=True)
name = Column(String(20))
# 设置外键关联到user表的:
user_id = Column(BIGINT, ForeignKey('user.id'))
# 定义 Account 的 user 属性,指明二者关系
user = relationship("User", back_populates="account")
# 清空数据库并从新初始化
drop_db()
init_db()
# 添加记录
user = User(name='子非鱼')
user.account = Account(name='攻城狮峡谷')
session.add(user)
session.commit()
# 查询
result = session.query(User).filter(User.name == '子非鱼').one()
print(result.account.name)
# 输出:
# 攻城狮峡谷
one_to_one()
多对多
多对多是经过两个表之间增长一个关联的表来实现,这个关联表使用MetaData对象来与两个表关联,并用ForeignKey参数指定连接来定位到两个不一样的表,两个不一样的表则在relationship()方法中经过secondary参数来指定关联表。
def many_to_many():
# 关联表
association_table = Table('association', Base.metadata,
Column('user_id', BIGINT, ForeignKey('user.id')),
Column('account_id', BIGINT, ForeignKey('account.id'))
)
class User(Base):
__tablename__ = "user"
id = Column(BIGINT, primary_key=True, autoincrement=True)
name = Column(String(20))
accounts = relationship('Account', secondary=association_table, back_populates="users")
class Account(Base):
__tablename__ = 'account'
id = Column(BIGINT, primary_key=True, autoincrement=True)
name = Column(String(20))
users = relationship("User", secondary=association_table, back_populates="accounts")
# 清空数据库并从新初始化
drop_db()
init_db()
# 建立记录
user1 = User(name='子非鱼')
user2 = User(name='zone')
user3 = User(name='mrlizi')
account1 = Account(name='攻城狮峡谷')
account2 = Account(name='zone7')
# 关联记录
user1.accounts = [account1]
user2.accounts = [account1, account2]
user3.accounts = [account2]
# 添加并保存
session.add(user1)
session.add(user2)
session.add(user3)
session.commit()
# 双向查询
result1 = session.query(User).filter(User.name == 'zone').one()
for item in result1.accounts:
print(item.name)
result2 = session.query(Account).filter(Account.name == '攻城狮峡谷').one()
for item in result2.users:
print(item.name)
many_to_many()
总结
MySQL做为主流的数据库之一,咱们不必定说要多深刻去研究它的使用,但起码的了解仍是要有的。并且python中使用MySQL仍是挺简单的,代码敲着敲着就会了。