这个篇目是“持久存储篇”，讲的就是Python操作数据库，这边介绍3种数据库，分别是MySQL、Redis、Mongodb

1. Python操作MySQL数据库

MySQL属于传统的关系型数据库产品，其开放式的架构使得用户的选择性很强，而且随着技术的逐渐成熟，MySQL支持的功能也越来越多，性能也在不断地提高，对平台的支持也在增多，此外，社区的开发与维护人数也很多。

当下，MySQL因为其功能稳定、性能卓越，且在遵守GPL协议的前提下，可以免费使用与修改，因此深受用户喜爱。

自甲骨文公司收购MySQL之后，MySQL在商业数据库与开源数据库领域的市场占有份额都跃居第一，这样的格局引起了部分业内人士的担忧，因为商业数据库的老大有可能将MySQL闭源，为了避免Oracle将MySQL闭源，而无开源的类MySQL数据库可用，MySQL社区采用了分支的方式，MariaDB数据库就这样诞生了。

MariaDB是一个向后兼容的数据库产品，可能会在以后替代MySQL，其官方地址为https://mariadb.org/。不过，这里还是建议大家选择更稳定且使用更广泛的MySQL数据库，可以先测试MariaDB数据库，等使用的人员多一些，社区更活跃后再正式考虑使用也不迟。

1.1 下载pymysql第三方库

python连接Mysql数据库，借助的第三方库是pymysql，进行下载pymysql：

pip install pymysql -i 镜像源地址

pip的仓库一般都是在国外的服务器上，加了镜像源可以提供下载的速度。

常见pip镜像源（国内源）

清华：https://pypi.tuna.tsinghua.edu.cn/simple

阿里云：http://mirrors.aliyun.com/pypi/simple/

中国科技大学： https://pypi.mirrors.ustc.edu.cn/simple/

华中理工大学：http://pypi.hustunique.com/

山东理工大学：http://pypi.sdutlinux.org/

豆瓣：http://pypi.douban.com/simple/

临时使用pip镜像源可以在使用pip的时候加参数：-i https://pypi.tuna.tsinghua.edu.cn/simple

Linux下，修改 ~/.pip/pip.conf (没有就创建一个文件夹及文件。文件夹要加“.”，表示是隐藏文件夹)

[global] 
index-url = https://pypi.tuna.tsinghua.edu.cn/simple
[install]
trusted-host=mirrors.aliyun.com

1.2 连接MySQL数据库

简单描述一下 Python 访问 MySQL 的步骤?

1、导入pymysql模块

2、用于模块的connect()方法创建数据库对象

3、利用数据库对象的cursor()方法创建Cursor对象

4、用Cursor对象的execute()方法执行数据库增删改查操作，查询时可用fetchone()和fetchall()查看数据

5、用数据库对象的commit()方法提交数据

6、关闭数据库对象和Cursor对象

在项目中，导入pymysql第三方库，配置连接mysql数据库：

import pymysql

conn = pymysql.connect(
    host='127.0.0.1',  # 连接名称，默认127.0.0.1
    user='root',  # 用户名
    passwd='root',  # 密码
    port=3306,  # 端口，默认为3306
    db='pythondb',  # 数据库名称
    charset='utf8',  # 字符编码
)

print(conn)

连接成功会打印连接对象：

<pymysql.connections.Connection object at 0x00000237F9CFFFD0>

pymysql.connect(···)返回就是Connection类的对象，接下来，看下Connection类的源码：

1.3 ini文件读取数据库配置项

配置参数，就是Connect类生成对象需要的参数，当然这些参数一般我们会建立配置文件来进行配置，配置文件可以是.conf，也可以是.ini，就是把配置项从程序代码中解耦出来：

这边举例，建立mysql_db.ini文件，作为连接MySQL的配置文件：

配置文件的配置项，读取的时候默认都是以字符串类型的，对应字符串，不需要加双引号""

[mysql]
host=127.0.0.1
;连接名称，默认127.0.0.1
user=root
;用户名
passwd=root
;密码
port=3306
;端口，默认为3306
db=pythondb
;数据库名称
charset=utf8
;字符编码

建立完配置文件mysql_db.ini，就需要在项目中导入配置文件中的配置项：那么对于.ini文件，在python中可以借助与configpaerser库进行读写。

configparser库相关的源码分析：

对于读取ini文件需要生成ConfigParser类的对象，ConfigParser类是继承RawConfigParser类。

ConfigParser类的对象有read_file()函数，参数需要传入File对象，file对象可以open()函数生成，当然f不仅可以传入File对象，但必须是可迭代的对象，The ‘f’ argument must be iterable.

get 函数就是获取.ini中的option配置项，section是部分，每个section部分都有若干的option配置项。

pymysql加载ini文件配置项，具体代码展示：

import pymysql
from pymysql import Connection
import configparser

db_config = configparser.ConfigParser()
db_config.read_file(open('mysql_db.ini', encoding='utf-8', mode='rt'))

conn: Connection = pymysql.connect(
    host=db_config.get('mysql', 'host'),  # 连接名称，默认127.0.0.1
    user=db_config.get('mysql', 'user'),  # 用户名
    passwd=db_config.get('mysql', 'passwd'),  # 密码
    port=int(db_config.get('mysql', 'port')),  # 端口，默认为3306
    db=db_config.get('mysql', 'db'),  # 数据库名称
    charset=db_config.get('mysql', 'charset'),  # 字符编码
)
print(conn)

解释下有同学之前目录读取的问题：

目录中的斜杠们

python读文件需要输入的目录参数，列出以下例子：

path = r"C:\User\temp\python.txt"

path1 = r"c:\User\temp\python.txt"

path2 = “c:\User\temp\python.txt”

path3 = “c:/User/temp/python.txt”

打开文件函数open()中的参数可以是path也可以是path1、path2、path3。

path：""为字符串中的特殊字符，加上r后变为原始字符串，则不会对字符串中的"\t"、"\r" 进行字符串转义

path1：大小写不影响windows定位到文件

path2：用一个"“取消第二个”“的特殊转义作用，即为"\"

path3：用正斜杠做目录分隔符也可以转到对应目录，并且在python中path3的方式也省去了反斜杠\转义的烦恼

1.4 操作cursor插入数据

conn.cursor() : 获取游标

要想操作数据库，光连接数据是不够的，必须拿到操作数据库的游标，才能进行后续的操作，比如读取数据、添加数据。通过获取到的数据库连接实例conn下的cursor()方法来创建游标。游标用来接收返回结果。

import pymysql
# 打开数据库连接
conn = pymysql.connect('localhost', user = "root", passwd = "123456", db = "testdb")
# 获取游标
cursor = conn.cursor()
print(cursor)

说明：cursor返回一个游标实例对象，其中包含了很多操作数据的方法，比如执行sql语句。源码展示如下：

执行sql语句execute和executemany

函数作用：执行单条的sql语句，执行成功后返回受影响的行数

execute 参数说明：

query：要执行的sql语句，字符串类型

args：可选的序列或映射，用于query的参数值。如果args为序列，query中必须使用%s做占位符；如果args为映射，query中必须使用%(key)s做占位符

函数作用：批量执行sql语句，比如批量插入数据，执行成功后返回受影响的行数

参数说明：

query：要执行的sql语句，字符串类型

args：嵌套的序列或映射，用于query的参数值

insert = cur.execute("insert into user values(1,'tom',18)")
sql = "insert into user values(%s,%s,%s)"
insert = cur.execute(sql,(4,'wen',20)) # 参数法，以元组的形式
print('添加语句受影响的行数：',insert)

execute和executemany 注意：

1. 数据库性能瓶颈很大一部份就在于网络IO和磁盘IO，将多个sql语句放在一起，只执行一次IO，可以有效的提升数据库性能。【推荐此方法】

2. 用executemany()方法一次性批量执行sql语句，固然很好，但是当数据一次传入过多到server端，可能造成server端的buffer溢出，也可能产生一些意想不到的麻烦。所以，合理、分批次使用executemany是个合理的办法

# 另一种插入数据的方式，通过字符串传入值
sql = "insert into user values(%s,%s,%s)"
insert = cur.executemany(sql,[(4,'wen',20),(5,'tom',10),(6,'test',30)])
print('批量插入返回受影响的行数：',insert)

excute执行SQL语句的时候，必须使用参数化的方式，否则必然产生SQL注入漏洞。

注意：批量插入多条sql语句采用的是executemany(sql, args)函数，返回受影响的行数。args参数是一个包含多个元组的列表，每个元组对应一条mysql中的一条数据。这里的%s不需要加引号，否则插入数据的数据会类型错误。

1.5 操作cursor查询数据

pymysql 查询数据

使用execute()函数得到的只是受影响的行数，并不能真正拿到查询的内容。cursor对象还提供了3种提取数据的方法：fetchone、fetchmany、fetchall.。每个方法都会导致游标动，所以必须注意游标的位置。

cursor.fetchone() : 获取游标所在处的一行数据，返回元组，没有返回None

cursor.fetchmany(size) : 接受size行返回结果行。如果size大于返回的结果行的数量，则会返回cursor.arraysize条数据。

cursor. fetchall() : 接收全部的返回结果行。

cur = conn.cursor()

cur.execute("select * from user;")
while True:
    res = cur.fetchone()
    if res is None:
        # 表示已经取完结果集
        break
    print(res)
cur.close()  # 关闭查询游标
conn.commit()  # 事务的提交
conn.close()  # 查询完毕，需要关闭连接，释放计算机资源
print('sql执行成功')

注意：从execute()函数的查询结果中取数据，以元组的形式返回游标所在处的一条数据，如果游标所在处没有数据，将返回空元组，该数据执行一次，游标向下移动一个位置。fetchone()函数必须跟exceute()函数结合使用，并且在exceute()函数之后使用

cursor.fetchmany(size):接受size行返回结果行。如果size大于返回的结果行的数量，则会返回cursor.arraysize条数据。

# 获取游标
cur = conn.cursor()

cur.execute("select * from user")
# 取3条数据
resTuple = cur.fetchmany(1)
print(type(resTuple))
for res in resTuple:
    print(res)

cur.close()  # 关闭查询游标
conn.commit()  # 事务的提交
conn.close()  # 查询完毕，需要关闭连接，释放计算机资源
print('sql执行成功')

注意：从exceute()函数结果中获取游标所在处的size条数据，并以元组的形式返回，元组的每一个元素都也是一个由一行数据组成的元组，如果size大于有效的结果行数，将会返回cursor.arraysize条数据，但如果游标所在处没有数据，将返回空元组。查询几条数据，游标将会向下移动几个位置。fetmany()函数必须跟exceute()函数结合使用，并且在exceute()函数之后使用

cursor. fetchall() : 接收全部的返回结果行

cur = conn.cursor()

cur.execute("select * from user")
# 取所有数据
resTuple = cur.fetchall()
print(type(resTuple))
print("共%d条数据" % len(resTuple))

cur.close()  # 关闭查询游标
conn.commit()  # 事务的提交
conn.close()  # 查询完毕，需要关闭连接，释放计算机资源

注意：获取游标所在处开始及以下所有的数据，并以元组的形式返回，元组的每一个元素都也是一个由一行数据组成的元组，如果游标所在处没有数据，将返回空元组。执行完这个方法后，游标将移动到数据库表的最后.

1.6 操作cursor修改数据

代码示例：操作cursor游标进行更新单条数据

cur = conn.cursor()

# 更新一条数据
update = cur.execute("update user set pwd='hello' where name='wrist'")
print('修改后受影响的行数为：', update)
# 查询一条数据
cur.execute('select * from user where name="wrist";')
print(cur.fetchone())
cur.close()
conn.commit()
conn.close()
print('sql执行成功')

代码示例：操作cursor游标更新多条数据

# 获取游标
cur = conn.cursor()
# 更新前查询所有数据
cur.execute("select * from user where name in ('唤醒手腕','蜡笔小新');")
print('更新前的数据为：')
for res in cur.fetchall():
    print(res)

# 更新2条数据
sql = "update user set age=%s where name=%s"
update = cur.executemany(sql, [(15, '唤醒手腕'), (18, '蜡笔小新')])

# 更新2条数据后查询所有数据
cur.execute("select * from user where name in ('唤醒手腕','蜡笔小新');")
print('更新后的数据为：')
for res in cur.fetchall():
    print(res)

cur.close()
conn.commit()
conn.close()
print('sql执行成功')

1.7 操作cursor删除数据

代码示例：删除单条数据

# 获取游标
cur = conn.cursor()

# 删除前查询所有数据
cur.execute("select * from user;")
print('删除前的数据为：')
for res in cur.fetchall():
    print(res)

print('*' * 40)
# 删除1条数据
cur.execute("delete from user where id=1")

# 删除后查询所有数据
cur.execute("select * from user;")
print('删除后的数据为：')
for res in cur.fetchall():
    print(res)
cur.close()
conn.commit()
conn.close()
print('sql执行成功')

代码示例：删除多条数据

cur = conn.cursor()
# 删除前查询所有数据
cur.execute("select * from user;")
print('删除前的数据为：')
for res in cur.fetchall():
    print(res)

print('*' * 40)
# 删除2条数据
sql = "delete from user where id = %s"
cur.executemany(sql, [(3), (4)])

# 删除后查询所有数据
cur.execute("select * from user;")
print('删除后的数据为：')
for res in cur.fetchall():
    print(res)
cur.close()
conn.commit()
conn.close()
print('sql执行成功')

1.8 pymysql常见事务操作

特别注意

记住在进行完增删改查之后，必须要提交事务的操作，否则操作将不生效，pymysql中提交事务的操作是：conn.commit()

事务操作的基本介绍

事务：一个最小的不可再分的工作单元；通常一个事务对应一个完整的业务 ( 例如银行账户转账业务，该业务就是一个最小的工作单元 )

事务四大特征(ACID)：

原子性(A)：事务是最小单位，不可再分

一致性(C)：事务要求所有的DML语句操作的时候，必须保证同时成功或者同时失败

隔离性(I)：事务A和事务B之间具有隔离性

持久性(D)：是事务的保证，事务终结的标志(内存的数据持久到硬盘文件中)

开启事务：Start Transaction 事务结束：End Transaction 提交事务：Commit Transaction
回滚事务：Rollback Transaction

回滚事务的案例操作：

import pymysql

# 打开数据库连接
conn = pymysql.connect('localhost', 'root', '123456')
conn.select_db('pythondb')
# 获取游标
cur = conn.cursor()

# 修改前查询所有数据
cur.execute("select * from user;")
print('修改前的数据为：')
for res in cur.fetchall():
    print(res)


# 更新表中第1条数据
cur.execute("update user set name='唤醒手腕' where id=5")

# 修改后查询所有数据
cur.execute("select * from user;")
print('修改后的数据为：')
for res in cur.fetchall():
    print(res)

# 回滚事务
conn.rollback()
cur.execute("select * from user;")
print('回滚事务后的数据为：')
for res in cur.fetchall():
    print(res)

cur.close()
conn.commit()
conn.close()
print('sql执行成功')

1.9 mysql进阶常见问题

视图的使用与作用？

视图又称为虚表，是一组数据的虚拟表示，本质就是一条select语句的结果集，视图本身没有数据，它只包含映射到基类表的查询语句，所以基类表数据发生变化，视图也随之变化。

视图语法示例：CREATE VIEW v as select * from my_table

视图作用：

1. 简化复杂查询，如果经常进行复杂的查询语句，可为该复杂查询语句建立视图，之后查询该视图即可
2. 限制数据访问，视图本质就是一条select语句，所以访问视图时，只能访问到对应的select语句查询的列，对基类其它列的数据起到安全和保密作用

存储过程的使用与作用？

存储过程（Stored Procedure）是在大型数据库系统中，一组为了完成特定功能的SQL 语句集，存储在数据库中，经过第一次编译后调用不需要再次编译，用户通过指定存储过程的名字并给出参数（如果该存储过程带有参数）来执行它。存储过程是数据库中的一个重要对象。

存储过程的特点

1、能完成较复杂的判断和运算
2、可编程行强，灵活
3、SQL编程的代码可重复使用
4、执行的速度相对快一些
5、减少网络之间的数据传输，节省开销 

创建一个简单的存储过程

create procedure test()
begin
    select * from users;
    select * from orders;
end;

调用存储过程：call testa()

MySQL 存储过程的变量 （declare）

create procedure test2()
begin
  -- 使用 declare语句声明一个变量
  declare username varchar(32) default '';
  -- 使用set语句给变量赋值
  set username = 'xiaoxiao';
  -- 将users表中id = 1的名称赋值给username
  select name into username from users where id=1;
  -- 返回变量
  select username;
end;

(1)、变量的声明使用declare,一句declare只声明一个变量，变量必须先声明后使用；

(2)、变量具有数据类型和长度，与mysql的SQL数据类型保持一致，因此甚至还能制定默认值、字符集和排序规则等；

(3)、变量可以通过set来赋值，也可以通过select into的方式赋值；

(4)、变量需要返回，可以使用select语句，如：select 变量名。

2. Python操作Redis数据库

redis是一个开源的、使用C语言编写的、支持网络交互的、可基于内存也可持久化的Key-Value数据库。

redis详细学习推荐：redis博客

2.1 python远程连接redis

下载第三方库：redis （py - redis的使用）

pip3 install --pre redis -i https://pypi.tuna.tsinghua.edu.cn/simple 

采用非连接池技术连接如下：

import redis
host = '服务器IP'
port = 6379
r = redis.Redis(host=host, port=port)

采用连接池技术连接如下：

# 连接池：为了节约资源，减少多次连接带来的消耗。
# 默认设置的值和取得的值都是bytes类型，如果想改为str类型，可以添加decode_responses=True

pool=redis.ConnectionPool(host='服务器IP', port=6379, decode_responses=True)

关系型数据库都有一个连接池的概念：对于大量redis连接来说，如果使用直接连接redis的方式的话，将会造成大量的TCP的重复连接，所以，就引入连接池来解决这个问题。在使用连接池连接上redis之后，可以从该连接池里面生成连接，调用完成之后，该链接将会返还给连接池，供其他连接请求调用，这样将减少大量redis连接的执行时间。

2.2 redis基本操作介绍

常规属性查看，redis库中的Redis类生成对应的对象都有如下同名的方法供调用者调用。

具体的操作请参考：py - redis 博客

3. Python操作Mongodb数据库

关于Mongodb的使用，在我的Python全栈学习笔记专栏网络爬虫篇已经介绍过了，这边的话继续完整的整合下，增加新的知识点内容。

MongoDB是基于分布式文件存储的数据库。由C++语言编写。旨在为WEB应用提供可扩展的高性能数据存储解决方案。

MongoDB是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。

MongoDB服务端可运行在Linux、Windows或mac os x平台，支持32位和64位应用，默认端口为27017。

推荐运行在64位平台，因为MongoDB在32位模式运行时支持的最大文件尺寸为2GB。

MongoDB 主要特点

• MongoDB中的记录是一个文档，它是由字段和值对组成的数据结构。
• 集合就是一组文档，类似于关系数据库中的表。

既然集合中可以存放任何类型的文档，那么为什么还需要使用多个集合？

这是因为所有文档都放在同一个集合中，无论对于开发者还是管理员，都很难对集合进行管理，而且这种情形下，对集合的查询等操作效率都不高。所以在实际使用中，往往将文档分类存放在不同的集合中。

MongoDB 实例可以承载多个数据库。它们之间可以看作相互独立，每个数据库都有独立的权限控制。在磁盘上，不同的数据库存放在不同的文件中。

MongoDB 中存在以下系统数据库：

• Admin 数据库：一个权限数据库，如果创建用户的时候将该用户添加到admin 数据库中，那么该用户就自动继承了所有数据库的权限。

• Local 数据库：这个数据库永远不会被复制，可以用来存储本地单台服务器的任意集合。

• Config 数据库：当MongoDB使用分片模式时，config 数据库在内部使用，用于保存分片的信息。

用户权限介绍

3.1 Mongodb远程连接

创建用户

cd /www/server/mongodb/bin 
# mongo安装目录下的bin目录

mongo
# 启动mongo服务，输入命令行mongo，进入mongodb环境

use admin
# 切换到admin数据库
# 正常情况就会报错 Error: not authorized on admin
# 先鉴权登录 db.auth('root', '此处是密码')

db.createUser({user: "root",pwd:"root",roles:[{ role: "readWriteAnyDatabase" , db: "DBNAME" }] })
# 创建用户
db.createUser({user:"root",pwd:"123456",roles:["root"] })  # 第二种方式

# 成功结果如下：
Successfully added user: {
        "user" : "root",
        "roles" : [
                {
                        "role" : "readWriteAnyDatabase",
                        "db" : "admin"
                }
        ]
}

show users
# 查看用户列表

远程联机宝塔centos系统的Mongodb数据库

进行权限的配置修改：

宝塔面板 和 服务器平台 都要开启27017的端口号

Mongodb结合Flask框架制作接口：

import pymongo
from flask import Flask, make_response
from bson import json_util

app = Flask(__name__)
app.MongoClient = pymongo.mongo_client.MongoClient("mongodb://root:root@服务器IP:27017")


@app.route("/login")
def index():
    db = app.MongoClient["campus"]
    # 选择数据库库
    collection = db.login
    # 选择集合
    data = collection.find()
    # 查询数据
    data_res = []
    for item in data:
        data_res.append(item)
    res = make_response(json_util.dumps(data_res))
    res.status = 200
    res.headers['Content-Type'] = "application/json"
    return res

if __name__ == '__main__':
    app.run(host="0.0.0.0", port=8080, debug=True)

Object of type ‘ObjectId’ is not JSON serializable 报错

从 mongo 中直接将查到的数据 dumps 导出，报错:

Object of type 'ObjectId' is not JSON serializable

解决方法:

from bson import json_util
 
json_util.dumps(data)

修改Mongodb用户的密码

db.changeUserPassword("root","mongodbadmin");

3.2 调用pymongo第三方库

PyMongo是驱动程序，使python程序能够使用Mongodb数据库，使用python编写而成。

先去官网下载软件包，地址点击打开链接，解压缩后进入，使用python setup.py install 进行安装或者用pip安装pip -m install pymongo

然后我们点击进入查看MongodbClient的源码：实例可以表示独立的MongoDB服务器、复制集或锐化集群。此类的实例负责维护集群的最新状态，并可能维护与此相关的缓存资源，包括用于监视的后台线程和连接池。（爱词霸翻译）

远程连接宝塔面板的Mongodb

import pymongo
from datetime import datetime

print(datetime.now())
# username="test"
# password="test"
# connection=pymongo.mongo_client.MongoClient(host="192.168.10.9:27017,connect=False,username=username,password=password)

# 链接服务器, 是本地服务器可不需要传入参数
MongoClient = pymongo.mongo_client.MongoClient("mongodb://root:root@远程服务器IP:27017")
# MongoClient = pymongo.MongoClient("mongodb://root:root@远程服务器IP:27017")


# 获取数据库, 中括号中填入数据库中的名字
db = MongoClient["wrist"]


collection = db.zhangyan

res = collection.find()

for item in res:
    print(item.get("name"))

3.3 pymongo插入数据

在Document中插入数据：

collection.insert_one({'name': '唤醒手腕', 'datetime': datetime.now()})

insert_many(list_of_dict) # 插入多个

3.4 pymongo查询数据（重要）

pymongo就不像pymysl讲的那么详细了，这边就简单介绍下。

pymongo是Python中用来操作MongoDB的一个库，MongoDB是一个基于分布式文件存储的数据库，旨在为WEB应用提供可扩展的高性能数据存储解决方案。其文件存储格式类似于JSON，叫BSON，通俗的理解，就是Python中的字典键值对格式。所以查询也需要根据键值对来。

比较运算符 查找数据

符号	说明
$eq	它将匹配等于指定值的值
$ne	它将匹配所有不等于指定值的值
$gt	它将匹配大于指定值的值
$gte	它将匹配所有大于或等于指定值的值
$lt	它将匹配所有小于指定值的值
$lte	它将匹配所有小于或等于指定值的值
$in	它将匹配数组中指定的任何值
$nin	它讲匹配不再数组中的值
比较运算符 查找数据，代码如下：

filterOption = {
    "age": {"$gte": 20}
}
# 查询年龄大于等于20岁的
data = collection.find_one(filterOption)
print(data)
# {'_id': ObjectId('61c7297dfff4db0a50af9f06'), 'name': '张燕', 'age': 20}

逻辑运算符查询

filterAnd = {
	'$and':[
		{'fid': {'$eq': 2048}}, # filter_01
		{'sid': {'$ne': 1024}}  # filter_02
		]
}

filterOr = {
	'$or':[
		{'fid': {'$eq': 2048}}, # filter_01
		{'sid': {'$ne': 1024}}  # filter_02
		]	
}

正则表达式查询

filterOption = {
	'name': {'$regex': r'Tom [a-zA-Z]+'}
}

遍历文档获取集合内所有文件：

# collection.find({})
# collection.find_one(filter) 只返回1个

for one in collection.find({}):
	print(one)

3.5 pymongo删除数据

删除的操作：

删除一个 collection.delete_one(filter)

删除多个 collection.delete_many(filter)

3.6 pymongo修改数据

修改的操作：

collection.update_many(filter, update)

新参量 update 说明：形式 {command: {key: value}}

• $set 修改或新增字段
• $unset 删除指定字段
• $rename 重命名字段

# 修改或新增字段
filter = {'name': '马大师'}
add_data = {'age': 60}

# key name 存在，改其值为 马大师？
update1 = {'$set': {'name': '马大师？'}}

# key age 不存在，插入字段
update2 = {'$set': add_data}

collection.update_one(filter, update1)
collection.update_one(filter, update2)

# 删除指定字段
filter = {'name': '马大师？'}
del_data = {'age': 60}

update = {'$unset': del_data}

collection.update_one(filter, update)

# 重命名字段
filter = {'name': '马大师？'}
update = {'$rename': {'name': '名字'}}
collection.update_one(filter, update)

断开连接：

client.close()

3.7 pymongo结合爬虫案例

import requests
import json
import pymongo

headers = {'User-Agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 13_2_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/13.0.3 Mobile/15E148 Safari/604.1'}
data = requests.get("http://localhost:8080/person/words/all", headers=headers)
words = json.loads(data.text)

MongoClient = pymongo.mongo_client.MongoClient("mongodb://root:root@远程服务器IP:27017")
db = MongoClient['wrist']
collection = db.word
collection.insert_many(words)

pymongo客户端展示如下：