python數據庫操作之pymysql模塊和sqlalchemy模塊(項目必備)

pymysql

 pymsql是Python中操作MySQL的模塊，其使用方法和MySQLdb幾乎相同。

1、下載安裝

pip3 install pymysql

2、操作數據庫

（1）、執行sql

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import pymysql
  
# 創建連接
conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='123', 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()

（2）、獲取新創建數據自增ID

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import pymysql
  
conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='123', 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

（3）、獲取查詢數據

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import pymysql
  
conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='123', db='t1')
cursor = conn.cursor()
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()

注：在fetch數據時按照順序進行，可以使用cursor.scroll(num,mode)來移動游標位置，如：

• cursor.scroll(1,mode='relative')  # 相對當前位置移動
• cursor.scroll(2,mode='absolute') # 相對絕對位置移動

（4）、fetch數據類型

　　關於默認獲取的數據是元祖類型，如果想要或者字典類型的數據，即：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import pymysql
  
conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='123', db='t1')
  
# 游標設置為字典類型
cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)
r = cursor.execute("call p1()")
  
result = cursor.fetchone()
  
conn.commit()
cursor.close()
conn.close()

 

sqlalchemy簡介

SQLAlchemy是Python編程語言下的一款開源軟件。提供了SQL工具包及對象關系映射（ORM）工具，使用MIT許可證發行。

SQLAlchemy“采用簡單的Python語言，為高效和高性能的數據庫訪問設計，實現了完整的企業級持久模型”。SQLAlchemy的理念是，SQL數據庫的量級和性能重要於對象集合；而對象集合的抽象又重要於表和行。因此，SQLAlchmey采用了類似於Java里Hibernate的數據映射模型，而不是其他ORM框架采用的Active Record模型。不過，Elixir和declarative等可選插件可以讓用戶使用聲明語法。

SQLAlchemy與數據庫關系圖如下：

sqlalchemy基本操作

一、安裝sqlalchemy

• 本文采用的是mysql案例，所以需要一台有安裝mysql數據庫的機器
• 使用python的pip3安裝 pip3 install sqlalchemy

安裝完后查看版本信息

import sqlalchemy
sqlalchemy.__version__

二、連接數據庫

在sqlalchemy中，session用於創建程序與數據庫之間的會話。所有對象的載入和保存都需要通過session對象。

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

# 鏈接數據庫采用pymysq模塊做映射，后面參數是最大連接數5
ENGINE=create_engine("mysql+pymysql://root@127.0.0.1:3306/digchouti?charset=utf8", max_overflow=5)
Session = sessionmaker(bind=engine)

session = Session()

三、創建映射(創建表)

一個映射對應着一個Python類，用來表示一個表的結構。下面創建一個person表，包括id和name兩個字段。也就是說創建表就是用python的的類來實現

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@127.0.0.1:3306/digchouti?charset=utf8", max_overflow=5)

#生成一個SQLORM基類，創建表必須繼承他，別問我啥意思就是這么規定的
Base = declarative_base()

class Person(Base):
    __tablename__ = 'userinfo'

    id   = Column(Integer, primary_key=True)
    name = Column(String(32))

    def __repr__(self):
        return "<Person(name='%s')>" % self.name

此代碼是創建了一個名字叫userinfo的表，表里有兩列，一列是id，一列是name。

四、添加數據

當然我們創建了表，肯定也要添加數據,代碼如下：

#創建一個person對象
person = Person(name='張岩林')
#添加person對象，但是仍然沒有提交到數據庫
session.add(person)
#提交數據庫
session.commit()

當然還能添加多條數據：

session.add_all([
    Person(name='張岩林'),
    Person(name='aylin')
])
session.commit()

五、查找數據

在sqlalchemy模塊中，查找數據給提供了query()的方法 下面我就把能用到的給列舉一下：

#獲取所有數據
session.query(Person).all()

#獲取name=‘張岩林’的那行數據
session.query(Person).filter(Person.name=='張岩林').one()

#獲取返回數據的第一行
session.query(Person).first()

#查找id大於1的所有數據
session.query(Person.name).filter(Person.id>1).all()

#limit索引取出第一二行數據
session.query(Person).all()[1:3]

#order by,按照id從大到小排列
session.query(Person).ordre_by(Person.id)

#equal/like/in
query = session.query(Person)
query.filter(Person.id==1).all()
query.filter(Person.id!=1).all()
query.filter(Person.name.like('%ay%')).all()
query.filter(Person.id.in_([1,2,3])).all()
query.filter(~Person.id.in_([1,2,3])).all()
query.filter(Person.name==None).all()

#and or
from sqlalchemy import and_
from sqlalchemy import or_
query.filter(and_(Person.id==1, Person.name=='張岩林')).all()
query.filter(Person.id==1, Person.name=='張岩林').all()
query.filter(Person.id==1).filter(Person.name=='張岩林').all()
query.filter(or_(Person.id==1, Person.id==2)).all()

# count計算個數
session.query(Person).count()

# 修改update
session.query(Person).filter(id > 2).update({'name' : '張岩林'})

# 通配符
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()

查詢這塊比較多，可能寫的不全還望各位見諒，剩下我相信大家都能擴展起來

上面的介紹完了，可能各位還不能吧融合到一塊去，下面我給大家融合寫在一塊吧：

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

ENGINE=create_engine("mysql+pymysql://root@127.0.0.1:3306/digchouti?charset=utf8", max_overflow=5)

Base = declarative_base()

class Person(Base):
    __tablename__ = 'userinfo'

    id   = Column(Integer, primary_key=True)
    name = Column(String(32))

    def __repr__(self):
        return "<Person(name='%s')>" % self.name

#創建連接數據庫以供提交用，至此表會創建完成，可以去數據庫里面查看
Base.metadata.create_all(ENGINE)
Session = sessionmaker(bind=engine)
# 往里面插入多條數據
session = Session()
session.add_all([
    Person(name='張岩林'),
    Person(name='很帥')
])
session.commit()

sqlalchemy表關系之高級用法

上面闡述的是對於一張表的操作，下面將說的是表關系的一對多，多對多，了解數據庫的都知道外鍵，也就是表關系建立。

1、一對多外鍵(1)

第一種方法我們只用到普通的操作，這個方式相對於好理解，在第一張表創建完，插入數據然后要記得提交數據，然后往第二章表創建數據的時候，可以直接拿第一張相關聯的數據，代碼如下：

#!/usr/bin/env python
# -*- coding:utf-8 -*-

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


engine=create_engine('mysql+pymysql://root@127.0.0.1:3306/db1')

Base = declarative_base()

class Son(Base):
    __tablename__ = 'son'
    id = Column(Integer,primary_key=True)
    name = Column(String(32))
    age = Column(String(32))
    # 創建外鍵，對應父親那張表的id項
    father_id = Column(Integer,ForeignKey('father.id'))

class Father(Base):
    __tablename__ = 'father'
    id = Column(Integer,primary_key=True)
    name = Column(String(32))
    age = Column(String(32))

Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)
session = Session()

f1 = Father(name = 'zhangyanlin',age = '18')
session.add(f1)
session.commit()

w1 = Son(name = 'xiaozhang1',age = 3,father_id = 1)
w2 = Son(name = 'xiaozhang2',age = 3,father_id = 1)

session.add_all([w1,w2])
session.commit()

2、一對多外鍵(2)relationship

 第二種方法和第一種一樣，只是這里改用了relationship來做外鍵關系，代碼如下：

#!/usr/bin/env python
# -*- coding:utf-8 -*-

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


engine = create_engine('mysql+pymysql://root@127.0.0.1:3306/db1')

Base = declarative_base()

class Son(Base):
    __tablename__ = 'son'
    id = Column(Integer,primary_key=True)
    name = Column(String(32))
    age = Column(String(32))

    father_id = Column(Integer,ForeignKey('father.id'))

class Father(Base):
    __tablename__ = 'father'
    id = Column(Integer,primary_key=True)
    name = Column(String(32))
    age = Column(String(32))
    son = relationship('Son')

Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)
session = Session()

f1 = Father(name = 'zhangyanlin',age = '18')

w1 = Son(name = 'xiaozhang1',age = '3')
w2 = Son(name = 'xiaozhang2',age = '4')
# 重點是這里綁定關系
f1.son = [w1,w2]
# 只需要把父親給傳進去，兒子的自然就上傳進去啦
session.add(f1)
session.commit()