Python3基础之学习笔记(十一)-pymysql-sqlalchemy

1. pymysql

1.1 执行sql语句

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import pymysql
 
# 创建连接
conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='root', db='t1')
# 创建游标
cursor = conn.cursor()
 
# 执行SQL，并返回收影响行数
effect_row = cursor.execute("update hosts set host = '1.1.1.2'")
 
# 执行SQL，并返回受影响行数
#effect_row = cursor.execute("update hosts set host = '1.1.1.2' where nid > %s", (1,))
 
# 执行SQL，并返回受影响行数
#effect_row = cursor.executemany("insert into hosts(host,color_id)values(%s,%s)", [("1.1.1.11",1),("1.1.1.11",2)])
 
 
# 提交，不然无法保存新建或者修改的数据
conn.commit()
 
# 关闭游标
cursor.close()
# 关闭连接
conn.close()

1.2 获取创建数据自增id

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import pymysql
 
conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='root', db='t1')
cursor = conn.cursor()
cursor.executemany("insert into hosts(host,color_id)values(%s,%s)", [("1.1.1.11",1),("1.1.1.11",2)])
conn.commit()
cursor.close()
conn.close()
 
# 获取最新自增ID
new_id = cursor.lastrowid

1.3 获取查询数据

注：在fetch数据时按照顺序进行，可以使用cursor.scroll(num,mode)来移动游标位置，如：

• cursor.scroll(1,mode=‘relative’) # 相对当前位置移动
• cursor.scroll(2,mode=‘absolute’) # 相对绝对位置移动

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import pymysql
 
conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='root', db='t1')
#不设置游标默认获取的数据是元组类型
cursor = conn.cursor()
#游标设置为字典类型
#cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)
cursor.execute("select * from hosts")
 
# 获取第一行数据
row_1 = cursor.fetchone()
 
# 获取前n行数据
# row_2 = cursor.fetchmany(3)
# 获取所有数据
# row_3 = cursor.fetchall()
 
conn.commit()
cursor.close()
conn.close()

2. sqlalchemy

SQLAlchemy是python编程语言下的一款开源软件。提供了SQL工具包及对象关系映射（ORM）工具，使用MIT许可证发行。

SQLAlchemy“采用简单的Python语言，为高效和高性能的数据库访问设计，实现了完整的企业级持久模型”。SQLAlchemy的理念是，SQL数据库的量级和性能重要于对象集合；而对象集合的抽象又重要于表和行。因此，SQLAlchmey采用了类似于Java里Hibernate的数据映射模型，而不是其他ORM框架采用的Active Record模型。不过，Elixir和declarative等可选插件可以让用户使用声明语法。

2.1 创建表结构

import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column,Integer,String
#连接数据库
engine=create_engine('mysql+pymysql://root:root@localhost/test',
                         encoding='utf-8',
                         echo=True)#echo为true在控制台打印消息
Base=declarative_base()#生成orm基类
class User(Base):
    __tablename__='user'#表名
    id=Column(Integer,primary_key=True)
    name=Column(String(32))
    password=Column(String(64))
def main():
    Base.metadata.create_all(engine)#创建表结构
if __name__ == "__main__":
    main()

2.2 创建数据

import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column,Integer,String
from sqlalchemy.orm import sessionmaker
#连接数据库
engine=create_engine('mysql+pymysql://root:root@localhost/test',
                         encoding='utf-8',
                         echo=True)#echo为true在控制台打印消息
Base=declarative_base()#生成orm基类
class User(Base):
    __tablename__='user'#表名
    id=Column(Integer,primary_key=True)
    name=Column(String(32))
    password=Column(String(64))
def main():
    Base.metadata.create_all(engine)#创建表结构
    Session_class=sessionmaker(bind=engine)#创建与数据库的session class
    session=Session_class()#生成session实例
    user_obj=User(name='zhangsan',password='12345678')#生成你要创建的数据对象
    session.add(user_obj)#把要创建的数据对象添加到这个session里，一会统一创建
    session.commit()#统一提交，创建数据
if __name__ == "__main__":
    main()

2.3 查询数据

import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column,Integer,String
from sqlalchemy.orm import sessionmaker
#连接数据库
engine=create_engine('mysql+pymysql://root:root@localhost/test',
                         encoding='utf-8',
                         echo=False)#echo为true在控制台打印消息
Base=declarative_base()#生成orm基类
class User(Base):
    __tablename__='user'#表名
    id=Column(Integer,primary_key=True)
    name=Column(String(32))
    password=Column(String(64))
    def __repr__(self):
        return 'id=%s,name=%s,password=%s'%(self.id,self.name,self.password)
def main():
    Base.metadata.create_all(engine)#创建表结构
    Session_class=sessionmaker(bind=engine)#创建与数据库的session class
    session=Session_class()#生成session实例
    #data=session.query(User).filter_by(name='zhangsan').all()
    #获取第一个数据
    #data = session.query(User).filter_by().first()
    #根据id查询
    data = session.query(User).filter(User.id>=1).all()
    #模糊查询
    data=session.query(User).filter(User.name.in_(['zhangsan','lisi'])).all()
    #多条件查询
    data = session.query(User)\
        .filter(User.id >= 1)\
        .filter(User.id<3)\
        .all()
    print(data)
    #print(data[0].name,data[0].password)
if __name__ == "__main__":
    main()
 

2.4 修改数据

import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column,Integer,String
from sqlalchemy.orm import sessionmaker
#连接数据库
engine=create_engine('mysql+pymysql://root:root@localhost/test',
                         encoding='utf-8',
                         echo=False)#echo为true在控制台打印消息
Base=declarative_base()#生成orm基类
class User(Base):
    __tablename__='user'#表名
    id=Column(Integer,primary_key=True)
    name=Column(String(32))
    password=Column(String(64))
    def __repr__(self):
        return 'id=%s,name=%s,password=%s'%(self.id,self.name,self.password)
def main():
    Base.metadata.create_all(engine)#创建表结构
    Session_class=sessionmaker(bind=engine)#创建与数据库的session class
    session=Session_class()#生成session实例
    data=session.query(User).filter_by(name='zhangsan').all()
    #修改数据
    data[0].name='lisi'
    data[0].password='123'
    #session.rollback()回滚操作
    session.commit()#提交修改
if __name__ == "__main__":
    main()

2.5 统计和分组

#统计
count = session.query(User).filter().count()
#分组
from sqlalchemy import func
print(session.query(func.count(User.name),User.name).group_by(User.name).all())

2.6 外键关联

2.6.1 一对多

#!/usr/bin/env python3
#coding:utf8
#导入所需模块
from sqlalchemy import create_engine,func
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String,ForeignKey
from  sqlalchemy.orm import sessionmaker,relationship
#生成sqlorm基类
Base = declarative_base()
#创建数据库连接，max_overflow指最大连接数
engine = create_engine("mysql+mysqldb://root:[email protected]:3306/test", max_overflow=5)
#目的是一个人可以拥有多本书，那么在数据库里的一对多关系
class User(Base):
    #表名
    __tablename__ = 'user'
    #id字段
    id = Column(String(20), primary_key=True)
    #名字字段
    name = Column(String(20))
    # 一对多:#内容不是表名而是定义的表结构名字
    books = relationship('Book')
class Book(Base):
    #表面
    __tablename__ = 'book'
    #id字段
    id = Column(String(20), primary_key=True)
    #名字字段
    name = Column(String(20))
    # “多”的一方的book表是通过外键关联到user表的:
    #ForeignKey是外键 关联user表的id字段
    user_id = Column(String(20), ForeignKey('user.id'))
#创建所需表
Base.metadata.create_all(engine)
 
if __name__ == '__main__':
    #绑定,生成会话
    SessionCls = sessionmaker(bind=engine)
    session = SessionCls()
    #创建用户
    liuyao = User(id='1',name='liuyao')
    ali=User(id='2',name='ali')
    #添加字段
    session.add_all([liuyao,ali])
    #提交
    session.commit()
    #创建白鹿原这本书，指定谁是拥有者
    Whitedeer = Book(id='1',name='White_deer',user_id = '1')
    #创建三体这本书，指定谁是拥有者
    Threebody = Book(id='2',name='Three_body',user_id = '2')
    #添加字段
    session.add_all([Whitedeer,Threebody])
    #提交
    session.commit()

2.6.2 多对多

建立一个双向一对多关系,“反向”是一个许多人,指定一个额外的relationship()函数并连接两个使用relationship.back_populates参数简单来说, relationship函数是sqlalchemy对关系之间提供的一种便利的调用方式, backref参数则对关系提供反向引用的声明。在最新版本的sqlalchemy中对relationship引进了back_populates参数。

#!/usr/bin/env python3
#coding:utf8
from sqlalchemy import Column, Sequence, String, Integer, ForeignKey
from sqlalchemy import create_engine # 导入创建连接驱动
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from sqlalchemy.orm import relationship, backref
# 这个url可以用urlparse解析, 其中echo=True表示执行时显示sql语句
engine = create_engine("mysql+pymysql://root:[email protected]:3306/test", max_overflow=5)
#生成了declarative基类, 以后的model继承此类
Base = declarative_base()
class Parent(Base):
    __tablename__ = 'parent'
    id = Column(Integer, primary_key=True)
    name = Column(String(64),unique=True,nullable=False)
    children = relationship("Child", back_populates="parent")#可以通过children查看Child里字段
class Child(Base):
    __tablename__ = 'child'
    id = Column(Integer, primary_key=True)
    name = Column(String(64),unique=True,nullable=False)
    parent_id = Column(Integer, ForeignKey('parent.id'))
    parent = relationship("Parent", back_populates="children")
Base.metadata.create_all(engine) #创建所有表结构
if __name__ == '__main__':
SessionCls = sessionmaker(bind=engine)
#创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例
session = SessionCls()
mama = Parent(id='1',name='mamaxx')
baba = Parent(id='2',name='babaoo')
session.add_all([mama,baba])
# onesb = Child(id='1',name='onesb',parent_id='2')
# twosb = Child(id='2',name='twosb',parent_id='2')
#session.add_all([onesb,twosb])
session.commit()

2.6.3 多对多之三表外键关联

#!/usr/bin/env python3
#coding:utf8
from sqlalchemy import create_engine,func,Table
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String,ForeignKey
from  sqlalchemy.orm import sessionmaker,relationship
Base = declarative_base()
#关系表
Host2Group = Table('host_2_group',Base.metadata,
               Column('host_id',ForeignKey('hosts.id'),primary_key=True),
               Column('group_id',ForeignKey('group.id'),primary_key=True),
               )
engine = create_engine("mysql+pymysql://root:[email protected]:root/test", max_overflow=5)
class Host(Base):
    __tablename__ = 'hosts'
    id = Column(Integer,primary_key=True,autoincrement=True)
    hostname = Column(String(64),unique=True,nullable=False)
    ip_addr = Column(String(128),unique=True,nullable=False)
    port = Column(Integer,default=22)
    groups = relationship('Group',
                      secondary= Host2Group,
                      backref = 'host_list')
class Group(Base):
    __tablename__ = 'group'
    id = Column(Integer,primary_key=True)
    name = Column(String(64),unique=True,nullable=False)
 
if __name__ == '__main__':
    SessionCls = sessionmaker(bind=engine)
    session = SessionCls()
    g1 = Group(name='g1')
    g2 = Group(name='g2')
    g3 = Group(name='g3')
    g4 = Group(name='g4')
    session.add_all([g1,g2,g3,g4])
    session.commit()