本篇對于Python操作MySQL主要使用兩種方式：

• 原生模塊 pymsql
• ORM框架 SQLAchemy

一、pymysql

• 1. 下載安裝
     pip 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()

二、SQLAchemy

SQLAlchemy是Python編程語言下的一款ORM框架，該框架建立在數據庫API之上，使用關系對象映射進行數據庫操作，簡言之便是：將對象轉換成SQL，然后使用數據API執行SQL并獲取執行結果
安裝：pip install SQLAlchemy

image.png

SQLAlchemy本身無法操作數據庫，其必須以來pymsql等第三方插件，Dialect用于和數據API進行交流，根據配置文件的不同調用不同的數據庫API，從而實現對數據庫的操作，如：

MySQL-Python
    mysql+mysqldb://<user>:<password>@<host>[:<port>]/<dbname>
   
pymysql
    mysql+pymysql://<username>:<password>@<host>/<dbname>[?<options>]
   
MySQL-Connector
    mysql+mysqlconnector://<user>:<password>@<host>[:<port>]/<dbname>
   
cx_Oracle
    oracle+cx_oracle://user:pass@host:port/dbname[?key=value&key=value...]
   
更多詳見：http://docs.sqlalchemy.org/en/latest/dialects/index.html

1、SQLAchemy的基本使用

• 創建表

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:123456@localhost/testdb",
                                    encoding='utf-8', 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))
 
Base.metadata.create_all(engine) #創建表結構

除上面的創建之外，還有一種創建表的方式，雖不常用，但還是看看吧

from sqlalchemy import Table, MetaData, Column, Integer, String, ForeignKey
from sqlalchemy.orm import mapper
 
metadata = MetaData()
 
user = Table('user', metadata,
            Column('id', Integer, primary_key=True),
            Column('name', String(50)),
            Column('fullname', String(50)),
            Column('password', String(12))
        )
 
class User(object):
    def __init__(self, name, fullname, password):
        self.name = name
        self.fullname = fullname
        self.password = password
 
mapper(User, user) 
#the table metadata is created separately with the Table construct,
 then associated with the User class via the mapper() function

事實上，我們用第一種方式創建的表就是基于第2種方式的再封裝。

• 新增

from sqlalchemy.orm import sessionmaker, relationship

Session_class = sessionmaker(bind=engine) 
#創建與數據庫的會話session class ,注意,這里返回給session的是個class,不是實例
Session = Session_class() #生成session實例

user_obj = User(name="alex",password="123456") #生成你要創建的數據對象
print(user_obj.name,user_obj.id)  #此時還沒創建對象呢，不信你打印一下id發現還是None
 
Session.add(user_obj) #把要創建的數據對象添加到這個session里， 一會統一創建
print(user_obj.name,user_obj.id) #此時也依然還沒創建
 
Session.commit() #現此才統一提交，創建數據

• 查詢

my_user = Session.query(User).filter_by(name="alex").first()
#這樣查詢出來的不是直接的數據是一個對象
print(my_user)#<__main__.User object at 0x105b4ba90>
#所以再經一輪提取才能獲得數據
print(my_user.id,my_user.name,my_user.password)

如果想查詢出來直接是數據的話，可以通過修改類的定義來返回

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

• 修改
  修改就是先查詢出將要修改的內容，然后直接重新對其賦值，這樣就能達到修改的目的。

my_user = Session.query(User).filter_by(name="alex").first()
my_user.name = "Alex Li" 
Session.commit()

• 回滾

my_user = Session.query(User).filter_by(id=1).first()
my_user.name = "Jack"
 
fake_user = User(name='Rain', password='12345')
Session.add(fake_user)
  #這時看session里有你剛添加和修改的數據
print(Session.query(User).filter(User.name.in_(['Jack','rain'])).all() ) 
#此時你rollback一下
Session.rollback() 
#再查就發現剛才添加的數據沒有了。
print(Session.query(User).filter(User.name.in_(['Jack','rain'])).all() ) 
# Session
# Session.commit()

• 獲取所有數據
  print(Session.query(User.name,User.id).all())
• 多條件查詢
  objs = Session.query(User).filter(User.id>0).filter(User.id<7).all()
  上面2個filter的關系相當于 user.id >1 AND user.id <7 的效果
• 統計和分組

#統計
Session.query(User).filter(User.name.like("Ra%")).count()
#分組
from sqlalchemy import func
print(Session.query(func.count(User.name),User.name).group_by(User.name).all() )
#相當于原生sql為
select count(user.name) AS count_1, user.name AS user_name
FROM user GROUP BY user.name

• 外鍵關聯
  我們創建一個addresses表，跟user表關聯

from sqlalchemy import Column, Integer, String, ForeignKey
from sqlalchemy.orm import relationship
 
class Address(Base):
    __tablename__ = 'addresses'
    id = Column(Integer, primary_key=True)
    email_address = Column(String(32), nullable=False)
    user_id = Column(Integer, ForeignKey('user.id'))
 
    user = relationship("User", backref="addresses") 
#這個nb，允許你在user表里通過backref字段反向查出所有它在addresses表里的關聯項
 
    def __repr__(self):
        return "<Address(email_address='%s')>" % self.email_address

表創建好后，我們可以這樣反查試試

obj = Session.query(User).first()
for i in obj.addresses: #通過user對象反查關聯的addresses記錄
    print(i)
 
addr_obj = Session.query(Address).first()
print(addr_obj.user.name)  #在addr_obj里直接查關聯的user表

創建關聯對象

obj = Session.query(User).filter(User.name=='rain').all()[0]
print(obj.addresses)
 
obj.addresses = [Address(email_address="r1@126.com"), #添加關聯對象
                 Address(email_address="r2@126.com")]
Session.commit()

2、多外鍵關聯
下表中，Customer表有2個字段都關聯了Address表

from sqlalchemy import Integer, ForeignKey, String, Column
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import relationship
 
Base = declarative_base()
 
class Customer(Base):
    __tablename__ = 'customer'
    id = Column(Integer, primary_key=True)
    name = Column(String)
 
    billing_address_id = Column(Integer, ForeignKey("address.id"))
    shipping_address_id = Column(Integer, ForeignKey("address.id"))
 
    billing_address = relationship("Address") 
    shipping_address = relationship("Address")
 
class Address(Base):
    __tablename__ = 'address'
    id = Column(Integer, primary_key=True)
    street = Column(String)
    city = Column(String)
    state = Column(String)

創建表結構是沒有問題的，但你Address表中插入數據時會報下面的錯.

sqlalchemy.exc.AmbiguousForeignKeysError: Could not determine join
condition between parent/child tables on relationship
Customer.billing_address - there are multiple foreign key
paths linking the tables.  Specify the 'foreign_keys' argument,
providing a list of those columns which should be
counted as containing a foreign key reference to the parent table.

解決辦法如下:

class Customer(Base):
    __tablename__ = 'customer'
    id = Column(Integer, primary_key=True)
    name = Column(String)
 
    billing_address_id = Column(Integer, ForeignKey("address.id"))
    shipping_address_id = Column(Integer, ForeignKey("address.id"))
 
    billing_address = relationship("Address", foreign_keys=[billing_address_id])
    shipping_address = relationship("Address", foreign_keys=[shipping_address_id])

這樣sqlachemy就能分清哪個外鍵是對應哪個字段了
3、多對多關系
現在來設計一個能描述“圖書”與“作者”的關系的表結構，需求是

• 一本書可以有好幾個作者一起出版
• 一個作者可以寫好幾本書

#一本書可以有多個作者，一個作者又可以出版多本書

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


Base = declarative_base()

book_m2m_author = Table('book_m2m_author', Base.metadata,
                        Column('book_id',Integer,ForeignKey('books.id')),
                        Column('author_id',Integer,ForeignKey('authors.id')),
                        )

class Book(Base):
    __tablename__ = 'books'
    id = Column(Integer,primary_key=True)
    name = Column(String(64))
    pub_date = Column(DATE)
    authors = relationship('Author',secondary=book_m2m_author,backref='books')

    def __repr__(self):
        return self.name

class Author(Base):
    __tablename__ = 'authors'
    id = Column(Integer, primary_key=True)
    name = Column(String(32))

    def __repr__(self):
        return self.name

接下來創建幾本書和作者

Session_class = sessionmaker(bind=engine) 
#創建與數據庫的會話session class ,注意,這里返回給session的是個class,不是實例
s = Session_class() #生成session實例
 
b1 = Book(name="Python入門到放棄")
b2 = Book(name="精通Python72式")
b3 = Book(name="MYSQL入門到裝逼")
b4 = Book(name="C#學習")
 
a1 = Author(name="Alex")
a2 = Author(name="Jack")
a3 = Author(name="Rain")
 
b1.authors = [a1,a2]
b2.authors = [a1,a2,a3]
 
s.add_all([b1,b2,b3,b4,a1,a2,a3])
 
s.commit()

此時，手動連上mysql，分別查看這3張表，你會發現，book_m2m_author中自動創建了多條紀錄用來連接book和author表

mysql> select * from books;
+----+------------------+----------+
| id | name             | pub_date |
+----+------------------+----------+
|  1 | Python入門到放棄   | NULL     |
|  2 | 精通Python72式     | NULL     |
|  3 | MYSQL入門到裝逼     | NULL     |
|  4 | C#學習     | NULL     |
+----+------------------+----------+
4 rows in set (0.00 sec)
 
mysql> select * from authors;
+----+------+
| id | name |
+----+------+
| 10 | Alex |
| 11 | Jack |
| 12 | Rain |
+----+------+
3 rows in set (0.00 sec)
 
mysql> select * from book_m2m_author;
+---------+-----------+
| book_id | author_id |
+---------+-----------+
|       2 |        10 |
|       2 |        11 |
|       2 |        12 |
|       1 |        10 |
|       1 |        11 |
+---------+-----------+
5 rows in set (0.00 sec)

此時，我們去用orm查一下數據

print('--------通過書表查關聯的作者---------')
 
book_obj = s.query(Book).filter_by(name="Python入門到放棄").first()
print(book_obj.name, book_obj.authors)
 
print('--------通過作者表查關聯的書---------')
author_obj =s.query(Author).filter_by(name="Alex").first()
print(author_obj.name , author_obj.books)
s.commit()

輸出如下:

--------通過書表查關聯的作者---------
Python入門到放棄 [Alex, Jack]
--------通過作者表查關聯的書---------
Alex [精通Python72式, Python入門到放棄]

• 多對多刪除
  刪除數據時不用管boo_m2m_authors　， sqlalchemy會自動幫你把對應的數據刪除
• 通過書刪除作者

author_obj =s.query(Author).filter_by(name="Jack").first()
 
book_obj = s.query(Book).filter_by(name="精通Python72式").first()
 
book_obj.authors.remove(author_obj) #從一本書里刪除一個作者
s.commit()

• 直接刪除作者
  刪除作者時，會把這個作者跟所有書的關聯關系數據也自動刪除

author_obj =s.query(Author).filter_by(name="Alex").first()
# print(author_obj.name , author_obj.books)
s.delete(author_obj)
s.commit()

• 處理中文
  sqlalchemy設置編碼字符集一定要在數據庫訪問的URL上增加charset=utf8，否則數據庫的連接就不是utf8的編碼格式:
  eng = create_engine('mysql://root:root@localhost:3306/test2?charset=utf8',echo=True)