爬虫提高之mongdb数据库

最新推荐文章于 2024-05-21 17:51:30 发布

Di.via

最新推荐文章于 2024-05-21 17:51:30 发布

阅读量185

点赞数

分类专栏：爬虫文章标签：爬虫

本文链接：https://blog.csdn.net/weixin_44611098/article/details/101171412

版权

爬虫专栏收录该内容

11 篇文章 1 订阅

订阅专栏

Mongodb数据库
介绍
在前面的课程中我们学习了mysql这种关系型数据库，那么接下来，我们会来学习一种非关系型数据库mongodb

内容
mongodb的介绍
mongodb安装
mongodb基本操作
mongodb数据查询
mongdb聚合
索引和备份
mongo和python交互

2.2.1mongodb的介绍和安装
目标
了解非关系型数据库和关系型数据库的区别
了解mongodb的优势
掌握mongodb的安装

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

对于关系型数据库，存储数据的时候需要提前建表建库，随着数据的复杂度越来越高，所建的表的数量也越来越多；但是非关系型却不需要

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

sudo apt-get install -y mongodb-org

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

4.2 源码安装

mongodb的启动
5.1 服务端mongodb的启动
查看帮助：mongod –help
启动：sudo service mongod start
停止：sudo service mongod stop
重启：sudo service mongod restart
查看是否启动成功：ps -ef|grep mongod
配置文件的位置：/etc/mongod.conf，
默认端⼝：27017
日志的位置：/var/log/mongodb/mongod.log
5.2 客户端mongo
启动本地客户端:mongo
查看帮助：mongo –help
退出：exit或者ctrl+c
5.3 服务端mongodb无法启动的解决方法

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

5.4 mongodb的官方文档
位置：https://docs.mongodb.com/manual/introduction/

小结
本小结重点
掌握mongodb的安装和启动
能够说出mongdb的优势

2.2.2mongodb的基本使用
目标
掌握mongodb关于数据库和集合的基础命令
掌握mongdb增删改查的命令
掌握mongodb高级查询的命令

mongodb数据库的命令
查看当前的数据库：db
查看所有的数据库：show dbs /show databases
切换数据库：use db_name
删除当前的数据库：db.dropDatabase()
mongodb集合的命令
不手动创建集合：向不存在的集合中第⼀次加⼊数据时，集合会被创建出来
手动创建结合：
db.createCollection(name,options)
db.createCollection(“stu”)
db.createCollection(“sub”, { capped : true, size : 10 } )
参数capped：默认值为false表示不设置上限,值为true表示设置上限
参数size：当capped值为true时，需要指定此参数，表示上限⼤⼩,当⽂档达到上限时，会将之前的数据覆盖，单位为字节
查看集合：show collections
删除集合：db.集合名称.drop()
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 注意点
创建⽇期语句如下：参数的格式为YYYY-MM-DD new Date(‘2017-12-20’)
每个⽂档都有⼀个属性，为_id，保证每个⽂档的唯⼀性

可以⾃⼰去设置_id插⼊⽂档，如果没有提供，那么MongoDB为每个⽂档提供了⼀个独特的_id，类型为objectID

objectID是⼀个12字节的⼗六进制数,每个字节两位，一共是24 位的字符串：前4个字节为当前时间戳接下来3个字节的机器ID 接下来的2个字节中MongoDB的服务进程id 最后3个字节是简单的增量值

mongodb的增删改查
知识点：

掌握mongodb的插入和保存
掌握mongodb的更新操作
掌握mongodb的查询操作
掌握mongodb的更新操作
掌握mongodb的删除操作
4.1 mongodb的插入

db.集合名称.insert(document)

  db.stu.insert({name:'gj',gender:1})
  db.stu.insert({_id:"20170101",name:'gj',gender:1})

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

4.2 mongodb的保存
命令：db.集合名称.save(document) 如果⽂档的_id已经存在则修改，如果⽂档的_id不存在则添加

4.3 mongodb的简单查询
命令：db.集合名称.find()

4.4 mongodb的更新
命令：db.集合名称.update( ,,{multi: })

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

db.stu.update({name:'hr'},{name:'mnc'})   更新一条
db.stu.update({name:'hr'},{$set:{name:'hys'}})    更新一条
db.stu.update({},{$set:{gender:0}},{multi:true})   更新全部

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

4.5 mongodb的删除
命令：db.集合名称.remove(,{justOne: })

参数query:可选，删除的⽂档的条件
参数justOne:可选，如果设为true或1，则只删除⼀条，默认false，表示删除多条
5. mongodb的高级查询
知识点：

掌握mongodb的数据查询操作
掌握比较运算符的使用
掌握逻辑运算符的使用
掌握范围运算符的使用
了解正则的使用
掌握skip和limit的使用
掌握投影方法的使用
掌握排序方法的使用
了解去重方法的使用

5.1 数据查询
⽅法find()：查询

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

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

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

⽅法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 }

等于：默认是等于判断，没有运算符
⼩于： $l t （ l e s s t h a n ）⼩于等于：$ lte （less than equal）
⼤于： $g t （ g r e a t e r t h a n ）⼤于等于：$ gte
不等于：$ne

例如：

  查询年龄大于18的所有学生
  db.stu.find({age:{$gte:18}})

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

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

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

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

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

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

5.4 范围运算符
使⽤$in， $nin 判断数据是否在某个数组内

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

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

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

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

{ "_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" }

5.6 skip和limit
⽅法limit()：⽤于读取指定数量的⽂档

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

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

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

同时使用

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

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

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

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

5.8 投影
在查询到的返回结果中，只选择必要的字段

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

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

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

5.9 排序
⽅法sort()，⽤于对集进⾏排序

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

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

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

5.10 统计个数
⽅法count()⽤于统计结果集中⽂档条数

命令：db.集合名称.find({条件}).count() 命令：db.集合名称.count({条件})

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

5.11 消除重复
⽅法distinct()对数据进⾏去重

命令：db.集合名称.distinct(‘去重字段’,{条件})

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

小结
本小结重点
掌握数据库和集合相关的命令
掌握基本的增删改查命令
掌握mongdb的高级查询命令

2.2.3mongodb的聚合操作
目标
了解mongodb的聚合是什么
掌握mongdb的管道命令
掌握mongdb的表达式

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

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

mongodb的常用管道和表达式
知识点：

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

$group：将集合中的⽂档分组，可⽤于统计结果
$match：过滤数据，只输出符合条件的⽂档
$project：修改输⼊⽂档的结构，如重命名、增加、删除字段、创建计算结果
$sort：将输⼊⽂档排序后输出
$limit：限制聚合管道返回的⽂档数
$s k i p ：跳过指定数量的⽂档，并返回余下的⽂档 2.2 常用表达式表达式：处理输⼊⽂档并输出语法：表达式 :^{'}$ 列名’ 常⽤表达式:

$sum：计算总和， $sum:1 表示以⼀倍计数
$avg：计算平均值
$min：获取最⼩值
$max：获取最⼤值
$p u s h ：在结果⽂档中插⼊值到⼀个数组中 3 . 管道命令之$ group
3.1 按照某个字段进行分组
$group是所有聚合命令中用的最多的一个命令，用来将集合中的文档分组，可用于统计结果

使用示例如下

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

其中注意点：

db.db_name.aggregate是语法，所有的管道命令都需要写在其中
_id 表示分组的依据，按照哪个字段进行分组，需要使用$gender表示选择这个字段进行分组
$s u m : 1 表示把每条数据作为 1 进行统计，统计的是该分组下面数据的条数 3.2 g r o u p b y n u l l 当我们需要统计整个文档的时候，$ group 的另一种用途就是把整个文档分为一组进行统计

使用实例如下：

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

其中注意点：

_id:null 表示不指定分组的字段，即统计整个文档，此时获取的counter表示整个文档的个数
3.3 数据透视
正常情况在统计的不同性别的数据的时候，需要知道所有的name，需要逐条观察，如果通过某种方式把所有的name放到一起，那么此时就可以理解为数据透视

使用示例如下：

统计不同性别的学生

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

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

 db.stu.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" : "sh", "userid" : "c" }  
{  "country" : "china", "province" : "bj", "userid" : "da" }  
{  "country" : "china", "province" : "bj", "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
$m a t c h 用于进行数据的过滤，是在能够在聚合操作中使用的命令，和 f i n d 区别在于$ match 操作可以把结果交给下一个管道处理，而find不行

使用示例如下：

查询年龄大于20的学生

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

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

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

管道命令之$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" : "sh", "userid" : "c" }  
{  "country" : "china", "province" : "bj", "userid" : "da" }  
{  "country" : "china", "province" : "bj", "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'}}
  )

管道命令之$sort
$sort用于将输入的文档排序后输出

使用示例如下：

查询学生信息，按照年龄升序

 db.stu.aggregate({$sort:{age:1}})

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

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

管道命令之$skip 和 $limit
$limit限制返回数据的条数
$skip 跳过指定的文档数，并返回剩下的文档数
同时使用时先使用skip在使用limit
使用示例如下：

查询2条学生信息

 db.stu.aggregate(
     {$limit:2}
 )

查询从第三条开始的学生信息

 db.stu.aggregate(
     {$skip:3}
 )

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

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

小结
本小结重点
理解聚合操作的是在干什么
掌握 $g r o u p,$ match, $p r o j e c t 的使用熟悉$ sort, $l i m i t,$ skip的使用
实习常用的表达式

2.2.4Mongdb的索引备份以及和python交互
目标
理解mongodb创建索引的目的
掌握mongdb创建索引的方式
熟悉mongdb备份和恢复的命令

mongodb的索引
知识点

掌握mongodb索引的创建，删除操作
掌握mongodb查看索引的方法
掌握mongodb创建联合索引的方法
掌握mongodb创建唯一索引的方法
1.1 为什么mongdb需要创建索引
加快查询速度
进行数据的去重
1.2 mongodb创建简单的索引方法
语法：

db.集合.ensureIndex({属性:1})，1表示升序， -1表示降序
db.集合.createIndex({属性:1})
上面两个命令效果等价
具体操作：db.db_name.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')

前后速度对比

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 删除索引
语法：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.6 建立复合索引
在进行数据去重的时候，可能用一个字段来保证数据的唯一性，这个时候可以考虑建立复合索引来实现。

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

建立复合索引的语法：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.7 建立索引注意点
根据需要选择是否需要建立唯一索引
索引字段是升序还是降序在单个索引的情况下不影响查询效率，但是带复合索引的条件下会有影响

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

mongodb的备份和恢复
知识点

掌握mongdb的备份和恢复命令
2.1 备份
备份的语法：mongodump -h dbhost -d dbname -o dbdirectory
-h：服务器地址，也可以指定端⼝号
-d：需要备份的数据库名称
-o：备份的数据存放位置，此⽬录中存放着备份出来的数据
示例：mongodump -h 192.168.196.128:27017 -d test1 -o ~/Desktop/test1bak

2.2 恢复
恢复语法：mongorestore -h dbhost -d dbname --dir dbdirectory

-h：服务器地址
-d：需要恢复的数据库实例
–dir：备份数据所在位置
示例：mongorestore -h 192.168.196.128:27017 -d test2 --dir ~/Desktop/test1bak/test1

动手
尝试将我电脑中的douban.tv1中的数据恢复到自己的电脑中，具体如何操作？

完成上述操作后完成以下问题：

2.1.获取每条数据中的title，count(所有评分人数),rate(评分),country(国家)的这些字段

2.2.获取上述结果中的不同国家电视剧的数据量

2.3.获取上述结果中分数大于8分的不同国家电视剧的数据量

小结
本小结重点
掌握mongodb中创建索引的方法
掌握mongodb中查看和删除索引的方法
掌握mongodb中创建唯一索引的方法
掌握mongodb中创建联合索引的方法
掌握mongodb中数据的备份和恢复的方法

2.2.5mongodb和python交互
目标
掌握mongdb和python交互的增删改查的方法

mongdb和python交互的模块
pymongo 提供了mongdb和python交互的所有方法安装方式: pip install pymongo
使用pymongo
导入pymongo并选择要操作的集合数据库和集合乜有会自动创建

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

添加一条数据

ret = collection.insert_one({"name":"test10010","age":33})
 print(ret)

添加多条数据

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

查找一条数据

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

查找全部数据

结果是一个Cursor游标对象，是一个可迭代对象，可以类似读文件的指针，但是只能够进行一次读取

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

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

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

更行全部数据

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

删除一条数据

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

删除全部数据

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

动手

小结
本小结重点
掌握pymongo的增删改查的使用

Di.via

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
爬虫提高之mongdb数据库

Mongodb数据库介绍在前面的课程中我们学习了mysql这种关系型数据库，那么接下来，我们会来学习一种非关系型数据库mongodb内容mongodb的介绍mongodb安装mongodb基本操作mongodb数据查询mongdb聚合索引和备份mongo和python交互2.2.1mongodb的介绍和安装目标了解非关系型数据库和关系型数据库的区别了解mongodb的优...
复制链接

扫一扫