相关文章推荐
严肃的乒乓球  ·  The Armenian ...·  3 月前    · 
不要命的日记本  ·  家庭影院装修设计效果图要有光系列- 阿强家庭影院网·  5 月前    · 
风流倜傥的消炎药  ·  Psychosocial effects ...·  1 年前    · 
重情义的炒粉  ·  参军入伍常见热点问题解答-松滋市人民政府网·  1 年前    · 
考研的葡萄  ·  马华小说的荒诞意识研究- UTAR ...·  1 年前    · 
小百科  ›  讨论一下Python 数据处理全家桶（MongoDB 两篇）-python 数据处理模块
LevelDB 数据处理 mongodb命令 大数据 mongodb
逃课的茶壶
1 年前

聊聊 Python 数据处理全家桶（MongoDB 篇）

星安果 2020-09-29 08:35:08
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. insert_one(dict) 

    该方法的返回值类型为 InsertOneResult

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

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

    使用 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/

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

    其中，更新一条记录对应的方法是： 

    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) 

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

    分别对应的方法是：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=True, default=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) 

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

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

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

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

    常见的查询操作包含：

  • 查询集合中的所有记录
  • 查询第一条记录
  • 通过主键 _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

    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) 

    删除操作对应 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() 

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

    MongoDB Python 数据
     
    推荐文章
    严肃的乒乓球  ·  The Armenian Allegation of Genocide: The issue and the facts ...
    3 月前
    不要命的日记本  ·  家庭影院装修设计效果图要有光系列- 阿强家庭影院网
    5 月前
    风流倜傥的消炎药  ·  Psychosocial effects of an Ebola outbreak at individual, community ...
    1 年前
    重情义的炒粉  ·  参军入伍常见热点问题解答-松滋市人民政府网
    1 年前
    考研的葡萄  ·  马华小说的荒诞意识研究- UTAR Institutional Repository
    1 年前
    Link管理   ·   51好读   ·   Sov5搜索   ·   小百科
    小百科 - 百科知识指南