python--mysql--驱动简介和使用_python连接mysql是什么协议驱动

本篇文章介绍 Python 操作 MySQL 的几种方式，你可以在实际开发过程中根据实际情况合理选择。

MySQL-python(MySQLdb）–支持python2.x

MySQL-python 又叫 MySQLdb，是 Python 连接 MySQL 最流行的一个驱动，很多框架都也是基于此库进行开发，遗憾的是它只支持 Python2.x，而且安装的时候有很多前置条件，因为它是基于C开发的库，在 Windows 平台安装非常不友好，经常出现失败的情况，现在基本不推荐使用，取代的是它的衍生版本。

Python-MySQL资格最老，核心由C语言打造，接口精炼，性能最棒，缺点是环境依赖较多，安装复杂，近两年已停止更新，只支持Python2，不支持Python3。

前置条件

sudo apt-get install python-dev libmysqlclient-dev # Ubuntu
sudo yum install python-devel mysql-devel # Red Hat / CentOS
1
2

安装

pip install MySQL-python
1

Windows 直接通过下载 exe 文件安装

使用

#!/usr/bin/python
import MySQLdb

db = MySQLdb.connect(
     host="localhost",    # 主机名
     user="john",         # 用户名
     passwd="megajonhy",  # 密码
     db="jonhydb")        # 数据库名称

# 查询前，必须先获取游标
cur = db.cursor()

# 执行的都是原生SQL语句
cur.execute("SELECT * FROM YOUR_TABLE_NAME")

for row in cur.fetchall():
    print(row[0])

db.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

mysqlclient–支持python2.x，Python3.x

由于 MySQL-python 年久失修，后来出现了它的 Fork 版本 mysqlclient，完全兼容 MySQLdb，同时支持 Python3.x，是 Django ORM的依赖工具，如果你想使用原生 SQL 来操作数据库，那么推荐此驱动。安装方式和 MySQLdb 是一样的，Windows 可以在 https://www.lfd.uci.edu/~gohlke/pythonlibs/#mysqlclient 网站找到 对应版本的 whl 包下载安装。

Windows安装

pip install some-package.whl
1

linux 前置条件

sudo apt-get install python3-dev # debian / Ubuntu
sudo yum install python3-devel # Red Hat / CentOS
brew install mysql-connector-c # macOS (Homebrew)

pip install mysqlclient
1
2
3
4
5

PyMySQL–支持python2.x，Python3.x

PyMySQL 是纯 Python 实现的驱动，速度上比不上 MySQLdb，最大的特点可能就是它的安装方式没那么繁琐，同时也兼容Python-MySQL(MySQLdb）

PyMySQL为替代Python-MySQL(MySQLdb）而生，纯python打造，接口与Python-MySQL兼容，安装方便，支持Python3。

pip install PyMySQL
1

PyMySQL兼容mysqldb

只需要加入

pymysql.install_as_MySQLdb()
1

使用

import pymysql
conn = pymysql.connect(host='127.0.0.1', user='root', passwd="xxx", db='mysql')
cur = conn.cursor()
cur.execute("SELECT Host,User FROM user")
for r in cur:
    print(r)
cur.close()
conn.close()
1
2
3
4
5
6
7
8

peewee–支持python2.x，Python3.x

写原生 SQL 的过程非常繁琐，代码重复，没有面向对象思维，继而诞生了很多封装 wrapper 包和 ORM 框架，ORM 是 Python 对象与数据库关系表的一种映射关系，有了 ORM 你不再需要写 SQL 语句。提高了写代码的速度，同时兼容多种数据库系统，如sqlite, mysql、postgresql，付出的代价可能就是性能上的一些损失。如果你对 Django 自带的 ORM 熟悉的话，那么 peewee的学习成本几乎为零。它是 Python 中是最流行的 ORM 框架。

pip install peewee
1

使用

import peewee
from peewee import *

db = MySQLDatabase('jonhydb', user='john', passwd='megajonhy')

class Book(peewee.Model):
    author = peewee.CharField()
    title = peewee.TextField()

    class Meta:
        database = db

Book.create_table()
book = Book(author="me", title='Peewee is cool')
book.save()
for book in Book.filter(author="me"):
    print(book.title)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

官方文档：http://docs.peewee-orm.com/en/latest/peewee/installation.html

SQLAlchemy–支持python2.x，Python3.x

SQLAlchemy是一个ORM框架，它并不提供底层的数据库操作，而是要借助于MySQLdb、PyMySQL等第三方库来完成，目前SQLAlchemy在Web编程领域应用广泛。

如果想找一种既支持原生 SQL，又支持 ORM 的工具，那么 SQLAlchemy 是最好的选择，它非常接近 Java 中的 Hibernate 框架。

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

from sqlalchemy_declarative import Address, Base, Person

class Address(Base):
    __tablename__ = 'address'
    id = Column(Integer, primary_key=True)
    street_name = Column(String(250))

engine = create_engine('sqlite:///sqlalchemy_example.db')
Base.metadata.bind = engine

DBSession = sessionmaker(bind=engine)
session = DBSession()

# Insert a Person in the person table
new_person = Person(name='new person')
session.add(new_person)
session.commit()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

更多PyMySQL用法

安装

简单的方式：

pip install pymysql
1

如果无法联网，需要进行离线安装，例如：

pip install pymysql-x.x.x.tar.gz
1

导入

import pymysql
1

连接

def connect_wxremit_db():
    return pymysql.connect(host='10.123.5.28',
                           port=3306,
                           user='root',
                           password='root1234',
                           database='db_name',
                           charset='latin1')
1
2
3
4
5
6
7

参数列表：

创建表格

# 获取游标
cursor = connection.cursor()
    
# 创建数据表
effect_row = cursor.execute('''
CREATE TABLE `users` (
  `name` varchar(32) NOT NULL,
  `age` int(10) unsigned NOT NULL DEFAULT '0',
  PRIMARY KEY (`name`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8
''')
1
2
3
4
5
6
7
8
9
10
11

查询

def query_country_name(cc2):
    sql_str = ("SELECT Fcountry_name_zh"
                + " FROM t_country_code"
                + " WHERE Fcountry_2code='%s'" % (cc2))
    logging.info(sql_str)

    con = mysql_api.connect_wxremit_db()
    cur = con.cursor()
    cur.execute(sql_str)
    rows = cur.fetchall()
	# 获取单条数据
    row = cur.fetchone()
	# 获取前N条数据
    rowmany =  cur.fetchmany(3)
    cur.close()
    con.close()

    assert len(rows) == 1, 'Fatal error: country_code does not exists!'
    return rows[0][0]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

查询遍历

import pymysql  #导入 pymysql
 
#打开数据库连接
db= pymysql.connect(host="localhost",user="root",
 	password="123456",db="test",port=3307)
 
# 使用cursor()方法获取操作游标
cur = db.cursor()
 
#1.查询操作
# 编写sql 查询语句  user 对应我的表名
sql = "select * from user"
try:
	cur.execute(sql) 	#执行sql语句
 
	results = cur.fetchall()	#获取查询的所有记录
	print("id","name","password")
	#遍历结果
	for row in results :
		id = row[0]
		name = row[1]
		password = row[2]
		print(id,name,password)
except Exception as e:
	raise e
finally:
	db.close()	#关闭连接
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

超过千万行的数据遍历

当使用sql查询的结果有非常多行时，如果使用默认的cursor，你的程序在接受数据的的时候很可能卡住或者被杀死，原因是mysql客户端（Java，Pyhton）默认在内存里缓存下所有行然后再处理，如果内存溢出后，你的程序就会被杀死。

解决方式是实用流式游标，在Python中，你可以使用pymysql.cursors.SSCursor（或者SSDictCursor）来解决这个问题

import pymysql
conn = pymysql.connect(...)
cursor = pymysql.cursors.SSCursor(conn)
cursor.execute(...)
while True:
    row = cursor.fetchone()
    if not row:
        break
    ...
1
2
3
4
5
6
7
8
9

这里有两点需要注意下：

使用pymysql.cursors.SSCursor代替默认的cursor。可以使用以上代码，或者这样写：conn.cursor(pymysql.cursors.SSCursor)
使用fetchone去每次只获得一行，别使用fetchall。也可以使用fetchmay，但是这样其实是多次调用fetchone。
对于SSCursor有一个错误的理解，就是SSCursor是服务端一次性读出所有数据然后一条一条返给客户端，其实不是这样的，这个cursor实际上没有缓存下来任何数据，它不会读取所有所有到内存中，它的做法是从储存块中读取记录，并且一条一条返回给你。这里有一个更适合的名字：流式游标。

因为SSCursor是没有缓存的游标，这里有几条约束：

这个connection只能读完所有行之后才能处理其他sql。如果你需要并行执行sql，在另外一个connection中执行，否则你会遇到 error 2014 , “Commands out of sync; you can’t run this command now.”
必须一次性读完所有行，每次读取后处理数据要快，不能超过60s，否则mysql将会断开这次连接（ error2013 , “Lost connection to MySQL server during query），也可以修改 SET NET_WRITE_TIMEOUT = xx 来增加超时间隔。
参考：Techualization: Retrieving million of rows from MySQL（原文更加详细）

查询数量

def count_t_quality_inspection_by_chip_barcode(chip, barcode):
    sql_str = ("SELECT * "
               + " FROM t_quality"
               + " WHERE chip='%s' and barcode='%s'" % (chip, barcode))
    con = connect_quality_db()
    cur = con.cursor()
    cur.execute(sql_str)
    rows = cur.rowcount
    logger.info("%s %s 在质检表中数量为 %i" % (chip, barcode,rows) )
    cur.close()
    con.close()
    return rows
1
2
3
4
5
6
7
8
9
10
11
12

游标控制

所有的数据查询操作均基于游标，我们可以通过cursor.scroll(num, mode)控制游标的位置。

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

设置游标类型

查询时，默认返回的数据类型为元组，可以自定义设置返回类型。支持5种游标类型：

Cursor: 默认，元组类型
DictCursor: 字典类型
DictCursorMixin: 支持自定义的游标类型，需先自定义才可使用
SSCursor: 无缓冲元组类型
SSDictCursor: 无缓冲字典类型
无缓冲游标类型，适用于数据量很大，一次性返回太慢，或者服务端带宽较小时。源码注释：

Unbuffered Cursor, mainly useful for queries that return a lot of data, or for connections to remote servers over a slow network.
Instead of copying every row of data into a buffer, this will fetch rows as needed. The upside of this is the client uses much less memory, and rows are returned much faster when traveling over a slow network or if the result set is very big.
There are limitations, though. The MySQL protocol doesn’t support returning the total number of rows, so the only way to tell how many rows there are is to iterate over every row returned. Also, it currently isn’t possible to scroll backwards, as only the current row is held in memory.
1
2
3

创建连接时，通过 cursorclass 参数指定类型：

connection = pymysql.connect(host='localhost',
                             user='root',
                             password='root',
                             db='demo',
                             charset='utf8',
                             cursorclass=pymysql.cursors.DictCursor)
							 
1
2
3
4
5
6
7

也可以在创建游标时指定类型：

cursor = connection.cursor(cursor=pymysql.cursors.DictCursor)
1

注意：INSERT、UPDATE、DELETE 等修改数据的语句需手动执行connection.commit()完成对数据修改的提交。

简单插入

def insert_file_rec(self, file_name, file_md5):
        con = mysql_api.connect_wxremit_db()
        cur = con.cursor()
        try:
            sql_str = ("INSERT INTO t_forward_file (Ffile_name, Ffile_md5)", 
                       + " VALUES ('%s', '%s')" % (file_name, file_md5))
            cur.execute(sql_str)
            con.commit()
        except:
            con.rollback()
            logging.exception('Insert operation error')
            raise
        finally:
            cur.close()
            con.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

批量插入

#new_items = [('1234', 'CAD'), ('5678', 'HKD')]

new_items=[]
for i in range(10000):
    new_item=(str(i),'zhangxiaofan')
	new_items.append(new_item)

con = mysql_api.connect_wxremit_db()
        cur = con.cursor()
        try:
                cur.executemany("INSERT INTO t_order (Fremit_id, Fcur_type, Fcreate_time"
                                                + " VALUES (%s, %s, now())", new_items)
                assert cur.rowcount == len(new_items), 'my error message'
                con.commit()
        except Exception as e:
                con.rollback()
                logging.exception('Insert operation error')
        finally:
                cur.close()
                con.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

executemany与on duplicate key update

#new_items = [('1234', 'CAD'), ('5678', 'HKD')]

new_items=[]
for i in range(10000):
    new_item=(str(i),'zhangxiaofan')
	new_items.append(new_item)

con = mysql_api.connect_wxremit_db()
        cur = con.cursor()
        try:
                cur.executemany("INSERT INTO t_order (Fremit_id, Fcur_type, Fcreate_time"
                                                + " VALUES (%s, %s, now())    on duplicate key update Fcreate_time = values(Fcreate_time)      ", new_items)
                assert cur.rowcount == len(new_items), 'my error message'
                con.commit()
        except Exception as e:
                con.rollback()
                logging.exception('Insert operation error')
        finally:
                cur.close()
                con.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

更新

    def update_refund_trans(self, remit_id):
        con = mysql_api.connect_wxremit_db()
        cur = con.cursor()
        try:
            sql_str = ("SELECT Fremit_id"
                       + " FROM t_wxrefund_trans"
                       + " WHERE Fremit_id='%s'" % remit_id
                       + " FOR UPDATE")
            logging.info(sql_str)

            cur.execute(sql_str)
            assert cur.rowcount == 1, 'Fatal error: The wx-refund record be deleted!'

            sql_str = ("UPDATE t_wxrefund_trans"
                        + " SET Fcheck_amount_flag=1"
                        + ", Fmodify_time=now()"
                        + " WHERE Fremit_id='%s'" % remit_id
            logging.info(sql_str)
            cur.execute(sql_str)

            assert cur.rowcount == 1, 'The number of affected rows not equal to 1'
            con.commit()
        except:
            con.rollback()
            logging.exception('Update operation error')
            raise
        finally:
            cur.close()
            con.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

事务处理

开启事务 connection.begin()

提交修改 connection.commit()

回滚事务 connection.rollback()

#!/usr/bin/python3
 
import pymysql
 
# 打开数据库连接
connection = pymysql.connect("localhost","testuser","test123","TESTDB" )
 
# 使用cursor()方法获取操作游标 
cursor = connection.cursor()
 
# SQL 插入语句
sql = "INSERT INTO EMPLOYEE(FIRST_NAME, \
       LAST_NAME, AGE, SEX, INCOME) \
       VALUES ('%s', '%s',  %s,  '%s',  %s)" % \
       ('Mac', 'Mohan', 20, 'M', 2000)
try:
   # 执行sql语句
   cursor.execute(sql)
   # 执行sql语句
   connection.commit()
except:
   # 发生错误时回滚
   connection.rollback()
 
# 关闭数据库连接
db.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

防 SQL 注入

转义特殊字符 connection.escape_string(str)

参数化语句 支持传入参数进行自动转义、格式化 SQL 语句，以避免 SQL 注入等安全问题。

# 插入数据(元组或列表)
effect_row = cursor.execute('INSERT INTO `users` (`name`, `age`) VALUES (%s, %s)', ('mary', 18))
# 插入数据(字典)
info = {'name': 'fake', 'age': 15}
effect_row = cursor.execute('INSERT INTO `users` (`name`, `age`) VALUES (%(name)s, %(age)s)', info)
# 批量插入
effect_row = cursor.executemany(
    'INSERT INTO `users` (`name`, `age`) VALUES (%s, %s) ON DUPLICATE KEY UPDATE age=VALUES(age)', [
        ('hello', 13),
        ('fake', 28),
    ])
1
2
3
4
5
6
7
8
9
10
11

参考链接:
https://foofish.net/python-mysql.html
https://juejin.im/entry/5ac32368f265da23750715b2
https://shockerli.net/post/python3-pymysql/
http://www.runoob.com/python3/python3-mysql.html