1.TXT文本存储
可以用requests将网页源代码获取下来，然后使用pyquery解析库解析，接下来将提取的标题、回答者、回答保存到文本，代码如下：
1 import requests 2 from pyquery import PyQuery as pq 3 4 url = 'https://www.zhihu.com/explore' 5 headers = { 6 'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36' 7 } 8 html = requests.get(url, headers=headers).text 9 doc = pq(html) 10 items = doc('.explore-tab .feed-item').items() 11 for item in items: 12 question = item.find('h2').text() 13 author = item.find('.author-link-line').text() 14 answer = pq(item.find('.content').html()).text() 15 file = open('explore.txt', 'a', encoding='utf-8') 16 file.write(' '.join([question, author, answer])) 17 file.write(' ' + '=' * 50 + ' ') 18 file.close()
运行程序，可以发现在本地生成了一个txt文件。
首先，用requests提取知乎的“发现”页面，然后将热门话题的问题、回答者、答案全文提取出来，然后利用Python提供的open()方法打开一个文本文件，获取一个文件操作对象，这里赋值为file，接着利用file对象的write()方法将提取的内容写入文件，最后调用close()方法将其关闭，这样抓取的内容即可成功写入文本中了。
这里open()方法的第一个参数即要保存的目标文件名称，第二个参数为a，代表以追加方式写入到文本。另外，我们还指定了文件的编码为utf-8。最后，写入完成后，还需要调用close()方法来关闭文件对象。
打开方式
在刚才的实例中，open()方法的第二个参数设置成了a，这样在每次写入文本时不会清空源文件，而是在文件末尾写入新的内容，这是一种文件打开方式。关于文件的打开方式，其实还有其他几种，这里简要介绍一下。
r：以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。rb：以二进制只读方式打开一个文件。文件指针将会放在文件的开头。r+：以读写方式打开一个文件。文件指针将会放在文件的开头。rb+：以二进制读写方式打开一个文件。文件指针将会放在文件的开头。w：以写入方式打开一个文件。如果该文件已存在，则将其覆盖。如果该文件不存在，则创建新文件。wb：以二进制写入方式打开一个文件。如果该文件已存在，则将其覆盖。如果该文件不存在，则创建新文件。w+：以读写方式打开一个文件。如果该文件已存在，则将其覆盖。如果该文件不存在，则创建新文件。wb+：以二进制读写格式打开一个文件。如果该文件已存在，则将其覆盖。如果该文件不存在，则创建新文件。a：以追加方式打开一个文件。如果该文件已存在，文件指针将会放在文件结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，则创建新文件来写入。
ab：以二进制追加方式打开一个文件。如果该文件已存在，则文件指针将会放在文件结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，则创建新文件来写入。
a+：以读写方式打开一个文件。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，则创建新文件来读写。ab+：以二进制追加方式打开一个文件。如果该文件已存在，则文件指针将会放在文件结尾。如果该文件不存在，则创建新文件用于读写。
另外，文件写入还有一种简写方法，那就是使用with as语法。在with控制块结束时，文件会自动关闭，所以就不需要再调用close()方法了。这种保存方式可以简写如下：
1 with open('explore.txt', 'a', encoding='utf-8') as file: 2 file.write(' '.join([question, author, answer])) 3 file.write(' ' + '=' * 50 + ' ')
2.JSON文件存储
JSON，全称为JavaScript Object Notation, 也就是JavaScript对象标记，它通过对象和数组的组合来表示数据，构造简洁但是结构化程度非常高，是一种轻量级的数据交换格式。
对象和数组
在JavaScript语言中，一切都是对象。因此，任何支持的类型都可以通过JSON来表示，例如字符串、数字、对象、数组等，但是对象和数组是比较特殊且常用的两种类型。
- 对象：它在JavaScript中是使用花括号
{}包裹起来的内容，数据结构为{key1：value1, key2：value2, ...}的键值对结构。在面向对象的语言中，key为对象的属性，value为对应的值。键名可以使用整数和字符串来表示。值的类型可以是任意类型。 - 数组：数组在JavaScript中是方括号
[]包裹起来的内容，数据结构为["java", "javascript", "vb", ...]的索引结构。在JavaScript中，数组是一种比较特殊的数据类型，它也可以像对象那样使用键值对，但还是索引用得多。同样，值的类型可以是任意类型。
所以，一个JSON对象可以写为如下形式：
[{ "name": "Bob", "gender": "male", "birthday": "1992-10-18" }, { "name": "Selina", "gender": "female", "birthday": "1995-10-18" }]
由中括号包围的就相当于列表类型，列表中的每个元素可以是任意类型，这个示例中它是字典类型，由大括号包围。
JSON可以由以上两种形式自由组合而成，可以无限次嵌套，结构清晰，是数据交换的极佳方式。
读取JSON
Python为我们提供了简单易用的库来实现JSON文件的读写操作，我们可以调用库的loads()方法将JSON文本字符串转为JSON对象，可以通过dumps()方法将JSON对象转为文本字符串。
例如，这里有一段JSON形式的字符串，它是str类型，我们用Python将其转换为可操作的数据结构，如列表或字典：
import json str = ''' [{ "name": "Bob", "gender": "male", "birthday": "1992-10-18" }, { "name": "Selina", "gender": "female", "birthday": "1995-10-18" }] ''' print(type(str)) data = json.loads(str) print(data) print(type(data))
运行结果：
<class 'str'> [{'name': 'Bob', 'gender': 'male', 'birthday': '1992-10-18'}, {'name': 'Selina', 'gender': 'female', 'birthday': '1995-10-18'}] <class 'list'>
这里使用loads()方法将字符串转为JSON对象。由于最外层是中括号，所以最终的类型是列表类型。
这样一来，我们就可以用索引来获取对应的内容了。例如，如果想取第一个元素里的name属性，就可以使用如下方式：
data[0]['name'] data[0].get('name')
得到的结果都是：Bob
通过中括号加0索引，可以得到第一个字典元素，然后再调用其键名即可得到相应的键值。获取键值时有两种方式，一种是中括号加键名，另一种是通过get()方法传入键名。这里推荐使用get()方法，这样如果键名不存在，则不会报错，会返回None。另外，get()方法还可以传入第二个参数（即默认值），示例如下：
data[0].get('age') data[0].get('age', 25)
运行结果如下：
None
25
这里我们尝试获取年龄age，其实在原字典中该键名不存在，此时默认会返回None。如果传入第二个参数（即默认值），那么在不存在的情况下返回该默认值。
值得注意的是，JSON的数据需要用双引号来包围，不能使用单引号。若使用单引号来包围表示，会出现错误。
如果从JSON文本中读取内容，例如这里有一个data.文本文件，其内容是刚才定义的JSON字符串，我们可以先将文本文件内容读出，然后再利用loads()方法转化：
import json with open('data.json', 'r') as file: str = file.read() data = json.loads(str) print(data)
结果为：
[{'name': 'Bob', 'gender': 'male', 'birthday': '1992-10-18'}, {'name': 'Selina', 'gender': 'female', 'birthday': '1995-10-18'}]
输出JSON，还可以调用dumps()方法将JSON对象转化为字符串。例如，将上例中的列表重新写入文本：
import json data = [{ 'name': 'Bob', 'gender': 'male', 'birthday': '1992-10-18' }] with open('data.json', 'w') as file: file.write(json.dumps(data))
利用dumps()方法，我们可以将JSON对象转为字符串，然后再调用文件的write()方法写入文本。
如果想保存JSON的格式，可以再加一个参数indent，代表缩进字符个数。示例如下：
with open('data.json', 'w') as file: file.write(json.dumps(data, indent=2))
如果JSON中包含中文字符，中文字符都变成了Unicode字符。
为了输出中文，还需要指定参数ensure_ascii为False，另外还要规定文件输出的编码：
with open('data.json', 'w', encoding='utf-8') as file: file.write(json.dumps(data, indent=2, ensure_ascii=False))
这样就可以输出JSON为中文了。
3.CSV文件存储
CSV，全称为Comma-Separated Values，中文可以叫作逗号分隔值或字符分隔值，其文件以纯文本形式存储表格数据。该文件是一个字符序列，可以由任意数目的记录组成，记录间以某种换行符分隔。每条记录由字段组成，字段间的分隔符是其他字符或字符串，最常见的是逗号或制表符。不过所有记录都有完全相同的字段序列，相当于一个结构化表的纯文本形式。它比Excel文件更加简介，XLS文本是电子表格，它包含了文本、数值、公式和格式等内容，而CSV中不包含这些内容，就是特定字符分隔的纯文本，结构简单清晰。所以，有时候用CSV来保存数据是比较方便的。
写入
import csv with open('data.csv', 'w') as csvfile: writer = csv.writer(csvfile) writer.writerow(['id', 'name', 'age']) writer.writerow(['10001', 'Mike', 20]) writer.writerow(['10002', 'Bob', 22]) writer.writerow(['10003', 'Jordan', 21])
首先，打开data.csv文件，然后指定打开的模式为w（即写入），获得文件句柄，随后调用csv库的writer()方法初始化写入对象，传入该句柄，然后调用writerow()方法传入每行的数据即可完成写入。
运行结束后，会生成一个名为data.csv的文件，此时数据就成功写入了。
直接以文本形式打开的话，其内容如下：
写入的文本默认以逗号分隔，调用一次writerow()方法即可写入一行数据。
用Excel打开的结果如图所示。
如果想修改列与列之间的分隔符，可以传入delimiter参数，其代码如下：
import csv with open('data.csv', 'w') as csvfile: writer = csv.writer(csvfile, delimiter=' ') writer.writerow(['id', 'name', 'age']) writer.writerow(['10001', 'Mike', 20]) writer.writerow(['10002', 'Bob', 22]) writer.writerow(['10003', 'Jordan', 21])
这里在初始化写入对象时传入delimiter为空格，此时输出结果的每一列就是以空格分隔了
另外，我们也可以调用writerows()方法同时写入多行，此时参数就需要为二维列表，例如：
import csv with open('data.csv', 'w') as csvfile: writer = csv.writer(csvfile) writer.writerow(['id', 'name', 'age']) writer.writerows([['10001', 'Mike', 20], ['10002', 'Bob', 22], ['10003', 'Jordan', 21]])
输出效果是相同的。
但是一般情况下，爬虫爬取的都是结构化数据，我们一般会用字典来表示。在csv库中也提供了字典的写入方式，示例如下：
import csv with open('data.csv', 'w') as csvfile: fieldnames = ['id', 'name', 'age'] writer = csv.DictWriter(csvfile, fieldnames=fieldnames) writer.writeheader() writer.writerow({'id': '10001', 'name': 'Mike', 'age': 20}) writer.writerow({'id': '10002', 'name': 'Bob', 'age': 22}) writer.writerow({'id': '10003', 'name': 'Jordan', 'age': 21})
这里先定义3个字段，用fieldnames表示，然后将其传给DictWriter来初始化一个字典写入对象，接着可以调用writeheader()方法先写入头信息，然后再调用writerow()方法传入相应字典即可。最终写入的结果是完全相同的。
如果想追加写入的话，可以修改文件的打开模式，即将open()函数的第二个参数改成a，代码如下：
import csv with open('data.csv', 'a') as csvfile: fieldnames = ['id', 'name', 'age'] writer = csv.DictWriter(csvfile, fieldnames=fieldnames) writer.writerow({'id': '10004', 'name': 'Durant', 'age': 22})
数据被追加写入到文件中。
如果要写入中文内容的话，可能会遇到字符编码的问题，此时需要给open()参数指定编码格式。比如，这里再写入一行包含中文的数据，代码需要改写如下：
import csv with open('data.csv', 'a', encoding='utf-8') as csvfile: fieldnames = ['id', 'name', 'age'] writer = csv.DictWriter(csvfile, fieldnames=fieldnames) writer.writerow({'id': '10005', 'name': '王伟', 'age': 22})
同样可以使用csv库来读取CSV文件。例如，将刚才写入的文件内容读取出来，相关代码如下：
import csv with open('data.csv', 'r', encoding='utf-8') as csvfile: reader = csv.reader(csvfile) for row in reader: print(row)
运行结果如下：
['id', 'name', 'age'] ['10001', 'Mike', '20'] ['10002', 'Bob', '22'] ['10003', 'Jordan', '21'] ['10004', 'Durant', '22'] ['10005', '王伟', '22']
4.MySQL存储
假设当前的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。接着，再利用这个数据库进行后续的操作。
创建数据库后，在连接时需要额外指定一个参数db。
接下来，新创建一个数据表students，此时执行创建表的SQL语句即可。
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()
一个学生信息，学号为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()
选择直接用格式化符%s来实现。有几个Value写几个%s，我们只需要在execute()方法的第一个参数传入该SQL语句，Value值用统一的元组传过来就好了。这样的写法既可以避免字符串拼接的麻烦，又可以避免引号冲突的问题。
之后值得注意的是，需要执行db对象的commit()方法才可实现数据插入，这个方法才是真正将语句提交到数据库执行的方法。对于数据插入、更新、删除操作，都需要调用该方法才能生效。
接下来，我们加了一层异常处理。如果执行失败，则调用rollback()执行数据回滚，相当于什么都没有发生过。
这里涉及事务的问题。事务机制可以确保数据的一致性，也就是这件事要么发生了，要么没有发生。比如插入一条数据，不会存在插入一半的情况，要么全部插入，要么都不插入，这就是事务的原子性。另外，事务还有3个属性——一致性、隔离性和持久性。
插入、更新和删除操作都是对数据库进行更改的操作，而更改操作都必须为一个事务，所以这些操作的标准写法就是：
try: cursor.execute(sql) db.commit() except: db.rollback()
这样便可以保证数据的一致性。这里的commit()和rollback()方法就为事务的实现提供了支持。
上面数据插入的操作是通过构造SQL语句实现的，但是很明显，这有一个极其不方便的地方，比如突然增加了性别字段gender
改写一下插入方法：
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语句，最简单的方式就是构造一个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
如此一来，我们就可以实现主键不存在便插入数据，存在则更新数据的功能了。
删除操作相对简单，直接使用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
查询会用到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')
这里我们构造了一条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')
这样每循环一次，指针就会偏移一条数据，随用随取，简单高效。
4.MongoDB存储
连接MongoDB时，我们需要使用PyMongo库里面的MongoClient。一般来说，传入MongoDB的IP及端口即可，其中第一个参数为地址host，第二个参数为端口port（如果不给它传递参数，默认是27017）：
import pymongo client = pymongo.MongoClient(host='localhost', port=27017)
这样就可以创建MongoDB的连接对象了。
另外，MongoClient的第一个参数host还可以直接传入MongoDB的连接字符串，它以mongodb开头，例如：
client = MongoClient('mongodb://localhost:27017/')
MongoDB中可以建立多个数据库，接下来我们需要指定操作哪个数据库。这里我们以test数据库为例来说明，下一步需要在程序中指定要使用的数据库：
db = client.test
MongoDB的每个数据库又包含许多集合（collection），它们类似于关系型数据库中的表。
下一步需要指定要操作的集合，这里指定一个集合名称为students。与指定数据库类似，指定集合也有两种方式：
collection = db.students
collection = db['students']
对于students这个集合，新建一条学生数据，这条数据以字典形式表示：
student = { 'id': '20170101', 'name': 'Jordan', 'age': 20, 'gender': 'male' }
这里指定了学生的学号、姓名、年龄和性别。接下来，直接调用collection的insert()方法即可插入数据，代码如下：
result = collection.insert(student) print(result)
在MongoDB中，每条数据其实都有一个_id属性来唯一标识。如果没有显式指明该属性，MongoDB会自动产生一个ObjectId类型的_id属性。insert()方法会在执行后返回_id值。
也可以同时插入多条数据，只需要以列表形式传递即可，示例如下：
student1 = { 'id': '20170101', 'name': 'Jordan', 'age': 20, 'gender': 'male' } student2 = { 'id': '20170202', 'name': 'Mike', 'age': 21, 'gender': 'male' } result = collection.insert([student1, student2]) print(result)
返回结果是对应的_id的集合：
[ObjectId('5932a80115c2606a59e8a048'), ObjectId('5932a80115c2606a59e8a049')]
在PyMongo 3.x版本中，官方推荐使用insert_one()和insert_many()方法来分别插入单条记录和多条记录，示例如下：
student = { 'id': '20170101', 'name': 'Jordan', 'age': 20, 'gender': 'male' } result = collection.insert_one(student) print(result) print(result.inserted_id)
运行结果如下：
<pymongo.results.InsertOneResult object at 0x10d68b558>
5932ab0f15c2606f0c1cf6c5
与insert()方法不同，这次返回的是InsertOneResult对象，我们可以调用其inserted_id属性获取_id。
对于insert_many()方法，我们可以将数据以列表形式传递，示例如下：
student1 = { 'id': '20170101', 'name': 'Jordan', 'age': 20, 'gender': 'male' } student2 = { 'id': '20170202', 'name': 'Mike', 'age': 21, 'gender': 'male' } result = collection.insert_many([student1, student2]) print(result) print(result.inserted_ids)
运行结果如下：
<pymongo.results.InsertManyResult object at 0x101dea558> [ObjectId('5932abf415c2607083d3b2ac'), ObjectId('5932abf415c2607083d3b2ad')]
该方法返回的类型是InsertManyResult，调用inserted_ids属性可以获取插入数据的_id列表。
这里查询的条件键值已经不是单纯的数字了，而是一个字典，其键名为比较符号$gt，意思是大于，键值为20。
还可以进行正则匹配查询。例如，查询名字以M开头的学生数据，示例如下：results = collection.find({'name': {'$regex': '^M.*'}})
这里使用$regex来指定正则匹配，^M.*代表以M开头的正则表达式。
要统计查询结果有多少条数据，可以调用count()方法。比如，统计所有数据条数：
count = collection.find().count()
print(count)
或者统计符合某个条件的数据：
count = collection.find({'age': 20}).count()
print(count)
运行结果是一个数值，即符合条件的数据条数。
排序时，直接调用sort()方法，并在其中传入排序的字段及升降序标志即可。示例如下：
results = collection.find().sort('name', pymongo.ASCENDING)
print([result['name'] for result in results])
这里我们调用pymongo.ASCENDING指定升序。如果要降序排列，可以传入pymongo.DESCENDING。
在某些情况下，我们可能想只取某几个元素，这时可以利用skip()方法偏移几个位置，比如偏移2，就忽略前两个元素，得到第三个及以后的元素：
limit()方法指定要取的结果个数，示例如下：如果不使用limit()方法，原本会返回三个结果，加了限制后，会截取两个结果返回。
值得注意的是，在数据库数量非常庞大的时候，如千万、亿级别，最好不要使用大的偏移量来查询数据，因为这样很可能导致内存溢出。此时可以使用类似如下操作来查询：
from bson.objectid import ObjectId
collection.find({'_id': {'$gt': ObjectId('593278c815c2602678bb2b8d')}})
使用update()方法，指定更新的条件和更新后的数据即可
condition = {'name': 'Kevin'}
student = collection.find_one(condition)
student['age'] = 25
result = collection.update(condition, student)
print(result)
这里我们要更新name为Kevin的数据的年龄：首先指定查询条件，然后将数据查询出来，修改年龄后调用update()方法将原条件和修改后的数据传入。
也可以使用$set操作符对数据进行更新，代码如下：
result = collection.update(condition, {'$set': student})
update()方法其实也是官方不推荐使用的方法。这里也分为update_one()方法和update_many()方法，用法更加严格，它们的第二个参数需要使用$类型操作符作为字典的键名，示例如下：
condition = {'name': 'Kevin'}
student = collection.find_one(condition)
student['age'] = 26
result = collection.update_one(condition, {'$set': student})
print(result)
print(result.matched_count, result.modified_count)
这里调用了update_one()方法，第二个参数不能再直接传入修改后的字典，而是需要使用{'$set': student}这样的形式，其返回结果是UpdateResult类型。然后分别调用matched_count和modified_count属性，可以获得匹配的数据条数和影响的数据条数。
运行结果如下：
<pymongo.results.UpdateResult object at 0x10d17b678>
1 0
直接调用remove()方法指定删除的条件即可，此时符合条件的所有数据均会被删除。示例如下：
result = collection.remove({'name': 'Kevin'})
print(result)
这里依然存在两个新的推荐方法——delete_one()和delete_many()。示例如下：
result = collection.delete_one({'name': 'Kevin'})
print(result)
print(result.deleted_count)
result = collection.delete_many({'age': {'$lt': 25}})
print(result.deleted_count)