聊聊 Python 数据处理全家桶(MongoDB 篇)

运维 数据库运维 MongoDB
MongoDB 是基于分布式存储,由 C++ 编写的开源的 NoSql 数据库。

[[344490]]

本文转载自微信公众号「AirPython」,作者星安果。转载本文请联系AirPython公众号。   

1. 前言

MongoDB 是基于分布式存储,由 C++ 编写的开源的 NoSql 数据库

MongoDB 的内容存储类似 JSON 对象,数据结构包含 3 种

分别是:

数据库 - Databases

对应关系型数据库中的数据库(Database)

集合 - Collection

对应关系型数据库中的 Table 表(Table)

文档 - Document

对应数据库表中的一条数据(Row Data)

2. 准备

Python 操作 MongoDB,常见的两种方式是:Pymongo、Mongoengine

其中

  • Mongoengine:面相对象,针对文档型数据库的 ORM,直接继承于 Document 文档,对文档进行增删改查
  • Pymongo:通过 JSON 和 MongoDB 进行通信,将 MongoDB 的数据映射成 Python 内置的数据类型

首先,我们通过 pip3 命令安装依赖

  1. # 安装依赖 
  2. # pymongo 
  3. pip3 install pymongo 
  4.  
  5. # mongoengine 
  6. pip3 install mongoengine 

下面分别对 Pymongo 和 Mongoengine 进行说明

3. PyMongo

首先,创建一个数据库连接对象

创建数据库连接对象有二种方式,分别是:多参数、字符串拼接

  1. import pymongo 
  2.  
  3. # 创建数据库连接对象的两种方式 
  4. # 方式一:多参数 
  5. self.client = pymongo.MongoClient(host='ip地址', port=27017, username="root"password="123456"
  6.                                           authMechanism="SCRAM-SHA-1"
  7. # 方式二:拼接 
  8. # self.client = pymongo.MongoClient('mongodb://root:123456@ip地址:27017/'

接着,通过数据库连接对象指定要操作的数据库和操作集合

比如:要操作数据库 temp 中的 students 集合

  1. # 指定要操作的数据库:temp 
  2. self.db = self.client.temp 
  3.  
  4. # 指定要操作集合students 
  5. self.collection_students = self.db.students 

接着,我们来实现增删改查操作

1、新增

新增包含:新增单条数据和多条数据

单条数据插入对应的方法是:

  1. insert_one(dict) 

该方法的返回值类型为 InsertOneResult

通过 inserted_id 属性,可以获取插入数据的 _id 值

  1. temp_data = { 
  2.     "id""1"
  3.     "name""xag"
  4.     "age": 18 
  5.  
  6. # 1、直接调用集合的insert_one()方法插入数据(插入一条数据) 
  7. result = self.collection_students.insert_one(temp_data) 
  8.  
  9. # 返回值为InsertOneResult,通过inserted_id属性获取_id的值 
  10. print(result.inserted_id) 

多条数据插入对应的方法是:

  1. insert_many([dict1,dict2...]) 

该方法的返回值类型为 InsertManyResult

通过 inserted_ids 属性,可以获取插入数据的 _id 属性值列表

  1. # 2、插入多条数据-insert_many() 
  2. result = self.collection_students.insert_many([temp_data, temp_data2]) 
  3.  
  4. # 返回值为InsertManyResult,通过inserted_ids属性获取插入数据的_id列表值 
  5. print(result.inserted_ids) 

2、查询

使用 PyMongo 查询 MongoDB 数据库,常用方法如下:

  • 通过某一个属性键值对,去查询一条记录 - find_one()
  • 通过 ObjectId 值去查询某一条记录 - find_one()
  • 通过某一个属性键值对,去查询多条记录 - find()
  • 通过大于、小于、等于等条件去比较查询
  • 正则匹配查询

前面 3 种查询方式,由于比较简单,直接给出实例:

  1. def manage_query(self): 
  2.     """查询数据""" 
  3.     # 1、通过某个属性键值对,去查询一条记录 find_one() 
  4.     # 返回值为字典类型 
  5.     # {'_id': ObjectId('5f5c437cfe49fa9a16664179'), 'id''1''name''xag''age': 18} 
  6.     result = self.collection_students.find_one({"name""xag"}) 
  7.     print(result) 
  8.  
  9.     # 2、通过ObjectId值去查询某一条记录 
  10.     result = self.collection_students.find_one({"_id": ObjectId('5f5c437cfe49fa9a16664179')}) 
  11.     print(result) 
  12.  
  13.     # 3.1 查询多条记录 find() 
  14.     # 返回值为一个游标(生成器),pymongo.cursor.Cursor 
  15.     result_lists = self.collection_students.find({"name":"xag"}) 
  16.     print(result_lists) 
  17.     for item in result_lists: 
  18.         print(item) 

条件比较查询,包含:大于($gt)、大于等于($gte)、小于($lt)、小于等于($lte)、不等于($ne)、在范围内($in)、不在范围内($nin)

比如:查询年龄大于 18 岁的数据

  1. # 3.2 条件比较查询,包含大于($gt)、大于等于($gte)、小于($lt)、小于等于($lte)、不等于($ne)、在范围内($in)、不在范围内($nin) 
  2. # 查询年龄大于18岁的记录 
  3. result = self.collection_students.find({'age': {'$gt': 18}}) 
  4. for item in result: 
  5.     print(item) 

正则匹配查询,包含:

  • $regex:匹配正则表达式
  • $exists:属性是否存在
  • $type:数据类型判断
  • $mod:数据模操作
  • $text:文本包含查询
  • $where:高级条件查询

比如,查询 name 值以 "xag" 开头的数据

  1. # 正则匹配查询 
  2. results = self.collection_students.find({'name': {'$regex''^xag.*'}}) 
  3. for item in results: 
  4.     print(item) 

关于查询更加复杂的功能可以参考:

https://docs.mongodb.com/manual/reference/operator/query/

3、更新

更新操作包含:更新一条记录和更新多条记录

其中,更新一条记录对应的方法是:

  1. update_one(query,update_content) 

参数包含:查询的条件、要修改的内容

  1. # 1、修改一条记录 update_one(query,update_data) 
  2. # 方法中有两个参数,分别是:查询条件、要修改的内容 
  3. # 查询条件 
  4. query_condition = {"name""xag"
  5. # 要修改的内容 
  6. update_content = {"$set": {"name""星安果"}} 
  7. # 使用update_one() 方法进行更新一条记录 
  8. result = self.collection_students.update_one(query_condition, update_content) 

通过返回的结果可以获取查询匹配的记录个数及影响的记录个数

  1. # matched_count:匹配的记录个数 
  2. # modified_count:影响的记录个数 
  3. print(result.matched_count, result.modified_count) 

更新多条记录对应的方法是:

  1. update_many(query,update_content) 

方法中的参数、返回值与修改单条记录类似

  1. # 2、修改多条记录 update_many(query,update_data) 
  2. # 查询条件 
  3. query_condition = {"name": {"$regex""^星.*"}} 
  4. # 要修改的内容 
  5. update_content = {"$set": {"name""xag"}} 
  6. # 将文档中name以星开头的记录都设置为xag 
  7. result = self.collection_students.update_many(query_condition, update_content) 
  8. print(result) 
  9. print(result.matched_count, result.modified_count) 

4、删除

删除同样包含:删除查询到的第一条记录、删除查询到的所有记录

分别对应的方法是:delete_one(query)、delete_many(query)

另外,在返回结果中可以获取到真实被删除的数目

  1. def manage_remove(self): 
  2.     ""
  3.     删除操作 
  4.     :return
  5.     ""
  6.     # 1、删除查询到的第一条记录 delete_one() 
  7.     # result = self.collection_students.delete_one({'name'"xag2"}) 
  8.     # print(result) 
  9.     # 删除的数目 
  10.     # print(result.deleted_count) 
  11.  
  12.     # 2、删除多条记录 delete_many() 
  13.     result = self.collection_students.delete_many({'name'"xag"}) 
  14.     print(result) 
  15.     # 删除的数目 
  16.     print(result.deleted_count) 

5、计数和排名

常用的方法包含:

  • limit(num):限制返回的结果数量
  • skip(num):忽略 num 个元素,从 num + 1 个元素开始查看
  • count_documents():查看集合中所有的文档数量,也可以根据条件去查询满足的文档数量
  • sort():升序或者降序
  1. def manage_count_and_sort(self): 
  2.     ""
  3.     计数和排序 
  4.     :return
  5.     ""
  6.     # 1、限制返回的结果数量 - limit() 
  7.     # result = self.collection_students.find().limit(2) 
  8.     # for item in result: 
  9.     #     print(item) 
  10.  
  11.     # 2、偏移  skip() 
  12.     # 比如:忽略前面两个元素,从第3个元素开始查看 
  13.     # result = self.collection_students.find().skip(2) 
  14.     # print([result['name'for result in result]) 
  15.  
  16.     # 3.1 查询出集合中所有的文档数量 count_documents() 
  17.     # result = self.collection_students.count_documents({}) 
  18.     # print(result) 
  19.  
  20.     # 3.2 根据条件去查询,然后判断结果数目 
  21.     # query_regex = {'name': {'$regex''^xag.*'}} 
  22.     # result = self.collection_students.count_documents(query_regex) 
  23.     # print(result) 
  24.  
  25.     # 4、排序 sort() 
  26.     # pymongo.ASCENDING:升序,DESCENDING:降序 
  27.     result = self.collection_students.find().sort('name', pymongo.DESCENDING) 
  28.     print([result['name'for result in result]) 

4. Mongoengine

在使用 Mongoengine 操作 MongoDB 之前,需要先定义一个 Document 的子类

该子类对应 MongoDB 中的文档,内部加入的静态变量(包含:类型、长度等)对应数据库文档中的数据

  1. from mongoengine import * 
  2.  
  3. # Document的子类,对应文档对象 
  4. class Student(Document): 
  5.     name = StringField(required=True, max_length=500) 
  6.     age = IntField(required=Truedefault=18) 
  7.     create_time = DateTimeField(default=datetime.now) 
  8.  
  9.     # 配置元数据 
  10.     # 指定集合为student 
  11.     meta = {'collection''student''strict'False

利用 Mongoengine 内置的 connect() 方法,连接指定的数据库

  1. # 连接数据库temp 
  2. def __init__(self): 
  3.     # 连接数据库 
  4.     # 数据库名称:temp 
  5.     # auth方式:SCRAM-SHA-1 
  6.     result = connect('temp', host='ip地址', port=27017, 
  7.                      username='root'password='123456', authentication_source='admin'
  8.                      authentication_mechanism="SCRAM-SHA-1"
  9.     print(result) 

接着,我们来实现增删改查操作

1、新增

使用 Mongoengine 新增一条记录到数据库非常方便

只需要实例化一个文档对象,调用 save() 方法,即可以存储一条记录到数据库当中

  1. def insert(self): 
  2.     ""
  3.     插入数据 
  4.     :return
  5.     ""
  6.     person = Student(name='xag2', age=20) 
  7.     person.save() 

2、查询

常见的查询操作包含:

  • 查询集合中的所有记录
  • 查询第一条记录
  • 通过主键 _ID,来查询数据
  • 条件查询

对应的代码如下:

  1. def query(self): 
  2.     ""
  3.     普通查询 
  4.     :return
  5.     ""
  6.     # 1、查看集合中所有数据 
  7.     # students = Student.objects.all() 
  8.     # print([item['name'for item in students]) 
  9.  
  10.     # 2、查询第一条记录 
  11.     # student = Student.objects.first() 
  12.     # print(student.name, student.age, student.create_time) 
  13.  
  14.     # 3、通过主键_ID来查询数据 
  15.     result = Student.objects.filter(pk="5f5c5b34f5b0c049707a1710").first() 
  16.     print(result.name, result.age, result.create_time) 
  17.  
  18.     # 4、条件查询 
  19.     # 查询年龄在18-20岁的数据 
  20.     # __gte:大于等于;__lte:小于等于 
  21.     # 默认是升序,可以加一个:-,代表逆序 
  22.     # students = Student.objects(age__gte=18, age__lte=20).order_by('name'
  23.     students = Student.objects(age__gte=18, age__lte=20).order_by('-name'
  24.     # for item in students: 
  25.     #     print(item.name, item.age, item.create_time) 

值得一提的是,Mongoengine 提供了关键字 Q 来实现高级查询

比如:查询 name 字段值为 xag,年龄为 18 岁的数据

  1. def query_advance(self): 
  2.     ""
  3.     高级查询 
  4.     :return
  5.     ""
  6.     # 查看name为xag,age为18的记录的第一条 
  7.     student = Student.objects(Q(name="xag") & Q(age=18)).first() 
  8.     print(student.name, student.age, student.create_time) 

进阶操作可以参考:

https://docs.mongoengine.org/guide/querying.html

3、更新

Mongoengine 提供了 filter() 和 update() 两个方法,分别用于过滤待更新的数据,指定的更新内容

  1. def update(self): 
  2.     ""
  3.     更新记录 
  4.     :return
  5.     ""
  6.     # 1、修改所有记录 
  7.     # 修改name为xag的年龄都减少1岁 
  8.     # 增加一岁:inc__age=1 
  9.     # 减少一岁:dec__age=1 
  10.     # Student.objects.filter(name="xag").update(dec__age=1) 
  11.     # Student.objects.filter(name="xag").update(inc__age=1) 
  12.  
  13.     # name为xag,age小于18的的所有记录,更新为age=23 
  14.     # __lt:小于 
  15.     # __lte:小于等于 
  16.     # __gt:大于 
  17.     # __gte:大于等于 
  18.     # Student.objects.filter(name="xag", age__lt=18).update(age=23) 
  19.     # Student.objects.filter(age__lte=20).update(age=23) 

如果只需要更改查询到的第一条记录,可以使用 update_one() 方法

  1. # 2、修改一条记录 
  2. # 年龄减少5岁 
  3. Student.objects.filter(name='xag').update_one(dec__age=5) 

4、删除

删除操作对应 delete() 方法

同样,可以利用 filter() 和 first() 方法限制要删除的范围

  1. def delete(self): 
  2.     ""
  3.     删除数据 
  4.     :return
  5.     ""
  6.     # 1、删除查询到的第一条记录 
  7.     # Student.objects.filter(name="xag").first().delete() 
  8.  
  9.     # 2、删除多条记录 
  10.     # Student.objects.filter(name="xag").delete() 
  11.  
  12.     # 删除name值以xag开头的所有记录 
  13.     Student.objects.filter(name__startswith="xag").delete() 

 

5.最后

本篇文章讲解了 Python 操作 MongoDB,最常用的两种使用方式

 

责任编辑:武晓燕 来源: AirPython
相关推荐

2020-09-27 08:36:21

Python Memcached缓存

2021-08-11 12:07:12

PythonPgSQL数据

2020-09-24 06:49:34

PythonRedis

2023-07-31 08:21:22

语法校对器Pick

2013-08-26 09:36:27

大数据NoSQLMongoDB

2021-03-16 10:12:24

python内置函数

2024-01-31 23:22:35

vaexPython

2022-07-15 08:45:07

slotVue3

2023-09-25 13:19:41

pandasPython

2023-12-12 11:06:37

PythonPandas数据

2022-02-09 15:23:41

大数据流计算Spark

2018-12-07 14:50:35

大数据数据采集数据库

2020-11-02 15:56:04

大数据数据库技术

2023-12-18 11:21:40

MongoDB数据库

2023-09-25 10:16:44

Python编程

2017-09-13 15:05:10

React前端单元测试

2017-09-10 17:41:39

React全家桶单元测试前端测试

2017-07-21 14:22:17

大数据大数据平台数据处理

2015-12-10 21:31:19

七牛数据处理架构变迁

2013-12-16 17:17:01

OpenMp数据处理
点赞
收藏

51CTO技术栈公众号