Mongodb的使用方法&与python的交互

一、Mongodb的介绍和安装

1. nosql的介绍

“NoSQL”⼀词最早于1998年被⽤于⼀个轻量级的关系数据库的名字
随着web2.0的快速发展， NoSQL概念在2009年被提了出来
NoSQL在2010年⻛⽣⽔起，现在国内外众多⼤⼩⽹站，如facebook、 google、淘宝、京东、百度等，都在使⽤nosql开发⾼性能的产品
对于⼀名程序员来讲，使⽤nosql已经成为⼀条必备技能
NoSQL最常⻅的解释是“non-relational”， “Not Only SQL”也被很多⼈接受，指的是⾮关系型的数据库

2. mongodb的优势

易扩展： NoSQL数据库种类繁多，但是⼀个共同的特点都是去掉关系数据库的关系型特性。数据之间⽆关系，这样就⾮常容易扩展
⼤数据量，⾼性能： NoSQL数据库都具有⾮常⾼的读写性能，尤其在⼤数据量下，同样表现优秀。这得益于它的⽆关系性，数据库的结构简单
灵活的数据模型： NoSQL⽆需事先为要存储的数据建⽴字段，随时可以存储⾃定义的数据格式。⽽在关系数据库⾥，增删字段是⼀件⾮常麻烦的事情。如果是⾮常⼤数据量的表，增加字段太复杂

3. mongodb的安装

3.1 命令安装

sudo apt-get install -y mongodb-org

https://docs.mongodb.com/manual/tutorial/install-mongodb-on-ubuntu/

3.2 brew安装

brew install mongodb

4. mongodb的启动

4.1 服务端mongodb的启动

查看帮助：mongod –help
启动:brew services start mongodb
停止:brew services stop mongodb
重启:brew services restart mongodb
查看是否启动成功：ps -ef|grep mongod
配置文件的位置：/etc/mongod.conf
默认端⼝：27017
日志的位置：/var/log/mongodb/mongod.log

4.2 客户端mongo启动

启动本地客户端:mongo
查看帮助：mongo –help
退出：exit或者ctrl+c

4.3 服务端mongodb无法启动的解决方法

sudo mongod --config /etc/mongod.conf &

4.4 mongodb的官方标准文档

位置：https://docs.mongodb.com/manual/introduction/

二、mongodb的基本使用

内容
1. 掌握mongodb关于数据库和集合的基础命令
2. 掌握mongdb增删改查的命令
3. 掌握mongodb高级查询的命令

1. mongodb数据库的命令

查看当前的数据库：db
查看所有的数据库：show dbs /show databases
切换数据库：use db_name
删除当前的数据库：db.dropDatabase()

2. mongodb集合的命令

默认不需要手动创建集合:向不存在的集合中第⼀次加⼊数据时，集合会被创建出来
手动创建结合:
	db.createCollection(name,options)
	db.createCollection("test")
	db.createCollection("test01",{ capped:true,size:10})
	参数capped：默认值为false表示不设置上限,值为true表示设置上限
	参数size：当capped值为true时，需要指定此参数，表示上限⼤⼩,当⽂档达到上限时，会将之前的数据覆盖，单位为字节
查看集合：show collections
删除集合：db.集合名称.drop()

3. mongodb中常见的数据类型

3.1 常见类型

Object ID： ⽂档ID
String： 字符串， 最常⽤， 必须是有效的UTF-8
Boolean： 存储⼀个布尔值， true或false
Integer： 整数可以是32位或64位， 这取决于服务器
Double： 存储浮点值
Arrays： 数组或列表， 多个值存储到⼀个键
Object： ⽤于嵌⼊式的⽂档， 即⼀个值为⼀个⽂档
Null： 存储Null值
Timestamp： 时间戳， 表示从1970-1-1到现在的总秒数
Date： 存储当前⽇期或时间的UNIX时间格式

3.2 注意点

1. 创建⽇期语句如下：参数的格式为YYYY-MM-DD new 例：Date('2018-10-01')
2. 每个⽂档都有⼀个属性，为_id，保证每个⽂档的唯⼀性可以⾃⼰去设置_id插⼊⽂档，如果没有提供，那么MongoDB为每个⽂档提供了⼀个独特的_id，类型为objectID
3. objectID是⼀个12字节的⼗六进制数,每个字节两位，一共是24位的字符串：前4个字节为当前时间戳,接下来3个字节的机器ID接下来的2个字节中MongoDB的服务进程id 最后3个字节是简单的增量值

4. mongodb的增删改查

4.1 mongodb的插入

方法：db.集合名称.insert(document)

  db.test.insert({name:'kungs',gender:1})
  db.test.insert({_id:"20181001",name:'kungs',gender:1})

注意：插⼊⽂档时，如果不指定_id参数， MongoDB会为⽂档分配⼀个唯⼀的ObjectId

4.2 mongodb的保存

db.集合名称.save(document)

如果⽂档的id已经存在则修改，如果⽂档的id不存在则添加

4.3 mongodb的简单查询

db.集合名称.find()

4.4 mongodb的更新

db.集合名称.update(<query> ,<update>,{multi: <boolean>})

参数query:查询条件
参数update:更新操作符
参数multi:可选，默认是false，表示只更新找到的第⼀条记录，值为true表示把满⾜条件的⽂档全部更新

db.test.update({name:‘kungs’},{name:‘kungs8’}) # 更新一条
db.test.update({name:‘kungs’},{ $KaTeX parse error: Expected 'EOF', got '}' at position 20: \dots{name:'kungs8'}}̲) # 更新一条 db.\dots$ set:{gender:0}},{multi:true}) # 更新全部

注意：“multi update only works with $ operators”

4.5 mongodb的删除

db.集合名称.remove(<query>,{justOne: <boolean>})

参数query:可选，删除的⽂档的条件
参数justOne:可选，如果设为true或1，则只删除⼀条，默认false，表示删除多条

5. mongodb的高级查询

内容：

1. mongodb的数据查询操作
2. 比较运算符的使用
3. 逻辑运算符的使用
4. 范围运算符的使用
5. 正则的使用
6. skip和limit的使用
7. 投影方法的使用
8. 排序方法的使用
9. 去重方法的使用

5.1 数据查询

1. ⽅法find()：查询

db.集合名称.find({条件⽂档})

2. ⽅法findOne()：查询，只返回第⼀个

db.集合名称.findOne({条件⽂档})

3. ⽅法pretty()：将结果格式化

db.集合名称.find({条件⽂档}).pretty()

5.2 比较运算符

可以使用以下数据进行练习

{"name" : "郭靖", "hometown" : "蒙古", "age" : 20, "gender" : true }
{"name" : "⻩蓉", "hometown" : "桃花岛", "age" : 18, "gender" : false }
{"name" : "华筝", "hometown" : "蒙古", "age" : 18, "gender" : false }
{"name" : "⻩药师", "hometown" : "桃花岛", "age" : 40, "gender" : true }
{"name" : "段誉", "hometown" : "⼤理", "age" : 16, "gender" : true }
{"name" : "段王爷", "hometown" : "⼤理", "age" : 45, "gender" : true }
{"name" : "洪七公", "hometown" : "华⼭", "age" : 18, "gender" : true }

方法：

等于： 默认是等于判断， 没有运算符
⼩于：$lt         (less than)
⼩于等于：$lte     (less than equal)
⼤于：$gt         (greater than)
⼤于等于：$gte
不等于：$ne

例如：

  查询年龄大于18的所有人物
  db.test.find({age:{$gte:18}})

5.3 逻辑运算符

逻辑运算符主要指与、或逻辑

1. and：在json中写多个条件即可

查询年龄⼤于或等于18， 并且性别为true的人物
  db.test.find({age:{$gte:18},gender:true})

2. or:使⽤$or，值为数组，数组中每个元素为json

1. 查询年龄⼤于18， 或性别为false的人物
  db.test.find({$or:[{age:{$gt:18}},{gender:false}]})

2. 查询年龄⼤于18或性别为男， 并且姓名是郭靖
  db.test.find({$or:[{age:{$gte:18}},{gender:true}],name:'gj'})

5.4 范围运算符

使⽤$in， $nin 判断数据是否在某个数组内

 查询年龄为18、 28的人
 db.test.find({age:{$in:[18,28,38]}})

5.5 ⽀持正则表达式

使⽤ //或 $regex 编写正则表达式

创建products数据：
{ "_id" : 100, "sku" : "abc123", "description" : "Single line description." }
{ "_id" : 101, "sku" : "abc789", "description" : "First line\nSecond line" }
{ "_id" : 102, "sku" : "xyz456", "description" : "Many spaces before     line" }
{ "_id" : 103, "sku" : "xyz789", "description" : "Multiple\nline description" }

查询products以abc开头的数据
db.products.find({sku:/^abc/})

查询sku以789结尾的数据
db.products.find({sku:{$regex:'789$'}})

5.6 skip和limit

1. ⽅法limit()：⽤于读取指定数量的⽂档

db.集合名称.find().limit(NUMBER)
查询2条学⽣信息
db.test.find().limit(2)

2. ⽅法skip()：⽤于跳过指定数量的⽂档

db.集合名称.find().skip(NUMBER)
db.test.find().skip(2)

3. 同时使用

db.test.find().limit(4).skip(5)
或 
db.test.find().skip(5).limit(4)

注意：先使用skip在使用limit的效率要高于前者

5.7 自定义查询*

由于mongo的shell是一个js的执行环境使⽤ $where 后⾯写⼀个函数，返回满⾜条件的数据

查询年龄⼤于30的学⽣
db.test.find({
    $where:function() {
        return this.age>30;}
})

5.8 投影( `find()` )

在查询到的返回结果中，只选择必要的字段，命令为：

db.集合名称.find({},{字段名称:1,...})

参数为字段与值，值为1表示显示，值为0不显特别注意：对于_id列默认是显示的，如果不显示需要明确设置为0，例：

db.test.find({},{_id:0,name:1,gender:1})

5.9 排序( sort() )

⽤于对集进⾏排序，命令为：

db.集合名称.find().sort({字段:1,...})

参数1为升序排列参数-1为降序排列例：

根据性别降序， 再根据年龄升序
db.test.find().sort({gender:-1,age:1})

5.10 统计个数( count() )

⽤于统计结果集中⽂档条数

方法1：db.集合名称.find({条件}).count()

方法2：db.集合名称.count({条件})

db.test.find({gender:true}).count()
db.test.count({age:{$gt:20},gender:true})

5.11 消除重复( distinct() )

对数据进⾏去重

方法：db.集合名称.distinct('去重字段',{条件})

db.test.distinct('hometown',{age:{$gt:18}})

三、mongodb的聚合操作

1. mongodb的聚合

聚合(aggregate)是基于数据处理的聚合管道，每个文档通过一个由多个阶段（stage）组成的管道，可以对每个阶段的管道进行分组、过滤等功能，然后经过一系列的处理，输出相应的结果。语法：

db.集合名称.aggregate({管道:{表达式}})

2. mongodb的常用管道和表达式

2.1 常用管道命令

在mongodb中，⽂档处理完毕后，通过管道进⾏下⼀次处理常用管道命令如下：

$group： 将集合中的⽂档分组， 可⽤于统计结果
$match： 过滤数据， 只输出符合条件的⽂档
$project： 修改输⼊⽂档的结构， 如重命名、 增加、 删除字段、 创建计算结果
$sort： 将输⼊⽂档排序后输出
$limit： 限制聚合管道返回的⽂档数
$skip： 跳过指定数量的⽂档， 并返回余下的⽂档

2.2 常用表达式

表达式：处理输⼊⽂档并输出语法：表达式:’$列名’ 常⽤表达式:

$sum： 计算总和， $sum:1 表示以⼀倍计数
$avg： 计算平均值
$min： 获取最⼩值
$max： 获取最⼤值
$push： 在结果⽂档中插⼊值到⼀个数组中

3. 管道命令之$group

3.1 按照某个字段进行分组

$group是所有聚合命令中用的最多的一个命令，用来将集合中的文档分组，可用于统计结果

使用示例如下

db.test.aggregate(
    {$group:
        {
            _id:"$gender",
            counter:{$sum:1}
        }
    }
)

其中注意点：

1. db.db_name.aggregate： 是语法，所有的管道命令都需要写在其中
2. _id： 表示分组的依据，按照哪个字段进行分组，需要使用`$gender`表示选择这个字段进行分组
3. $sum:1： 表示把每条数据作为1进行统计，统计的是该分组下面数据的条数

3.2 group by null

当我们需要统计整个文档的时候，$group 的另一种用途就是把整个文档分为一组进行统计

使用实例如下：

db.test.aggregate(
    {$group:
        {
            _id:null,
            counter:{$sum:1}
        }
    }
)

注意点：

_id:null 表示不指定分组的字段，即统计整个文档，此时获取的counter表示整个文档的个数

3.3 数据透视

正常情况在统计的不同性别的数据的时候，需要知道所有的name，需要逐条观察，如果通过某种方式把所有的name放到一起，那么此时就可以理解为数据透视

使用示例如下：

1. 统计不同性别的人

   db.test.aggregate(
       {$group:
           {
               _id:null,
               name:{$push:"$name"}
           }
       }
   )

2. 使用$$ROOT可以将整个文档放入数组中

db.test.aggregate(
       {$group:
           {
               _id:null,
               name:{$push:"$$ROOT"}
           }
       }
   )

3.4 示例

对于如下数据，需要统计出每个country/province下的userid的数量（同一个userid只统计一次）

{ "country" : "china", "province" : "sh", "userid" : "a" }  
{  "country" : "china", "province" : "sh", "userid" : "b" }  
{  "country" : "china", "province" : "sh", "userid" : "a" }  
{  "country" : "china", "province" : "hf", "userid" : "c" }  
{  "country" : "china", "province" : "hf", "userid" : "da" }  
{  "country" : "china", "province" : "hf", "userid" : "fa" }

参考答案

db.tv3.aggregate(
  {$group:{_id:{country:'$country',province:'$province',userid:'$userid'}}},
  {$group:{_id:{country:'$_id.country',province:'$_id.province'},count:{$sum:1}}}

4.管道命令之$match

$match用于进行数据的过滤，是在能够在聚合操作中使用的命令，和find区别在于$ match 操作可以把结果交给下一个管道处理，而find不行

使用示例如下：

1. 查询年龄大于20的学生

db.test.aggregate(
    {$match:{age:{$gt:20}}
    )

2. 查询年龄大于20的男女学生的人数

db.test.aggregate(
    {$match:{age:{$gt:20}}
    {$group:{_id:"$gender",counter:{$sum:1}}}
    )

5. 管道命令之$project

$project用于修改文档的输入输出结构，例如重命名，增加，删除字段

使用示例如下：

查询学生的年龄、姓名，仅输出年龄姓名

db.stu.aggregate(
    {$project:{_id:0,name:1,age:1}}
    )

查询男女生人生，输出人数

db.stu.aggregate(
    {$group:{_id:"$gender",counter:{$sum:1}}}
    {$project:{_id:0,counter:1}}
    )

5.1 示例

对于如下数据：统计出每个country/province下的userid的数量（同一个userid只统计一次），结果中的字段为{country:""，province:""，counter:"*"}

{ "country" : "china", "province" : "sh", "userid" : "a" }  
{  "country" : "china", "province" : "sh", "userid" : "b" }  
{  "country" : "china", "province" : "sh", "userid" : "a" }  
{  "country" : "china", "province" : "hf", "userid" : "c" }  
{  "country" : "china", "province" : "hf", "userid" : "da" }  
{  "country" : "china", "province" : "hf", "userid" : "fa" }

参考答案

db.tv3.aggregate(
  {$group:{_id:{country:'$country',province:'$province',userid:'$userid'}}},
  {$group:{_id:{country:'$_id.country',province:'$_id.province'},count:{$sum:1}}},
  {$project:{_id:0,country:'$_id.country',province:'$_id.province',counter:'$count'}}
  )

6. 管道命令之$sort

$sort用于将输入的文档排序后输出

使用示例如下：

查询学生信息，按照年龄升序
```
db.stu.aggregate({$sort:{age:1}})
```

查询男女人数，按照人数降序

db.stu.aggregate(
    {$group:{_id:"$gender",counter:{$sum:1}}},
    {$sort:{counter:-1}}
)

7. 管道命令之`$skip` 和 `$limit`

$limit限制返回数据的条数
$skip 跳过指定的文档数，并返回剩下的文档数
同时使用时先使用skip在使用limit

使用示例如下：

查询2条学生信息
```
db.test.aggregate(
    {$limit:2}
)
```
查询从第三条开始的学生信息
```
db.test.aggregate(
    {$skip:3}
)
```

统计男女生人数，按照人数升序，返回第二条数据

db.test.aggregate(
    {$group:{_id:"$gender",counter:{$sum:1}}},
    {$sort:{counter:-1}},
    {$skip:1},
    {$limit:1}
)

四、Mongdb的索引备份以及和python交互

内容

1. mongodb创建索引的目的
2. mongdb创建索引的方式
	1) 掌握mongodb索引的创建，删除操作
    2) 掌握mongodb查看索引的方法
    3) 掌握mongodb创建联合索引的方法
    4) 掌握mongodb创建唯一索引的方法
3. mongdb备份和恢复的命令

1. mongodb的索引

1.1 mongdb创建索引的目的

加快查询速度
进行数据的去重

1.2 mongodb创建简单的索引方法

1. 语法：

db.集合.ensureIndex({属性:1})  # 1表示升序， -1表示降序
或
db.集合.createIndex({属性:1})

2. 实例：

db.test.ensureIndex({name:1})

1.3 创建索引前后查询速度对比

测试：插入10万条数据到数据库中插入数据：

for(i=0;i<100000;i++){db.t255.insert({name:'test'+i,age:i})}

创建索引前：

db.t1.find({name:'test10000'})
db.t1.find({name:'test10000'}).explain('executionStats')

创建索引后：

db.t255.ensureIndex({name:1})
db.t1.find({name:'test10000'}).explain('executionStats')

创建索引前后速度对比executionTimeMillis，明显快了很多

1.4 索引的查看

默认情况下_id是集合的索引

查看方式：

db.collection_name.getIndexes()

添加索引前：

> db.test2000.insert({"name":"hello",age:20})
WriteResult({ "nInserted" : 1 })
> db.test2000.find()
{ "_id" : ObjectId("5ae0232f625b9ddd91a0e7ae"), "name" : "hello", "age" : 20 }
> db.test2000.getIndexes()
[
    {
        "v" : 2,
        "key" : {
            "_id" : 1
        },
        "name" : "_id_",
        "ns" : "test2000.test2000"
    }
]

添加name为索引后:

> db.test2000.ensureIndex({name:1})
{
    "createdCollectionAutomatically" : false,
    "numIndexesBefore" : 1,
    "numIndexesAfter" : 2,
    "ok" : 1
}
> db.test2000.getIndexes()
[
    {
        "v" : 2,
        "key" : {
            "_id" : 1
        },
        "name" : "_id_",
        "ns" : "test2000.test2000"
    },
    {
        "v" : 2,
        "key" : {
            "name" : 1
        },
        "name" : "name_1",
        "ns" : "test2000.test2000"
    }
]

1.5 mongodb创建唯一索引

在默认情况下mongdb的索引字段的值是可以相同的,仅仅能够提高查询速度

添加唯一索引的语法：

db.collection_name.ensureIndex({"name":1},{"unique":true})

使用普通索引的效果如下：

> db.test2000.getIndexes()
[
    {
        "v" : 2,
        "key" : {
            "_id" : 1
        },
        "name" : "_id_",
        "ns" : "test2000.test2000"
    },
    {
        "v" : 2,
        "key" : {
            "name" : 1
        },
        "name" : "name_1",
        "ns" : "test2000.test2000"
    }
]
> db.test2000.insert({name:"hello",age:40})
WriteResult({ "nInserted" : 1 })
> db.test2000.find()
{ "_id" : ObjectId("5ae0232f625b9ddd91a0e7ae"), "name" : "hello", "age" : 20 }
{ "_id" : ObjectId("5ae02421625b9ddd91a0e7af"), "name" : "hello", "age" : 30 }
{ "_id" : ObjectId("5ae02432625b9ddd91a0e7b0"), "name" : "hello", "age" : 40 }

添加age为唯一索引之后：

> db.test2000.createIndex({age:1},{unique:true})
{
    "createdCollectionAutomatically" : false,
    "numIndexesBefore" : 2,
    "numIndexesAfter" : 3,
    "ok" : 1
}
> db.test2000.getIndexes()
[
    {
        "v" : 2,
        "key" : {
            "_id" : 1
        },
        "name" : "_id_",
        "ns" : "test2000.test2000"
    },
    {
        "v" : 2,
        "key" : {
            "name" : 1
        },
        "name" : "name_1",
        "ns" : "test2000.test2000"
    },
    {
        "v" : 2,
        "unique" : true,
        "key" : {
            "age" : 1
        },
        "name" : "age_1",
        "ns" : "test2000.test2000"
    }
]
> db.test2000.insert({"name":"world",age:20})
WriteResult({
    "nInserted" : 0,
    "writeError" : {
        "code" : 11000,
        "errmsg" : "E11000 duplicate key error collection: test2000.test2000 index: age_1 dup key: { : 20.0 }"
    }
})

1.6 删除索引(dropIndex({‘索引名称’:1}))

语法：db.t1.dropIndex({‘索引名称’:1})

> db.test2000.getIndexes()
[
    {
        "v" : 2,
        "key" : {
            "_id" : 1
        },
        "name" : "_id_",
        "ns" : "test2000.test2000"
    },
    {
        "v" : 2,
        "key" : {
            "name" : 1
        },
        "name" : "name_1",
        "ns" : "test2000.test2000"
    },
    {
        "v" : 2,
        "unique" : true,
        "key" : {
            "age" : 1
        },
        "name" : "age_1",
        "ns" : "test2000.test2000"
    }
]
> db.test2000.dropIndex({age:1})
{ "nIndexesWas" : 3, "ok" : 1 }
> db.test2000.dropIndex({name:1})
{ "nIndexesWas" : 2, "ok" : 1 }
> db.test2000.getIndexes()
[
    {
        "v" : 2,
        "key" : {
            "_id" : 1
        },
        "name" : "_id_",
        "ns" : "test2000.test2000"
    }
]

1.7 建立复合索引(`ensureIndex({字段1:1,字段2:1})`)

在进行数据去重的时候，可能用一个字段来保证数据的唯一性，这个时候可以考虑建立复合索引来实现。

例如：抓全贴吧信息，如果把帖子的名字作为唯一索引对数据进行去重是不可取的，因为可能有很多帖子名字相同

建立复合索引的语法：db.collection_name.ensureIndex({字段1:1,字段2:1})

> db.test2000.getIndexes()
[
    {
        "v" : 2,
        "key" : {
            "_id" : 1
        },
        "name" : "_id_",
        "ns" : "test2000.test2000"
    }
]
> db.test2000.createIndex({name:1,age:1})
{
    "createdCollectionAutomatically" : false,
    "numIndexesBefore" : 1,
    "numIndexesAfter" : 2,
    "ok" : 1
}
> db.test2000.getIndexes()
[
    {
        "v" : 2,
        "key" : {
            "_id" : 1
        },
        "name" : "_id_",
        "ns" : "test2000.test2000"
    },
    {
        "v" : 2,
        "key" : {
            "name" : 1,
            "age" : 1
        },
        "name" : "name_1_age_1",
        "ns" : "test2000.test2000"
    }
]

1.8 建立索引注意点

1. 根据需要选择是否需要建立唯一索引
2. 索引字段是升序还是降序在单个索引的情况下不影响查询效率，但是带复合索引的条件下会有影响

例如：

在进行查询的时候如果字段1需要升序的方式排序输出，字段2需要降序的方式排序输出，那么此时复合索引的建立需要把字段1设置为1，字段2设置为-1

2. mongodb的备份和恢复

2.1 备份

备份的语法：

mongodump -h dbhost -d dbname -o dbdirectory

-h：服务器地址，也可以指定端⼝号,默认情况下是本地(127.0.0.1)
-d：需要备份的数据库名称
-o：备份的数据存放位置，此⽬录中存放着备份出来的数据

示例：

mongodump -h 127.0.0.1:27017 -d test1 -o ~/Desktop/

2.2 恢复

恢复语法：

mongorestore -h dbhost -d dbname --dir dbdirectory

-h：服务器地址
-d：需要恢复的数据库实例
–dir：备份数据所在位置

示例：

mongorestore -h 127.0.0.1:27017 -d test2 --dir ~/Desktop/test1

五、mongodb和python交互

1. mongdb和python交互的模块

pymongo 提供了mongdb和python交互的所有方法安装方式:

 pip install pymongo

2. 使用pymongo

1. 导入pymongo并选择要操作的集合数据库和集合乜有会自动创建

from pymongo import MongoClient
client = MongoClient(host,port)
collection = client[db名][集合名]

2. 添加一条数据

   ret = collection.insert_one({"name":"10086","age":100})
    print(ret)

3. 添加多条数据

item_list = [{"name":"py_{}".format(i)} for i in range(10)]
    #insert_many接收一个列表，列表中为所有需要插入的字典
t = collection.insert_many(item_list)

4. 查找一条数据

#find_one查找并且返回一个结果,接收一个字典形式的条件
t = collection.find_one({"name":"py_5"})
print(t)

5. 查找全部数据
结果是一个Cursor游标对象，是一个可迭代对象，可以类似读文件的指针，但是只能够进行一次读取

#find返回所有满足条件的结果，如果条件为空，则返回数据库的所有
t = collection.find({"name":"py_5"})
    #结果是一个Cursor游标对象，是一个可迭代对象，可以类似读文件的指针，
for i in t:
    print(i)
for i in t: #此时t中没有内容
    print(i)

6. 更新一条数据注意使用$set命令

#update_one更新一条数据
collection.update_one({"name":"py_5"},{"$set":{"name":"new_test10005"}})

7. 更行全部数据

# update_one更新全部数据
collection.update_many({"name":"py_5"},{"$set":{"name":"new_py_5"}})

8. 删除一条数据

#delete_one删除一条数据
collection.delete_one({"name":"py_10"})

9. 删除全部数据

#delete_may删除所有满足条件的数据
collection.delete_many({"name":"py_10"})

3. 示例

实例：
1. 使用python向集合t3中插入1000条文档，文档的属性包括_id、name
    1) _id的值为0、1、2...999
    2) _id的值为'py0'、'py1',...
2. 查询显示出_id为100的整倍数的文档，如100、200...，并将name输出

from pymongo import MongoClient

# client = MongoClient(host="127.0.0.1", port=27017)
client = MongoClient()  # 本机，参数可以不用写

collection = client["test1000"]["t3"]

temp_list = [{"_id": i, "name": "py{}".format(i)} for i in range(1000)]
print(temp_list)
collection.insert_many(temp_list)

ret_list = list(collection.find({}))
ret = [i["name"] for i in ret_list if i["_id"]%100==0 and i["_id"]!=0]
print(ret)

六、MongoEngine 和python交互

pymongo操作MongoDB数据库，直接把对数据库的操作代码写在脚本里，应用的代码耦合性太强，不利于代码的优化管理。

通常情况下应用是使用MVC框架来设计的，为了更好地维持MVC结构，需要把数据库操作部分作为model抽离出来，这就需要借助MongoEngine

MongoEngine是一个对象文档映射器（ODM），相当于一个基于SQL的对象关系映射器（ORM）

MongoEngine提供的抽象是基于类的，创建的所有模型都是类

1.MongoEngine安装

pip3 install mongoengine

先声明一个继承自MongoEngine.Document的类

在类中声明一些属性，相当于创建一个用来保存数据的数据结构，即数据以类似数据结构的形式存入数据库中，通常把这样的一些类都存放在一个脚本中，作为应用的Model模块

from mongoengine import *
connect('test', host='localhost', port=27017)
import datetime
class Page(Document):
    title = StringField(max_length=200, required=True)
    date_modified = DateTimeField(default=datetime.datetime.utcnow)

# Create a new page and add tags
>>> page = Page(title='Using MongoEngine')
>>> page.tags = ['mongodb', 'mongoengine']
>>> page.save()

>>> Page.objects(tags='mongoengine').count()
>>> 1

具体操作的方法见下面链接

Docs参考：http://docs.mongoengine.org/tutorial.html