Python MongoDB速成教程

ftpeak2025-03-09 15:44

一、基础

1. 安装pymongo库

pymongo 是 Python 操作 MongoDB 的官方驱动，你可以使用 pip 来安装它：

bash 复制代码 
pip install pymongo

2. 连接到 MongoDB

首先，你需要建立与 MongoDB 服务器的连接。以下是一个简单的示例：

python 复制代码 
from pymongo import MongoClient

# 连接到本地MongoDB服务器，默认端口是27017
client = MongoClient('mongodb://localhost:27017/')

# 选择一个数据库，如果该数据库不存在，MongoDB会在你第一次插入数据时创建它
db = client['test_database']

# 选择一个集合（类似于关系型数据库中的表），如果集合不存在也会在插入数据时创建
collection = db['test_collection']

3. 插入数据

（1）插入单条文档

python 复制代码 
# 定义一个文档（类似于关系型数据库中的一行记录）
document = {
    "name": "John Doe",
    "age": 30,
    "city": "New York"
}

# 插入单条文档
result = collection.insert_one(document)
print(f"插入的文档ID: {result.inserted_id}")

（2）插入多条文档

python 复制代码 
documents = [
    {
        "name": "Jane Smith",
        "age": 25,
        "city": "Los Angeles"
    },
    {
        "name": "Bob Johnson",
        "age": 35,
        "city": "Chicago"
    }
]

# 插入多条文档
result = collection.insert_many(documents)
print(f"插入的文档ID列表: {result.inserted_ids}")

4. 查询数据

（1）查询单条文档

python 复制代码 
# 查询集合中的第一条文档
first_document = collection.find_one()
print("查询到的第一条文档:")
print(first_document)

# 根据条件查询单条文档
query = {"name": "John Doe"}
found_document = collection.find_one(query)
print("根据条件查询到的文档:")
print(found_document)

（2）查询多条文档

python 复制代码 
# 查询集合中的所有文档
all_documents = collection.find()
print("集合中的所有文档:")
for document in all_documents:
    print(document)

# 根据条件查询多条文档
query = {"age": {"$gt": 30}}  # 查询年龄大于30的文档
matching_documents = collection.find(query)
print("年龄大于30的文档:")
for document in matching_documents:
    print(document)

5. 更新数据

（1）更新单条文档

python 复制代码 
# 定义更新条件
query = {"name": "John Doe"}
# 定义更新内容
new_values = {"$set": {"age": 31}}

# 更新单条文档
result = collection.update_one(query, new_values)
print(f"更新的文档数量: {result.modified_count}")

（2）更新多条文档

python 复制代码 
# 定义更新条件
query = {"city": "New York"}
# 定义更新内容
new_values = {"$set": {"city": "San Francisco"}}

# 更新多条文档
result = collection.update_many(query, new_values)
print(f"更新的文档数量: {result.modified_count}")

6. 删除数据

（1）删除单条文档

python 复制代码 
# 定义删除条件
query = {"name": "John Doe"}

# 删除单条文档
result = collection.delete_one(query)
print(f"删除的文档数量: {result.deleted_count}")

（2）删除多条文档

python 复制代码 
# 定义删除条件
query = {"age": {"$lt": 30}}  # 删除年龄小于30的文档

# 删除多条文档
result = collection.delete_many(query)
print(f"删除的文档数量: {result.deleted_count}")

7. 关闭连接

在完成所有操作后，记得关闭与 MongoDB 的连接：

python 复制代码 
client.close()

二、索引

建立和使用索引是MongoDB的必备操作技能。

1. 建立索引

索引在 MongoDB 中可以显著提高查询性能，特别是在处理大量数据时。pymongo 提供了方便的方法来创建不同类型的索引。

（1）单字段索引

单字段索引是基于文档中的一个字段创建的索引。以下是创建一个基于 name 字段的升序索引的示例：

python 复制代码 
from pymongo import MongoClient

# 连接到本地MongoDB服务器
client = MongoClient('mongodb://localhost:27017/')
db = client['test_database']
collection = db['test_collection']

# 创建单字段索引
index_name = collection.create_index("name")
print(f"创建的索引名称: {index_name}")

在上述代码中，create_index 方法接受一个字段名作为参数，默认创建升序索引。如果要创建降序索引，可以使用 [("field_name", -1)] 的形式：

python 复制代码 
index_name = collection.create_index([("name", -1)])
print(f"创建的降序索引名称: {index_name}")

（2）复合索引

复合索引是基于多个字段创建的索引。例如，我们可以创建一个基于 name 和 age 字段的复合索引：

python 复制代码 
# 创建复合索引
index_name = collection.create_index([("name", 1), ("age", -1)])
print(f"创建的复合索引名称: {index_name}")

2. 使用索引进行查询

创建索引后，MongoDB 会自动使用合适的索引来优化查询。以下是一些使用索引进行查询的示例：

（1）单字段索引查询

python 复制代码 
# 使用单字段索引进行查询
query = {"name": "Jane Smith"}
result = collection.find(query)
for doc in result:
    print(doc)

（2）复合索引查询

python 复制代码 
# 使用复合索引进行查询
query = {"name": "Bob Johnson", "age": {"$gt": 30}}
result = collection.find(query)
for doc in result:
    print(doc)

3. 查看索引信息

可以使用 list_indexes 方法查看集合中所有的索引信息：

python 复制代码 
# 查看集合中的所有索引
indexes = collection.list_indexes()
for index in indexes:
    print(index)

4. 删除索引

如果某个索引不再需要，可以使用 drop_index 方法删除它。以下是删除之前创建的 name 字段索引的示例：

python 复制代码 
# 删除单字段索引
collection.drop_index("name_1")  # "name_1" 是默认的索引名称
print("索引已删除")

如果要删除所有索引，可以使用 drop_indexes 方法：

python 复制代码 
# 删除集合中的所有索引
collection.drop_indexes()
print("所有索引已删除")

5.完整示例代码

python 复制代码 
from pymongo import MongoClient

# 连接到本地MongoDB服务器
client = MongoClient('mongodb://localhost:27017/')
db = client['test_database']
collection = db['test_collection']

# 创建单字段索引
index_name = collection.create_index("name")
print(f"创建的索引名称: {index_name}")

# 创建复合索引
compound_index_name = collection.create_index([("name", 1), ("age", -1)])
print(f"创建的复合索引名称: {compound_index_name}")

# 使用单字段索引进行查询
query = {"name": "Jane Smith"}
result = collection.find(query)
print("使用单字段索引查询结果:")
for doc in result:
    print(doc)

# 使用复合索引进行查询
query = {"name": "Bob Johnson", "age": {"$gt": 30}}
result = collection.find(query)
print("使用复合索引查询结果:")
for doc in result:
    print(doc)

# 查看集合中的所有索引
indexes = collection.list_indexes()
print("集合中的所有索引:")
for index in indexes:
    print(index)

# 删除单字段索引
collection.drop_index("name_1")
print("单字段索引已删除")

# 删除集合中的所有索引
collection.drop_indexes()
print("所有索引已删除")

# 关闭连接
client.close()

通过以上步骤，可以在 Python 中使用 pymongo 轻松地建立、使用和管理 MongoDB 的索引，从而提高查询性能。

三、汉字全文检索

MongoDB 从 2.6 版本开始支持全文检索，它使用文本索引（Text Index）来实现该功能，不过需要注意的是，文本索引默认不支持中文分词，因此需要额外的处理或者借助第三方分词工具。以下是详细步骤和示例代码。

1. 创建支持中文的文本索引

在 MongoDB 中创建支持中文的文本索引，这里以借助 jieba 分词库手动处理中文分词为例。首先需要安装 jieba 库：

python 复制代码 
pip install jieba

然后创建索引：

python 复制代码 
from pymongo import MongoClient
import jieba

# 连接到本地MongoDB服务器
client = MongoClient('mongodb://localhost:27017/')
db = client['test_database']
collection = db['test_collection']

# 定义一个函数，用于对中文文本进行分词处理
def tokenize_chinese(text):
    return ' '.join(jieba.lcut(text))

# 插入一些包含中文的文档
documents = [
    {
        "title": "Python与MongoDB开发教程",
        "content": "这是一篇关于Python使用MongoDB进行开发的详细教程，涵盖了各种操作。"
    },
    {
        "title": "中文全文检索功能介绍",
        "content": "本文章介绍了在MongoDB中实现中文全文检索的方法和技巧。"
    }
]

# 对文档中的中文文本进行分词处理并插入
for doc in documents:
    doc["title"] = tokenize_chinese(doc["title"])
    doc["content"] = tokenize_chinese(doc["content"])
collection.insert_many(documents)

# 创建文本索引
index_name = collection.create_index([("title", "text"), ("content", "text")])
print(f"创建的文本索引名称: {index_name}")

2. 执行全文检索

创建好文本索引后，就可以使用 $text 操作符进行全文检索了：

python 复制代码 
# 定义要搜索的关键词
search_keyword = tokenize_chinese("Python开发")

# 执行全文检索
query = {"$text": {"$search": search_keyword}}
results = collection.find(query)

print("全文检索结果:")
for result in results:
    print(result)

3. 检索结果排序

可以根据文本匹配的相关性对检索结果进行排序，使用 $meta 操作符来获取文本匹配的得分：

python 复制代码 
# 执行全文检索并按相关性排序
query = {"$text": {"$search": search_keyword}}
sort = [("score", {"$meta": "textScore"})]
results = collection.find(query).sort(sort)

print("按相关性排序的全文检索结果:")
for result in results:
    print(result)

4. 完整示例代码

python 复制代码 
from pymongo import MongoClient
import jieba

# 连接到本地MongoDB服务器
client = MongoClient('mongodb://localhost:27017/')
db = client['test_database']
collection = db['test_collection']

# 定义一个函数，用于对中文文本进行分词处理
def tokenize_chinese(text):
    return ' '.join(jieba.lcut(text))

# 插入一些包含中文的文档
documents = [
    {
        "title": "Python与MongoDB开发教程",
        "content": "这是一篇关于Python使用MongoDB进行开发的详细教程，涵盖了各种操作。"
    },
    {
        "title": "中文全文检索功能介绍",
        "content": "本文章介绍了在MongoDB中实现中文全文检索的方法和技巧。"
    }
]

# 对文档中的中文文本进行分词处理并插入
for doc in documents:
    doc["title"] = tokenize_chinese(doc["title"])
    doc["content"] = tokenize_chinese(doc["content"])
collection.insert_many(documents)

# 创建文本索引
index_name = collection.create_index([("title", "text"), ("content", "text")])
print(f"创建的文本索引名称: {index_name}")

# 定义要搜索的关键词
search_keyword = tokenize_chinese("Python开发")

# 执行全文检索
query = {"$text": {"$search": search_keyword}}
results = collection.find(query)

print("全文检索结果:")
for result in results:
    print(result)

# 执行全文检索并按相关性排序
query = {"$text": {"$search": search_keyword}}
sort = [("score", {"$meta": "textScore"})]
results = collection.find(query).sort(sort)

print("按相关性排序的全文检索结果:")
for result in results:
    print(result)

# 关闭连接
client.close()
注意事项
  • 分词准确性 ：jieba 分词库虽然能满足大部分中文分词需求，但对于一些特定领域的词汇可能分词不准确，可以根据实际情况自定义词典。
  • 性能考虑：全文检索会增加系统的开销，尤其是在处理大量数据时，因此需要合理设计索引和查询语句。

通过以上步骤，可以在 Python 中使用 pymongo 结合 jieba 实现 MongoDB 的中文全文检索功能。

四、聚合

MongoDB 的聚合操作允许你对数据进行复杂的处理和分析，类似于关系型数据库中的分组、排序、统计等操作。pymongo 提供了相应的方法来执行聚合管道。

示例数据准备

首先，我们插入一些示例数据用于后续的聚合操作：

python 复制代码 
from pymongo import MongoClient

# 连接到本地MongoDB服务器
client = MongoClient('mongodb://localhost:27017/')
db = client['test_database']
collection = db['test_collection']

# 插入示例数据
products = [
    {"name": "Apple", "category": "Fruit", "price": 2.5, "quantity": 100},
    {"name": "Banana", "category": "Fruit", "price": 1.5, "quantity": 200},
    {"name": "Carrot", "category": "Vegetable", "price": 1.0, "quantity": 150},
    {"name": "Tomato", "category": "Vegetable", "price": 1.2, "quantity": 120}
]

collection.insert_many(products)

1. 分组聚合

分组聚合可以根据指定的字段对文档进行分组，并对每个组进行统计操作。以下是一个按 category 字段分组，统计每个分组的产品数量和总价格的示例：

python 复制代码 
# 定义聚合管道
pipeline = [
    {
        "$group": {
            "_id": "$category",
            "total_quantity": {"$sum": "$quantity"},
            "total_price": {"$sum": {"$multiply": ["$price", "$quantity"]}}
        }
    }
]

# 执行聚合操作
results = collection.aggregate(pipeline)

print("按类别分组的统计结果：")
for result in results:
    print(result)

在上述代码中，$group 阶段将文档按 category 字段分组，_id 指定分组的依据，$sum 用于计算数量总和，$multiply 用于计算每个产品的总价，然后再求和。

2. 过滤聚合

可以在聚合管道中使用 $match 阶段来过滤文档，只处理符合条件的文档。以下是一个只处理价格大于 1.2 的产品的聚合示例：

python 复制代码 
# 定义聚合管道，包含过滤和分组操作
pipeline = [
    {
        "$match": {
            "price": {"$gt": 1.2}
        }
    },
    {
        "$group": {
            "_id": "$category",
            "total_quantity": {"$sum": "$quantity"},
            "total_price": {"$sum": {"$multiply": ["$price", "$quantity"]}}
        }
    }
]

# 执行聚合操作
results = collection.aggregate(pipeline)

print("价格大于 1.2 的产品按类别分组的统计结果：")
for result in results:
    print(result)

这里的 $match 阶段过滤出价格大于 1.2 的产品，然后再进行分组统计。

3. 排序聚合

使用 $sort 阶段可以对聚合结果进行排序。以下是一个按总价格降序排序的聚合示例：

python 复制代码 
# 定义聚合管道，包含分组和排序操作
pipeline = [
    {
        "$group": {
            "_id": "$category",
            "total_quantity": {"$sum": "$quantity"},
            "total_price": {"$sum": {"$multiply": ["$price", "$quantity"]}}
        }
    },
    {
        "$sort": {
            "total_price": -1
        }
    }
]

# 执行聚合操作
results = collection.aggregate(pipeline)

print("按总价格降序排序的分组统计结果：")
for result in results:
    print(result)

$sort 阶段根据 total_price 字段进行降序排序，-1 表示降序，1 表示升序。

4. 投影聚合

$project 阶段用于控制输出文档的字段，你可以选择包含或排除某些字段，也可以对字段进行重命名和计算。以下是一个投影聚合的示例：

python 复制代码 
# 定义聚合管道，包含分组、投影和排序操作
pipeline = [
    {
        "$group": {
            "_id": "$category",
            "total_quantity": {"$sum": "$quantity"},
            "total_price": {"$sum": {"$multiply": ["$price", "$quantity"]}}
        }
    },
    {
        "$project": {
            "category": "$_id",
            "total_quantity": 1,
            "total_price": 1,
            "_id": 0
        }
    },
    {
        "$sort": {
            "total_price": -1
        }
    }
]

# 执行聚合操作
results = collection.aggregate(pipeline)

print("投影聚合后的按总价格降序排序的分组统计结果：")
for result in results:
    print(result)

在 $project 阶段，我们将 _id 重命名为 category，并排除了原始的 _id 字段。

完整示例代码

python 复制代码 
from pymongo import MongoClient

# 连接到本地MongoDB服务器
client = MongoClient('mongodb://localhost:27017/')
db = client['test_database']
collection = db['test_collection']

# 插入示例数据
products = [
    {"name": "Apple", "category": "Fruit", "price": 2.5, "quantity": 100},
    {"name": "Banana", "category": "Fruit", "price": 1.5, "quantity": 200},
    {"name": "Carrot", "category": "Vegetable", "price": 1.0, "quantity": 150},
    {"name": "Tomato", "category": "Vegetable", "price": 1.2, "quantity": 120}
]

collection.insert_many(products)

# 分组聚合
pipeline = [
    {
        "$group": {
            "_id": "$category",
            "total_quantity": {"$sum": "$quantity"},
            "total_price": {"$sum": {"$multiply": ["$price", "$quantity"]}}
        }
    }
]

results = collection.aggregate(pipeline)
print("按类别分组的统计结果：")
for result in results:
    print(result)

# 过滤聚合
pipeline = [
    {
        "$match": {
            "price": {"$gt": 1.2}
        }
    },
    {
        "$group": {
            "_id": "$category",
            "total_quantity": {"$sum": "$quantity"},
            "total_price": {"$sum": {"$multiply": ["$price", "$quantity"]}}
        }
    }
]

results = collection.aggregate(pipeline)
print("价格大于 1.2 的产品按类别分组的统计结果：")
for result in results:
    print(result)

# 排序聚合
pipeline = [
    {
        "$group": {
            "_id": "$category",
            "total_quantity": {"$sum": "$quantity"},
            "total_price": {"$sum": {"$multiply": ["$price", "$quantity"]}}
        }
    },
    {
        "$sort": {
            "total_price": -1
        }
    }
]

results = collection.aggregate(pipeline)
print("按总价格降序排序的分组统计结果：")
for result in results:
    print(result)

# 投影聚合
pipeline = [
    {
        "$group": {
            "_id": "$category",
            "total_quantity": {"$sum": "$quantity"},
            "total_price": {"$sum": {"$multiply": ["$price", "$quantity"]}}
        }
    },
    {
        "$project": {
            "category": "$_id",
            "total_quantity": 1,
            "total_price": 1,
            "_id": 0
        }
    },
    {
        "$sort": {
            "total_price": -1
        }
    }
]

results = collection.aggregate(pipeline)
print("投影聚合后的按总价格降序排序的分组统计结果：")
for result in results:
    print(result)

# 关闭连接
client.close()

通过以上示例，可以了解到如何在 Python 中使用 pymongo 执行 MongoDB 的聚合操作，包括分组、过滤、排序和投影等常见操作。聚合操作可以帮助你从大量数据中提取有价值的信息。

5.关联

（1）创建示例集合和数据

为了演示集合关联操作，我们创建两个示例集合：students和courses，并插入一些示例数据。

python 复制代码 
# 创建 students 集合并插入数据
students = db['students']
students_data = [
    {"_id": 1, "name": "Alice", "age": 20},
    {"_id": 2, "name": "Bob", "age": 22}
]
students.insert_many(students_data)

# 创建 courses 集合并插入数据
courses = db['courses']
courses_data = [
    {"student_id": 1, "course_name": "Math"},
    {"student_id": 1, "course_name": "Physics"},
    {"student_id": 2, "course_name": "Chemistry"}
]
courses.insert_many(courses_data)

（2） 使用 Python 代码进行关联查询

可以通过查询一个集合，然后根据查询结果再查询另一个集合来实现关联。

python 复制代码 
# 查询所有学生
all_students = students.find()

for student in all_students:
    student_id = student["_id"]
    # 根据学生 ID 查询该学生的所有课程
    student_courses = courses.find({"student_id": student_id})
    print(f"Student: {student['name']}")
    for course in student_courses:
        print(f"  Course: {course['course_name']}")

（3）使用 MongoDB 的聚合管道进行关联查询

MongoDB 的聚合管道提供了$lookup操作符，可以用于在一个集合中查找另一个集合的匹配文档，类似于关系型数据库的JOIN操作。

python 复制代码 
# 使用聚合管道进行关联查询
pipeline = [
    {
        "$lookup": {
            "from": "courses",
            "localField": "_id",
            "foreignField": "student_id",
            "as": "student_courses"
        }
    },
    {
        "$project": {
            "name": 1,
            "age": 1,
            "student_courses.course_name": 1
        }
    }
]

result = students.aggregate(pipeline)

for doc in result:
    print(f"Student: {doc['name']}, Age: {doc['age']}")
    for course in doc['student_courses']:
        print(f"  Course: {course['course_name']}")

五、其它操作

MongoDB还提供了地理空间索引与查询、事务处理、批量操作等。

1. 地理空间索引与查询

MongoDB 支持地理空间索引，可用于处理地理空间数据，如经纬度坐标。这里以查找附近地点为例。

（1）插入地理空间数据

python 复制代码 
from pymongo import MongoClient

client = MongoClient('mongodb://localhost:27017/')
db = client['test_database']
collection = db['geospatial_collection']

# 插入包含地理位置的文档
places = [
    {"name": "Place A", "location": [116.4074, 39.9042]},
    {"name": "Place B", "location": [116.4174, 39.9142]},
    {"name": "Place C", "location": [116.4274, 39.9242]}
]
collection.insert_many(places)

（2）创建地理空间索引

python 复制代码 
# 创建 2dsphere 索引用于地理空间查询
collection.create_index([("location", "2dsphere")])

（3）进行地理空间查询

python 复制代码 
# 查询距离指定点（116.4074, 39.9042）一定距离内的地点
query_point = [116.4074, 39.9042]
distance = 1000  # 单位：米
query = {
    "location": {
        "$near": {
            "$geometry": {
                "type": "Point",
                "coordinates": query_point
            },
            "$maxDistance": distance
        }
    }
}
results = collection.find(query)
print("附近的地点：")
for result in results:
    print(result)

2. 事务处理

MongoDB 支持多文档事务，可确保在多个操作之间的数据一致性。以下是一个简单的事务处理示例，模拟账户之间的资金转移。

python 复制代码 
# 插入账户数据
accounts = [
    {"_id": "account1", "balance": 1000},
    {"_id": "account2", "balance": 500}
]
collection = db['accounts_collection']
collection.insert_many(accounts)

# 开始事务
session = client.start_session()
try:
    with session.start_transaction():
        # 从 account1 转出 200 到 account2
        source_account = collection.find_one({"_id": "account1"}, session=session)
        if source_account["balance"] >= 200:
            collection.update_one(
                {"_id": "account1"},
                {"$inc": {"balance": -200}},
                session=session
            )
            collection.update_one(
                {"_id": "account2"},
                {"$inc": {"balance": 200}},
                session=session
            )
            print("资金转移成功")
        else:
            raise ValueError("余额不足")
except Exception as e:
    session.abort_transaction()
    print(f"事务失败：{e}")
finally:
    session.end_session()

3. 批量操作

批量操作允许你一次性执行多个插入、更新或删除操作，可提高性能。

（1）批量插入

python 复制代码 
new_documents = [
    {"name": "Document 1", "value": 1},
    {"name": "Document 2", "value": 2},
    {"name": "Document 3", "value": 3}
]
collection = db['batch_collection']
result = collection.insert_many(new_documents)
print(f"批量插入的文档 ID：{result.inserted_ids}")

（2）批量更新

python 复制代码 
from pymongo import UpdateOne

# 定义批量更新操作
requests = [
    UpdateOne({"name": "Document 1"}, {"$set": {"value": 10}}),
    UpdateOne({"name": "Document 2"}, {"$set": {"value": 20}}),
    UpdateOne({"name": "Document 3"}, {"$set": {"value": 30}})
]
result = collection.bulk_write(requests)
print(f"批量更新的文档数量：{result.modified_count}")

（3）批量删除

python 复制代码 
from pymongo import DeleteOne

# 定义批量删除操作
requests = [
    DeleteOne({"name": "Document 1"}),
    DeleteOne({"name": "Document 2"}),
    DeleteOne({"name": "Document 3"})
]
result = collection.bulk_write(requests)
print(f"批量删除的文档数量：{result.deleted_count}")

4. 索引管理更多操作

（1）查看索引使用情况

python 复制代码 
collection = db['test_collection']
explain_result = collection.find({"name": "Apple"}).explain()
index_used = explain_result.get('queryPlanner', {}).get('winningPlan', {}).get('inputStage', {}).get('indexName')
print(f"查询使用的索引：{index_used}")

（2）重建索引

python 复制代码 
collection.reindex()
print("索引已重建")

完整示例代码

python 复制代码 
from pymongo import MongoClient, UpdateOne, DeleteOne

# 连接到本地MongoDB服务器
client = MongoClient('mongodb://localhost:27017/')
db = client['test_database']

# 地理空间索引与查询
collection = db['geospatial_collection']
places = [
    {"name": "Place A", "location": [116.4074, 39.9042]},
    {"name": "Place B", "location": [116.4174, 39.9142]},
    {"name": "Place C", "location": [116.4274, 39.9242]}
]
collection.insert_many(places)
collection.create_index([("location", "2dsphere")])
query_point = [116.4074, 39.9042]
distance = 1000
query = {
    "location": {
        "$near": {
            "$geometry": {
                "type": "Point",
                "coordinates": query_point
            },
            "$maxDistance": distance
        }
    }
}
results = collection.find(query)
print("附近的地点：")
for result in results:
    print(result)

# 事务处理
collection = db['accounts_collection']
accounts = [
    {"_id": "account1", "balance": 1000},
    {"_id": "account2", "balance": 500}
]
collection.insert_many(accounts)
session = client.start_session()
try:
    with session.start_transaction():
        source_account = collection.find_one({"_id": "account1"}, session=session)
        if source_account["balance"] >= 200:
            collection.update_one(
                {"_id": "account1"},
                {"$inc": {"balance": -200}},
                session=session
            )
            collection.update_one(
                {"_id": "account2"},
                {"$inc": {"balance": 200}},
                session=session
            )
            print("资金转移成功")
        else:
            raise ValueError("余额不足")
except Exception as e:
    session.abort_transaction()
    print(f"事务失败：{e}")
finally:
    session.end_session()

# 批量操作
collection = db['batch_collection']
new_documents = [
    {"name": "Document 1", "value": 1},
    {"name": "Document 2", "value": 2},
    {"name": "Document 3", "value": 3}
]
result = collection.insert_many(new_documents)
print(f"批量插入的文档 ID：{result.inserted_ids}")
requests = [
    UpdateOne({"name": "Document 1"}, {"$set": {"value": 10}}),
    UpdateOne({"name": "Document 2"}, {"$set": {"value": 20}}),
    UpdateOne({"name": "Document 3"}, {"$set": {"value": 30}})
]
result = collection.bulk_write(requests)
print(f"批量更新的文档数量：{result.modified_count}")
requests = [
    DeleteOne({"name": "Document 1"}),
    DeleteOne({"name": "Document 2"}),
    DeleteOne({"name": "Document 3"})
]
result = collection.bulk_write(requests)
print(f"批量删除的文档数量：{result.deleted_count}")

# 索引管理更多操作
collection = db['test_collection']
explain_result = collection.find({"name": "Apple"}).explain()
index_used = explain_result.get('queryPlanner', {}).get('winningPlan', {}).get('inputStage', {}).get('indexName')
print(f"查询使用的索引：{index_used}")
collection.reindex()
print("索引已重建")

# 关闭连接
client.close()

六、备份与恢复

在 MongoDB 中，备份和恢复数据是非常重要的操作，能够确保数据的安全性和可恢复性。使用 pymongo 结合系统命令来实现 MongoDB 的备份与恢复，同时也要会使用 mongodump 和 mongorestore 工具的基本方法。

1.使用 mongodump和mongorestore工具

（1）安装工具

mongodump 和 mongorestore 是 MongoDB 自带的工具，在安装 MongoDB 时通常会一并安装。如果你的系统中没有这两个工具，可以重新安装 MongoDB 或者从 MongoDB 官方网站下载对应的工具包。

（2）备份数据库

使用 mongodump 工具可以将整个数据库或指定集合的数据备份到指定目录。以下是使用 Python 调用系统命令进行备份的示例：

python 复制代码 
import subprocess

# 定义备份目录
backup_dir = 'backup_data'

# 执行 mongodump 命令
try:
    subprocess.run(['mongodump', '--db', 'test_database', '--out', backup_dir], check=True)
    print(f"数据库备份成功，备份文件存储在 {backup_dir} 目录下。")
except subprocess.CalledProcessError as e:
    print(f"数据库备份失败：{e}")

在上述代码中，--db 参数指定要备份的数据库名称，--out 参数指定备份文件的存储目录。

（3）恢复数据库

使用 mongorestore 工具可以将备份的数据恢复到指定的数据库中。以下是使用 Python 调用系统命令进行恢复的示例：

python 复制代码 
import subprocess

# 定义备份目录
backup_dir = 'backup_data'

# 执行 mongorestore 命令
try:
    subprocess.run(['mongorestore', '--db', 'test_database', backup_dir], check=True)
    print(f"数据库恢复成功，数据从 {backup_dir} 目录下恢复到 test_database 数据库。")
except subprocess.CalledProcessError as e:
    print(f"数据库恢复失败：{e}")

在上述代码中，--db 参数指定要恢复到的数据库名称，后面跟上备份文件的存储目录。

2. 备份与恢复指定集合

（1）备份指定集合

如果你只需要备份某个集合的数据，可以在 mongodump 命令中指定集合名称。以下是示例代码：

python 复制代码 
import subprocess

# 定义备份目录
backup_dir = 'backup_collection_data'

# 执行 mongodump 命令备份指定集合
try:
    subprocess.run(['mongodump', '--db', 'test_database', '--collection', 'test_collection', '--out', backup_dir], check=True)
    print(f"集合备份成功，备份文件存储在 {backup_dir} 目录下。")
except subprocess.CalledProcessError as e:
    print(f"集合备份失败：{e}")

在上述代码中，--collection 参数指定要备份的集合名称。

（2）恢复指定集合

同样，如果你只需要恢复某个集合的数据，可以在 mongorestore 命令中指定集合名称。以下是示例代码：

python 复制代码 
import subprocess

# 定义备份目录
backup_dir = 'backup_collection_data'

# 执行 mongorestore 命令恢复指定集合
try:
    subprocess.run(['mongorestore', '--db', 'test_database', '--collection', 'test_collection', backup_dir], check=True)
    print(f"集合恢复成功，数据从 {backup_dir} 目录下恢复到 test_database 数据库的 test_collection 集合。")
except subprocess.CalledProcessError as e:
    print(f"集合恢复失败：{e}")

完整示例代码

python 复制代码 
import subprocess

# 备份整个数据库
backup_dir = 'backup_data'
try:
    subprocess.run(['mongodump', '--db', 'test_database', '--out', backup_dir], check=True)
    print(f"数据库备份成功，备份文件存储在 {backup_dir} 目录下。")
except subprocess.CalledProcessError as e:
    print(f"数据库备份失败：{e}")

# 恢复整个数据库
try:
    subprocess.run(['mongorestore', '--db', 'test_database', backup_dir], check=True)
    print(f"数据库恢复成功，数据从 {backup_dir} 目录下恢复到 test_database 数据库。")
except subprocess.CalledProcessError as e:
    print(f"数据库恢复失败：{e}")

# 备份指定集合
backup_collection_dir = 'backup_collection_data'
try:
    subprocess.run(['mongodump', '--db', 'test_database', '--collection', 'test_collection', '--out', backup_collection_dir], check=True)
    print(f"集合备份成功，备份文件存储在 {backup_collection_dir} 目录下。")
except subprocess.CalledProcessError as e:
    print(f"集合备份失败：{e}")

# 恢复指定集合
try:
    subprocess.run(['mongorestore', '--db', 'test_database', '--collection', 'test_collection', backup_collection_dir], check=True)
    print(f"集合恢复成功，数据从 {backup_collection_dir} 目录下恢复到 test_database 数据库的 test_collection 集合。")
except subprocess.CalledProcessError as e:
    print(f"集合恢复失败：{e}")

七、优化

使用 Python 操作 MongoDB 时，为了提升性能和效率，避免不必要的资源消耗，有很多方面可以进行优化。下面从索引优化、查询优化、批量操作优化、连接管理优化等多个角度进行介绍。

1. 索引优化

索引是提升查询性能的关键因素，合理使用索引能显著加快查询速度。

（1）合理创建索引

根据业务的查询需求，为经常用于查询条件的字段创建索引。例如，若经常根据 name 和 age 字段进行查询，可以创建复合索引：

python 复制代码 
from pymongo import MongoClient

client = MongoClient('mongodb://localhost:27017/')
db = client['test_database']
collection = db['test_collection']

# 创建复合索引
index_name = collection.create_index([("name", 1), ("age", 1)])
print(f"创建的复合索引名称: {index_name}")

（2）避免创建过多索引

虽然索引可以加快查询速度，但过多的索引会增加写操作的开销，因为每次插入、更新或删除文档时，都需要更新相应的索引。所以，只创建必要的索引。

（3）定期重建索引

随着数据的不断插入、更新和删除，索引可能会变得碎片化，影响查询性能。可以定期重建索引来优化性能：

python 复制代码 
collection.reindex()
print("索引已重建")

2. 查询优化

优化查询语句可以减少不必要的数据扫描，提高查询效率。

（1）精确查询条件

尽量使用精确的查询条件，避免使用宽泛的查询，例如避免使用 $or 操作符，因为它可能会导致全表扫描。如果必须使用 $or，可以考虑为每个条件字段创建索引。

（2）投影操作

使用投影操作只返回需要的字段，减少数据传输量。例如：

python 复制代码 
query = {"name": "John Doe"}
projection = {"name": 1, "age": 1, "_id": 0}  # 只返回 name 和 age 字段
result = collection.find(query, projection)
for doc in result:
    print(doc)

（3）使用 limit 和 skip 分页

当需要处理大量数据时，使用 limit 和 skip 进行分页查询，避免一次性返回过多数据。例如：

python 复制代码 
page_size = 10
page_number = 2
skip_count = (page_number - 1) * page_size
result = collection.find().skip(skip_count).limit(page_size)
for doc in result:
    print(doc)

3. 批量操作优化

批量操作可以减少与数据库的交互次数，提高性能。

（1）批量插入

使用 insert_many 方法一次性插入多个文档：

python 复制代码 
documents = [
    {"name": "Alice", "age": 22},
    {"name": "Bob", "age": 25}
]
result = collection.insert_many(documents)
print(f"插入的文档 ID 列表: {result.inserted_ids}")

（2）批量更新和删除

使用 bulk_write 方法进行批量更新和删除操作：

python 复制代码 
from pymongo import UpdateOne, DeleteOne

# 批量更新
requests = [
    UpdateOne({"name": "Alice"}, {"$set": {"age": 23}}),
    UpdateOne({"name": "Bob"}, {"$set": {"age": 26}})
]
result = collection.bulk_write(requests)
print(f"批量更新的文档数量: {result.modified_count}")

# 批量删除
requests = [
    DeleteOne({"name": "Alice"}),
    DeleteOne({"name": "Bob"})
]
result = collection.bulk_write(requests)
print(f"批量删除的文档数量: {result.deleted_count}")

4. 连接管理优化

合理管理与 MongoDB 的连接可以避免资源浪费。

（1）连接池复用

pymongo 会自动管理连接池，默认情况下会复用连接。确保在代码中复用 MongoClient 实例，避免频繁创建新的连接：

python 复制代码 
# 全局创建一次 MongoClient 实例
client = MongoClient('mongodb://localhost:27017/')

# 在需要使用数据库的地方复用 client
db = client['test_database']
collection = db['test_collection']

（2）调整连接池参数

根据实际业务需求，可以调整连接池的参数，如最大连接数、最小连接数等。例如：

python 复制代码 
client = MongoClient('mongodb://localhost:27017/', maxPoolSize=100, minPoolSize=10)

5. 聚合操作优化

聚合操作可能会消耗较多的资源，需要进行优化。

（1）尽早过滤数据

在聚合管道中，使用 $match 阶段尽早过滤不需要的数据，减少后续阶段的处理量：

python 复制代码 
pipeline = [
    {"$match": {"age": {"$gt": 20}}},  # 先过滤年龄大于 20 的文档
    {"$group": {"_id": "$name", "count": {"$sum": 1}}}
]
result = collection.aggregate(pipeline)
for doc in result:
    print(doc)

（2）使用索引

确保聚合操作中使用的字段有相应的索引，以加快聚合速度。

完整示例代码

python 复制代码 
from pymongo import MongoClient, UpdateOne, DeleteOne

# 连接管理优化：复用连接
client = MongoClient('mongodb://localhost:27017/')
db = client['test_database']
collection = db['test_collection']

# 索引优化
index_name = collection.create_index([("name", 1), ("age", 1)])
print(f"创建的复合索引名称: {index_name}")

# 查询优化：投影操作
query = {"name": "John Doe"}
projection = {"name": 1, "age": 1, "_id": 0}
result = collection.find(query, projection)
for doc in result:
    print(doc)

# 批量操作优化：批量插入
documents = [
    {"name": "Alice", "age": 22},
    {"name": "Bob", "age": 25}
]
result = collection.insert_many(documents)
print(f"插入的文档 ID 列表: {result.inserted_ids}")

# 批量操作优化：批量更新
requests = [
    UpdateOne({"name": "Alice"}, {"$set": {"age": 23}}),
    UpdateOne({"name": "Bob"}, {"$set": {"age": 26}})
]
result = collection.bulk_write(requests)
print(f"批量更新的文档数量: {result.modified_count}")

# 聚合操作优化：尽早过滤数据
pipeline = [
    {"$match": {"age": {"$gt": 20}}},
    {"$group": {"_id": "$name", "count": {"$sum": 1}}}
]
result = collection.aggregate(pipeline)
for doc in result:
    print(doc)

# 定期重建索引
collection.reindex()
print("索引已重建")

# 关闭连接
client.close()

八、注意事项

在使用 Python 操作 MongoDB 时，除了前面提到的各种操作和优化方法，还有一些其它重要的注意事项，以下从数据类型处理、安全方面、错误处理、性能监控等：

1. 数据类型处理

（1）日期时间类型

  • 存储与读取 ：MongoDB 中使用 datetime 对象来表示日期和时间。在 Python 里，要确保插入和查询时使用正确的 datetime 类型。例如：
python 复制代码 
from pymongo import MongoClient
from datetime import datetime

client = MongoClient('mongodb://localhost:27017/')
db = client['test_database']
collection = db['test_collection']

# 插入包含日期时间的文档
document = {
    "name": "Event",
    "date": datetime.now()
}
collection.insert_one(document)

# 查询特定日期范围内的文档
start_date = datetime(2025, 1, 1)
end_date = datetime(2025, 12, 31)
query = {
    "date": {
        "$gte": start_date,
        "$lte": end_date
    }
}
results = collection.find(query)
for result in results:
    print(result)
  • 时区问题 ：要注意时区的设置，确保在不同环境下日期时间的一致性。可以使用 pytz 库来处理时区问题。

（2）数据类型兼容性

M ongoDB 是动态类型数据库，但在 Python 中操作时，要确保数据类型的兼容性。例如，MongoDB 中的 ObjectId 类型在 Python 中对应 bson.objectid.ObjectId，在进行查询或比较时需要正确使用。

2. 安全方面

（1）身份验证

  • 启用身份验证：在生产环境中，务必启用 MongoDB 的身份验证功能。创建具有适当权限的用户，并在连接数据库时提供用户名和密码。例如：
python 复制代码 
client = MongoClient('mongodb://username:password@localhost:27017/')
  • 权限管理：根据不同的业务需求，为用户分配最小必要的权限。例如，只需要查询数据的用户，不应该赋予写操作的权限。

（2）网络安全

  • 防火墙设置：配置防火墙，只允许来自受信任 IP 地址的连接，限制 MongoDB 服务的网络访问范围。
  • 加密传输 ：使用 TLS/SSL 加密 MongoDB 与客户端之间的通信，防止数据在传输过程中被窃取或篡改。在 pymongo 中可以通过以下方式启用 SSL 连接：
python 复制代码 
client = MongoClient('mongodb://localhost:27017/', ssl=True, ssl_cert_reqs='CERT_NONE')

3. 错误处理

（1）异常捕获

  • 在使用 pymongo 进行数据库操作时，要捕获可能出现的异常，并进行适当的处理。例如，网络连接错误、数据库操作失败等。
python 复制代码 
try:
    result = collection.insert_one({"name": "Test"})
    print(f"插入的文档 ID: {result.inserted_id}")
except Exception as e:
    print(f"插入操作失败: {e}")

（2）重试机制

  • 对于一些临时性的错误，如网络抖动导致的连接失败，可以实现重试机制。例如：
python 复制代码 
import time

max_retries = 3
retry_delay = 2  # 重试间隔时间（秒）

for attempt in range(max_retries):
    try:
        result = collection.insert_one({"name": "Test"})
        print(f"插入的文档 ID: {result.inserted_id}")
        break
    except Exception as e:
        if attempt < max_retries - 1:
            print(f"第 {attempt + 1} 次尝试失败，{retry_delay} 秒后重试: {e}")
            time.sleep(retry_delay)
        else:
            print(f"多次尝试后仍失败: {e}")

4. 性能监控

（1）日志分析

  • 查看 MongoDB 的日志文件，了解数据库的运行状态和性能瓶颈。日志中会记录慢查询、索引使用情况等信息，有助于发现问题并进行优化。

（2）性能分析工具

  • 使用 MongoDB 自带的性能分析工具，如 explain() 方法来分析查询语句的执行计划，了解查询是否使用了索引、扫描的文档数量等信息。例如：
python 复制代码 
query = {"name": "Test"}
explain_result = collection.find(query).explain()
print(explain_result)

5. 版本兼容性

  • 确保 pymongo 库的版本与 MongoDB 服务器的版本兼容。不同版本的 MongoDB 可能支持不同的特性和操作，使用不兼容的版本可能会导致功能异常或性能问题。可以参考 pymongo 官方文档来选择合适的版本。

6. 资源管理

（1）内存使用

  • 注意 MongoDB 服务器的内存使用情况，避免因内存不足导致性能下降。可以通过调整 MongoDB 的配置参数，如 wiredTigerCacheSizeGB 来控制内存使用。

（2）磁盘空间

  • 定期监控数据库所在磁盘的空间使用情况，及时清理无用的数据或进行数据归档，避免磁盘空间不足影响数据库的正常运行。
相关推荐
IT猿手36 分钟前
2025最新群智能优化算法：山羊优化算法（Goat Optimization Algorithm, GOA）求解23个经典函数测试集，MATLAB
人工智能·python·算法·数学建模·matlab·智能优化算法
萧鼎1 小时前
深入解析 Umi-OCR：高效的免费开源 OCR 文字识别工具
python·ocr·umi-ocr
夏天的味道٥2 小时前
使用 Java 执行 SQL 语句和存储过程
java·开发语言·sql
IT、木易3 小时前
大白话JavaScript实现一个函数，将字符串中的每个单词首字母大写。
开发语言·前端·javascript·ecmascript
明矾java3 小时前
MySQL进阶-关联查询优化
数据库·mysql
冰糖码奇朵3 小时前
大数据表高效导入导出解决方案，mysql数据库LOAD DATA命令和INTO OUTFILE命令详解
java·数据库·sql·mysql
迷路的小犀牛3 小时前
【MYSQL数据库异常处理】执行SQL语句报超时异常
数据库·sql·mysql
Mr.NickJJ4 小时前
JavaScript系列06-深入理解 JavaScript 事件系统：从原生事件到 React 合成事件
开发语言·javascript·react.js
Archer1945 小时前
C语言——链表
c语言·开发语言·链表
My Li.5 小时前
c++的介绍
开发语言·c++
热门推荐
01DeepSeek各版本说明与优缺点分析02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03如何在WPS和Word/Excel中直接使用DeepSeek功能04苍穹外卖面试总结05DeepSeek R1本地化部署 Ollama + Chatbox 打造最强 AI 工具06本地部署DeepSeek教程（Mac版本）07Coze扣子平台完整体验和实践（附国内和国际版对比）08Windows 11 安装 Dify 完整指南 非docker环境09保姆级教程：利用Ollama与Open-WebUI本地部署 DeedSeek-R1大模型10macOS 上部署 RAGFlow