【Python3网络爬虫开发实战】5-数据存储-2-关系型数据库存储-1 MySQL存储

关系型数据库是基于关系模型的数据库，而关系模型是经过二维表来保存的，因此它的存储方式就是行列组成的表，每一列是一个字段，每一行是一条记录。表能够看做某个实体的集合，而实体之间存在联系，这就须要表与表之间的关联关系来体现，如主键外键的关联关系。多个表组成一个数据库，也就是关系型数据库。

关系型数据库有多种，如SQLite、MySQL、Oracle、SQL Server、DB2等。

本节中，咱们主要介绍Python 3下MySQL的存储。

在Python 2中，链接MySQL的库大可能是使用MySQLdb，可是此库的官方并不支持Python 3，因此这里推荐使用的库是PyMySQL。

本节中，咱们就来说解使用PyMySQL操做MySQL数据库的方法。

1. 准备工做

在开始以前，请确保已经安装好了MySQL数据库并保证它能正常运行，并且须要安装好PyMySQL库。若是没有安装，能够参考第1章。

2. 链接数据库

这里，首先尝试链接一下数据库。假设当前的MySQL运行在本地，用户名为root，密码为123456，运行端口为3306。这里利用PyMySQL先链接MySQL，而后建立一个新的数据库，名字叫做spiders，代码以下：

import pymysql

db = pymysql.connect(host='localhost',user='root', password='123456', port=3306)
cursor = db.cursor()
cursor.execute('SELECT VERSION()')
data = cursor.fetchone()
print('Database version:', data)
cursor.execute("CREATE DATABASE spiders DEFAULT CHARACTER SET utf8")
db.close()
复制代码

运行结果以下：

Database version: ('5.6.22',)
复制代码

这里经过PyMySQL的connect()方法声明一个MySQL链接对象db，此时须要传入MySQL运行的host（即IP）。因为MySQL在本地运行，因此传入的是localhost。若是MySQL在远程运行，则传入其公网IP地址。后续的参数user即用户名，password即密码，port即端口（默认为3306）。

链接成功后，须要再调用cursor()方法得到MySQL的操做游标，利用游标来执行SQL语句。这里咱们执行了两句SQL，直接用execute()方法执行便可。第一句SQL用于得到MySQL的当前版本，而后调用fetchone()方法得到第一条数据，也就获得了版本号。第二句SQL执行建立数据库的操做，数据库名叫做spiders，默认编码为UTF-8。因为该语句不是查询语句，因此直接执行后就成功建立了数据库spiders。接着，再利用这个数据库进行后续的操做。

3. 建立表

通常来讲，建立数据库的操做只须要执行一次就行了。固然，咱们也能够手动建立数据库。之后，咱们的操做都在spiders数据库上执行。

建立数据库后，在链接时须要额外指定一个参数db。

接下来，新建立一个数据表students，此时执行建立表的SQL语句便可。这里指定3个字段，结构如表5-1所示。

表5-1 数据表students

建立该表的示例代码以下：

import pymysql

db = pymysql.connect(host='localhost', user='root', password='123456', port=3306, db='spiders')
cursor = db.cursor()
sql = 'CREATE TABLE IF NOT EXISTS students (id VARCHAR(255) NOT NULL, name VARCHAR(255) NOT NULL, age INT NOT NULL, PRIMARY KEY (id))'
cursor.execute(sql)
db.close()
复制代码

运行以后，咱们便建立了一个名为students的数据表。

固然，为了演示，这里只指定了最简单的几个字段。实际上，在爬虫过程当中，咱们会根据爬取结果设计特定的字段。

4. 插入数据

下一步就是向数据库中插入数据了。例如，这里爬取了一个学生信息，学号为20120001，名字为Bob，年龄为20，那么如何将该条数据插入数据库呢？示例代码以下：

import pymysql

id = '20120001'
user = 'Bob'
age = 20

db = pymysql.connect(host='localhost', user='root', password='123456', port=3306, db='spiders')
cursor = db.cursor()
sql = 'INSERT INTO students(id, name, age) values(%s, %s, %s)'
try:
    cursor.execute(sql, (id, user, age))
    db.commit()
except:
    db.rollback()
db.close()
复制代码

这里首先构造了一个SQL语句，其Value值没有用字符串拼接的方式来构造，如：

sql = 'INSERT INTO students(id, name, age) values(' + id + ', ' + name + ', ' + age + ')'
复制代码

这样的写法烦琐并且不直观，因此咱们选择直接用格式化符%s来实现。有几个Value写几个%s，咱们只须要在execute()方法的第一个参数传入该SQL语句，Value值用统一的元组传过来就行了。这样的写法既能够避免字符串拼接的麻烦，又能够避免引号冲突的问题。

以后值得注意的是，须要执行db对象的commit()方法才可实现数据插入，这个方法才是真正将语句提交到数据库执行的方法。对于数据插入、更新、删除操做，都须要调用该方法才能生效。

接下来，咱们加了一层异常处理。若是执行失败，则调用rollback()执行数据回滚，至关于什么都没有发生过。

这里涉及事务的问题。事务机制能够确保数据的一致性，也就是这件事要么发生了，要么没有发生。好比插入一条数据，不会存在插入一半的状况，要么所有插入，要么都不插入，这就是事务的原子性。另外，事务还有3个属性——一致性、隔离性和持久性。这4个属性一般称为ACID特性，具体如表5-2所示。

表5-2 事务的4个属性

插入、更新和删除操做都是对数据库进行更改的操做，而更改操做都必须为一个事务，因此这些操做的标准写法就是：

try:
    cursor.execute(sql)
    db.commit()
except:
    db.rollback()
复制代码

这样即可以保证数据的一致性。这里的commit()和rollback()方法就为事务的实现提供了支持。

上面数据插入的操做是经过构造SQL语句实现的，可是很明显，这有一个极其不方便的地方，好比忽然增长了性别字段gender，此时SQL语句就须要改为：

INSERT INTO students(id, name, age, gender) values(%s, %s, %s, %s)
复制代码

相应的元组参数则须要改为：

(id, name, age, gender)
复制代码

这显然不是咱们想要的。在不少状况下，咱们要达到的效果是插入方法无需改动，作成一个通用方法，只须要传入一个动态变化的字典就行了。好比，构造这样一个字典：

{
    'id': '20120001',
    'name': 'Bob',
    'age': 20
}
复制代码

而后SQL语句会根据字典动态构造，元组也动态构造，这样才能实现通用的插入方法。因此，这里咱们须要改写一下插入方法：

data = {
    'id': '20120001',
    'name': 'Bob',
    'age': 20
}
table = 'students'
keys = ', '.join(data.keys())
values = ', '.join(['%s'] * len(data))
sql = 'INSERT INTO {table}({keys}) VALUES ({values})'.format(table=table, keys=keys, values=values)
try:
   if cursor.execute(sql, tuple(data.values())):
       print('Successful')
       db.commit()
except:
    print('Failed')
    db.rollback()
db.close()
复制代码

这里咱们传入的数据是字典，并将其定义为data变量。表名也定义成变量table。接下来，就须要构造一个动态的SQL语句了。

首先，须要构造插入的字段id、name和age。这里只须要将data的键名拿过来，而后用逗号分隔便可。因此', '.join(data.keys())的结果就是id, name, age，而后须要构造多个%s看成占位符，有几个字段构造几个便可。好比，这里有三个字段，就须要构造%s, %s, %s。这里首先定义了长度为1的数组['%s']，而后用乘法将其扩充为['%s', '%s', '%s']，再调用join()方法，最终变成%s, %s, %s。最后，咱们再利用字符串的format()方法将表名、字段名和占位符构造出来。最终的SQL语句就被动态构形成了：

INSERT INTO students(id, name, age) VALUES (%s, %s, %s)
复制代码

最后，为execute()方法的第一个参数传入sql变量，第二个参数传入data的键值构造的元组，就能够成功插入数据了。

如此以来，咱们便实现了传入一个字典来插入数据的方法，不须要再去修改SQL语句和插入操做了。

5. 更新数据

数据更新操做实际上也是执行SQL语句，最简单的方式就是构造一个SQL语句，而后执行：

sql = 'UPDATE students SET age = %s WHERE name = %s'
try:
   cursor.execute(sql, (25, 'Bob'))
   db.commit()
except:
   db.rollback()
db.close()
复制代码

这里一样用占位符的方式构造SQL，而后执行execute()方法，传入元组形式的参数，一样执行commit()方法执行操做。若是要作简单的数据更新的话，彻底可使用此方法。

可是在实际的数据抓取过程当中，大部分状况下须要插入数据，可是咱们关心的是会不会出现重复数据，若是出现了，咱们但愿更新数据而不是重复保存一次。另外，就像前面所说的动态构造SQL的问题，因此这里能够再实现一种去重的方法，若是数据存在，则更新数据；若是数据不存在，则插入数据。另外，这种作法支持灵活的字典传值。示例以下：

data = {
    'id': '20120001',
    'name': 'Bob',
    'age': 21
}

table = 'students'
keys = ', '.join(data.keys())
values = ', '.join(['%s'] * len(data))

sql = 'INSERT INTO {table}({keys}) VALUES ({values}) ON DUPLICATE KEY UPDATE'.format(table=table, keys=keys, values=values)
update = ','.join([" {key} = %s".format(key=key) for key in data])
sql += update
try:
    if cursor.execute(sql, tuple(data.values())*2):
        print('Successful')
        db.commit()
except:
    print('Failed')
    db.rollback()
db.close()
复制代码

这里构造的SQL语句实际上是插入语句，可是咱们在后面加了ON DUPLICATE KEY UPDATE。这行代码的意思是若是主键已经存在，就执行更新操做。好比，咱们传入的数据id仍然为20120001，可是年龄有所变化，由20变成了21，此时这条数据不会被插入，而是直接更新id为20120001的数据。完整的SQL构造出来是这样的：

INSERT INTO students(id, name, age) VALUES (%s, %s, %s) ON DUPLICATE KEY UPDATE id = %s, name = %s, age = %s
复制代码

这里就变成了6个%s。因此在后面的execute()方法的第二个参数元组就须要乘以2变成原来的2倍。

如此一来，咱们就能够实现主键不存在便插入数据，存在则更新数据的功能了。

6. 删除数据

删除操做相对简单，直接使用DELETE语句便可，只是须要指定要删除的目标表名和删除条件，并且仍然须要使用db的commit()方法才能生效。示例以下：

table = 'students'
condition = 'age > 20'

sql = 'DELETE FROM {table} WHERE {condition}'.format(table=table, condition=condition)
try:
    cursor.execute(sql)
    db.commit()
except:
    db.rollback()

db.close()
复制代码

由于删除条件有多种多样，运算符有大于、小于、等于、LIKE等，条件链接符有AND、OR等，因此再也不继续构造复杂的判断条件。这里直接将条件看成字符串来传递，以实现删除操做。

7. 查询数据

说完插入、修改和删除等操做，还剩下很是重要的一个操做，那就是查询。查询会用到SELECT语句，示例以下：

sql = 'SELECT * FROM students WHERE age >= 20'

try:
    cursor.execute(sql)
    print('Count:', cursor.rowcount)
    one = cursor.fetchone()
    print('One:', one)
    results = cursor.fetchall()
    print('Results:', results)
    print('Results Type:', type(results))
    for row in results:
        print(row)
except:
    print('Error')
复制代码

运行结果以下：

Count: 4
One: ('20120001', 'Bob', 25)
Results: (('20120011', 'Mary', 21), ('20120012', 'Mike', 20), ('20120013', 'James', 22))
Results Type: <class 'tuple'>
('20120011', 'Mary', 21)
('20120012', 'Mike', 20)
('20120013', 'James', 22)
复制代码

这里咱们构造了一条SQL语句，将年龄20岁及以上的学生查询出来，而后将其传给execute()方法。注意，这里再也不须要db的commit()方法。接着，调用cursor的rowcount属性获取查询结果的条数，当前示例中是4条。

而后咱们调用了fetchone()方法，这个方法能够获取结果的第一条数据，返回结果是元组形式，元组的元素顺序跟字段一一对应，即第一个元素就是第一个字段id，第二个元素就是第二个字段name，以此类推。随后，咱们又调用了fetchall()方法，它能够获得结果的全部数据。而后将其结果和类型打印出来，它是二重元组，每一个元素都是一条记录，咱们将其遍历输出出来。

可是这里须要注意一个问题，这里显示的是3条数据而不是4条，fetchall()方法不是获取全部数据吗？这是由于它的内部实现有一个偏移指针用来指向查询结果，最开始偏移指针指向第一条数据，取一次以后，指针偏移到下一条数据，这样再取的话，就会取到下一条数据了。咱们最初调用了一次fetchone()方法，这样结果的偏移指针就指向下一条数据，fetchall()方法返回的是偏移指针指向的数据一直到结束的全部数据，因此该方法获取的结果就只剩3个了。

此外，咱们还能够用while循环加fetchone()方法来获取全部数据，而不是用fetchall()所有一块儿获取出来。fetchall()会将结果以元组形式所有返回，若是数据量很大，那么占用的开销会很是高。所以，推荐使用以下方法来逐条取数据：

sql = 'SELECT * FROM students WHERE age >= 20'
try:
    cursor.execute(sql)
    print('Count:', cursor.rowcount)
    row = cursor.fetchone()
    while row:
        print('Row:', row)
        row = cursor.fetchone()
except:
    print('Error')
复制代码

这样每循环一次，指针就会偏移一条数据，随用随取，简单高效。

本节中，咱们介绍了如何使用PyMySQL操做MySQL数据库以及一些SQL语句的构造方法，后面会在实战案例中应用这些操做来存储数据。

本资源首发于崔庆才的我的博客静觅： Python3网络爬虫开发实战教程 | 静觅

如想了解更多爬虫资讯，请关注个人我的微信公众号：进击的Coder

weixin.qq.com/r/5zsjOyvEZ… (二维码自动识别)