原文： http://zetcode.com/python/pymongo/

PyMongo 教程展示了如何使用 Python 编程 MongoDB。 在作者的 Github 仓库中提供了代码示例。

MongoDB 是 NoSQL 跨平台的面向文档的数据库。 它是可用的最受欢迎的数据库之一。 MongoDB 由 MongoDB Inc. 开发，并作为免费和开源软件发布。

MongoDB 中的记录是一个文档，它是由字段和值对组成的数据结构。 MongoDB 文档与 JSON 对象相似。 字段的值可以包括其他文档，数组和文档数组。 MongoDB 将文档存储在集合中。 集合类似于关系数据库中的表以及行中的文档。

游标是对查询结果集的引用。 客户可以遍历游标以检索结果。 默认情况下，游标闲置十分钟后会超时。

PyMongo

PyMongo 是一个 Python 模块，用于在 Python 中使用 MongoDB。

安装 PyMongo

以下命令用于安装 PyMongo。

  1. $ sudo pip install pymongo

我们用pip安装 PyMongo。

创建一个 MongoDB 数据库

mongo工具是 MongoDB 的交互式 JavaScript Shell 界面，它为系统管理员提供了一个界面，并为开发者提供了一种直接测试数据库查询和操作的方法。

  1. $ mongo testdb
  2. MongoDB shell version: 2.6.10
  3. connecting to: testdb
  4. > show dbs
  5. admin   (empty)
  6. local   0.078GB
  7. test    0.078GB
  8. testdb  0.078GB

我们创建一个testdb数据库。

PyMongo 创建集合

在第一个示例中，我们创建一个新集合。 MongoDB 将文档存储在集合中。 集合类似于关系数据库中的表。

create_collection.py

  1. #!/usr/bin/python3
  3. from pymongo import MongoClient
  5. cars = [ {'name': 'Audi', 'price': 52642},
  6.     {'name': 'Mercedes', 'price': 57127},
  7.     {'name': 'Skoda', 'price': 9000},
  8.     {'name': 'Volvo', 'price': 29000},
  9.     {'name': 'Bentley', 'price': 350000},
  10.     {'name': 'Citroen', 'price': 21000},
  11.     {'name': 'Hummer', 'price': 41400},
  12.     {'name': 'Volkswagen', 'price': 21600} ]
  14. client = MongoClient('mongodb://localhost:27017/')
  16. with client:
  18.     db = client.testdb
  20.     db.cars.insert_many(cars)

该示例创建一个新的cars集合。 它包含八个文档。

  1. cars = [ {'name': 'Audi', 'price': 52642},
  2.     {'name': 'Mercedes', 'price': 57127},
  3.     {'name': 'Skoda', 'price': 9000},
  4.     {'name': 'Volvo', 'price': 29000},
  5.     {'name': 'Bentley', 'price': 350000},
  6.     {'name': 'Citroen', 'price': 21000},
  7.     {'name': 'Hummer', 'price': 41400},
  8.     {'name': 'Volkswagen', 'price': 21600} ]

该 Python 字典存储了八个要插入到 MongoDB 集合中的记录。

  1. client = MongoClient('mongodb://localhost:27017/')

MongoClient用于与 MongoDB 通信。 我们传递MongoClient主机名和端口号。

  1. db = client.testdb

我们获得了对testdb数据库的引用。

  1. db.cars.insert_many(cars)

使用insert_many()方法，我们将八个文档插入到cars集合中，该集合也会自动创建。

  1. > db.cars.find()
  2. { "_id" : ObjectId("5b41eb21b9c5d915989d48a8"), "price" : 52642, "name" : "Audi" }
  3. { "_id" : ObjectId("5b41eb21b9c5d915989d48a9"), "price" : 57127, "name" : "Mercedes" }
  4. { "_id" : ObjectId("5b41eb21b9c5d915989d48aa"), "price" : 9000, "name" : "Skoda" }
  5. { "_id" : ObjectId("5b41eb21b9c5d915989d48ab"), "price" : 29000, "name" : "Volvo" }
  6. { "_id" : ObjectId("5b41eb21b9c5d915989d48ac"), "price" : 350000, "name" : "Bentley" }
  7. { "_id" : ObjectId("5b41eb21b9c5d915989d48ad"), "price" : 21000, "name" : "Citroen" }
  8. { "_id" : ObjectId("5b41eb21b9c5d915989d48ae"), "price" : 41400, "name" : "Hummer" }
  9. { "_id" : ObjectId("5b41eb21b9c5d915989d48af"), "price" : 21600, "name" : "Volkswagen" }

我们使用mongo工具验证数据。

PyMongo 列出集合

使用collection_names()，我们获得数据库中可用列表的列表。

list_collections.py

  1. #!/usr/bin/python3
  3. from pymongo import MongoClient
  5. client = MongoClient('mongodb://localhost:27017/')
  7. with client:
  9.     db = client.testdb
  10.     print(db.collection_names())

该示例在testdb数据库中打印集合。

PyMongo 删除集合

drop()方法从数据库中删除一个集合。

drop_collection.py

  1. #!/usr/bin/python3
  3. from pymongo import MongoClient
  5. client = MongoClient('mongodb://localhost:27017/')
  7. with client:
  9.     db = client.testdb
  11.     db.cars.drop()

该示例从testdb数据库中删除cars集合。

PyMongo 运行命令

我们可以使用command()向 MongoDB 发出命令。 serverStatus命令返回 MongoDB 服务器的状态。

server_status.py

  1. #!/usr/bin/python3
  3. from pymongo import MongoClient
  4. from pprint import pprint
  6. client = MongoClient('mongodb://localhost:27017/')
  8. with client:
  10.     db = client.testdb
  12.     status = db.command("serverStatus")
  13.     pprint(status)

该示例显示冗长的服务器状态。

dbstats命令返回反映单个数据库使用状态的统计信息。

db_stats.py

  1. #!/usr/bin/python3
  3. from pymongo import MongoClient
  4. from pprint import pprint
  6. client = MongoClient('mongodb://localhost:27017/')
  8. with client:
  10.     db = client.testdb
  11.     print(db.collection_names())
  13.     status = db.command("dbstats")
  14.     pprint(status)

该示例打印testdb的数据库统计信息。

PyMongo 游标

find方法返回一个 PyMongo 游标，该游标是对查询结果集的引用。

cursor.py

  1. #!/usr/bin/python3
  3. from pymongo import MongoClient
  5. client = MongoClient('mongodb://localhost:27017/')
  7. with client:
  9.     db = client.testdb
  11.     cars = db.cars.find()
  13.     print(cars.next())
  14.     print(cars.next())
  15.     print(cars.next())
  17.     cars.rewind()
  19.     print(cars.next())
  20.     print(cars.next())
  21.     print(cars.next())    
  23.     print(list(cars))

在示例中，我们使用游标。

  1. cars = db.cars.find()

find()方法返回一个 PyMongo 游标。

  1. print(cars.next())

使用next()方法，我们从结果集中获取下一个文档。

  1. cars.rewind()

rewind()方法将游标倒回其未求值状态。

  1. print(list(cars))

使用list()方法，我们可以将游标转换为 Python 列表。 它将所有数据加载到内存中。

PyMongo 读取所有数据

在下面的示例中，我们从集合中读取所有记录。 我们使用 Python for循环遍历返回的游标。

all_cars.py

  1. #!/usr/bin/python3
  3. from pymongo import MongoClient
  5. client = MongoClient('mongodb://localhost:27017/')
  7. with client:
  9.     db = client.testdb
  11.     cars = db.cars.find()
  13.     for car in cars:
  14.         print('{0} {1}'.format(car['name'], 
  15.             car['price']))

该示例从集合中打印所有汽车名称及其价格。

  1. cars = db.cars.find()

find()方法选择集合或视图中的文档，然后将游标返回到所选文档。 游标是对查询结果集的引用。

  1. for car in cars:
  2.     print('{0} {1}'.format(car['name'], 
  3.         car['price']))

使用 Python for 循环，我们遍历结果集。

  1. $ ./all_cars.py 
  2. Audi 52642
  3. Mercedes 57127
  4. Skoda 9000
  5. Volvo 29000
  6. Bentley 350000
  7. Citroen 21000
  8. Hummer 41400
  9. Volkswagen 21600

这是输出。

PyMongo 计数文件

使用count()方法检索文档数量。

count_cars.py

  1. #!/usr/bin/python3
  3. from pymongo import MongoClient
  5. client = MongoClient('mongodb://localhost:27017/')
  7. with client:
  9.     db = client.testdb
  11.     n_cars = db.cars.find().count()
  13.     print("There are {} cars".format(n_cars))

该示例使用count()计算集合中的汽车数量。

  1. $ ./count_cars.py 
  2. There are 8 cars

集合中有八辆车。

PyMongo 过滤器

find()和find_one()的第一个参数是一个过滤器。 过滤器是所有文档必须匹配的条件。

filtering.py

  1. #!/usr/bin/python3
  3. from pymongo import MongoClient
  5. client = MongoClient('mongodb://localhost:27017/')
  7. with client:
  9.     db = client.testdb
  11.     expensive_cars = db.cars.find({'price': {'$gt': 50000}})
  13.     for ecar in expensive_cars:
  14.         print(ecar['name'])

该示例打印价格大于 50000 的汽车的名称。

  1. expensive_cars = db.cars.find({'price': {'$gt': 50000}})

find()方法的第一个参数是所有返回的记录必须匹配的过滤器。 过滤器使用$gt运算符仅返回昂贵的汽车。

  1. $ ./filtering.py 
  2. Audi
  3. Mercedes
  4. Bentley

这是输出。

PyMongo 投影

通过投影，我们可以从返回的文档中选择特定字段。 投影在find()方法的第二个参数中传递。

projection.py

  1. #!/usr/bin/python3
  3. from pymongo import MongoClient
  5. client = MongoClient('mongodb://localhost:27017/')
  7. with client:
  9.     db = client.testdb
  11.     cars = db.cars.find({}, {'_id': 1, 'name':1})
  13.     for car in cars:
  14.         print(car)

该示例打印文档的_id和name字段。

  1. cars = db.cars.find({}, {'_id': 1, 'name':1})

我们可以指定包含或排除投影，但不能同时指定。

  1. $ ./projection.py 
  2. {'name': 'Audi', '_id': ObjectId('5b41eb21b9c5d915989d48a8')}
  3. {'name': 'Mercedes', '_id': ObjectId('5b41eb21b9c5d915989d48a9')}
  4. {'name': 'Skoda', '_id': ObjectId('5b41eb21b9c5d915989d48aa')}
  5. {'name': 'Volvo', '_id': ObjectId('5b41eb21b9c5d915989d48ab')}
  6. {'name': 'Bentley', '_id': ObjectId('5b41eb21b9c5d915989d48ac')}
  7. {'name': 'Citroen', '_id': ObjectId('5b41eb21b9c5d915989d48ad')}
  8. {'name': 'Hummer', '_id': ObjectId('5b41eb21b9c5d915989d48ae')}
  9. {'name': 'Volkswagen', '_id': ObjectId('5b41eb21b9c5d915989d48af')}

这是输出。

PyMongo 排序文件

我们可以使用sort()对文档进行排序。

sorting.py

  1. #!/usr/bin/python3
  3. from pymongo import MongoClient, DESCENDING
  5. client = MongoClient('mongodb://localhost:27017/')
  7. with client:
  9.     db = client.testdb
  11.     cars = db.cars.find().sort("price", DESCENDING)
  13.     for car in cars:
  14.         print('{0} {1}'.format(car['name'], 
  15.             car['price']))

该示例按价格降序对记录进行排序。

  1. $ ./sorting.py 
  2. Bentley 350000
  3. Mercedes 57127
  4. Audi 52642
  5. Hummer 41400
  6. Volvo 29000
  7. Volkswagen 21600
  8. Citroen 21000
  9. Skoda 9000

这是输出。

PyMongo 聚合

聚合计算集合中数据的聚合值。

aggregate_sum.py

  1. #!/usr/bin/python3
  3. from pymongo import MongoClient
  5. client = MongoClient('mongodb://localhost:27017/')
  7. with client:
  9.     db = client.testdb
  11.     agr = [ {'$group': {'_id': 1, 'all': { '$sum': '$price' } } } ]
  13.     val = list(db.cars.aggregate(agr))
  15.     print('The sum of prices is {}'.format(val[0]['all']))

该示例计算所有汽车价格的总和。

  1. agr = [ {'$group': {'_id': 1, 'all': { '$sum': '$price' } } } ]

$sum运算符计算并返回数值的总和。 $group运算符通过指定的标识符表达式对输入文档进行分组，并将累加器表达式（如果指定）应用于每个组。

  1. val = list(db.cars.aggregate(agr))

aggregate()方法将聚合操作应用于cars集合。

  1. $ ./aggregate_sum.py 
  2. The sum of prices is 581769

所有值的总和是 581769。

我们可以使用$match运算符来选择要汇总的特定汽车。

sum_two_cars.py

  1. #!/usr/bin/python3
  3. from pymongo import MongoClient
  5. client = MongoClient('mongodb://localhost:27017/')
  7. with client:
  9.     db = client.testdb
  11.     agr = [{ '$match': {'$or': [ { 'name': "Audi" }, { 'name': "Volvo" }] }}, 
  12.         { '$group': {'_id': 1, 'sum2cars': { '$sum': "$price" } }}]
  14.     val = list(db.cars.aggregate(agr))
  16.     print('The sum of prices of two cars is {}'.format(val[0]['sum2cars']))

该示例计算奥迪和沃尔沃汽车的价格总和。

  1. agr = [{ '$match': {'$or': [ { 'name': "Audi" }, { 'name': "Volvo" }] }}, 
  2.     { '$group': {'_id': 1, 'sum2cars': { '$sum': "$price" } }}]

该表达式使用$match，$or，$group和$sum运算符执行任务。

  1. $ ./sum_two_cars.py 
  2. The sum of prices of two cars is 81642

两辆车的总价是 81642。

PyMongo 限制数据输出

limit查询选项指定要返回的文档数量，skip()选项指定某些文档。

MongoSkipLimit.java

  1. #!/usr/bin/python3
  3. from pymongo import MongoClient
  5. client = MongoClient('mongodb://localhost:27017/')
  7. with client:
  9.     db = client.testdb
  11.     cars = db.cars.find().skip(2).limit(3)
  13.     for car in cars:
  14.         print('{0}: {1}'.format(car['name'], car['price']))

该示例从cars集合中读取，跳过了前两个文档，并将输出限制为三个文档。

  1. cars = db.cars.find().skip(2).limit(3)

skip()方法跳过前两个文档，limit()方法将输出限制为三个文档。

  1. $ ./limit_documents.py 
  2. Skoda: 9000
  3. Volvo: 29000
  4. Bentley: 350000

这是示例的输出。

在 PyMongo 教程中，我们使用了 MongoDB 和 Python。

您可能还会对以下教程感兴趣： PyMySQL 教程， pyDAL 教程， Peewee 教程， SQLite Python 教程， OpenPyXL 教程，Bottle 教程， Python CSV 教程或 Python 教程。