python mongodb数据库的基础教程

最新推荐文章于 2024-06-13 20:40:05 发布

长安白猫

最新推荐文章于 2024-06-13 20:40:05 发布

阅读量358

点赞数

分类专栏：爬虫基础文章标签： mongo 爬虫基础

本文链接：https://blog.csdn.net/weixin_44074810/article/details/96962195

版权

爬虫基础专栏收录该内容

11 篇文章 0 订阅

订阅专栏

Mongodb 数据库
一、优势：（集合，去重）

易扩展：数据之间无关系
大数据量，高性能：数据库的结构简单，非关系性
灵活的数据模型：无需事先为要存的数据建立字段，随时可以储存自定义的数据格式，

二、安装

这个安装时基于Ubuntu虚拟机的安装（虚拟机16.04）
5. 命令安装：

安装：sudo apt-get install mongodb 或 sudo apt-get install -y mongodb-org
卸载：sudo apt-get --purge remove mongodb mongodb-clients mongodb-server

软件包安装：（我下载的版本是3.4.0 提醒一下 ,作为一名程序员还是不要用最新的版本）

解压：tar -zxvf mongodb-linux-x86_64-ubuntu1604-3.4.0.tgz
移动到/usr/local/目录下
sudo mv -r mongodb-linux-x86_64-ubuntu1604-3.4.0/ /usr/local/mongodb
将可执行文件添加到PATH路径中
export PATH=/usR/local/mongodb/bin:$PATH

验证是否安装成功

服务端mongodb的启动
启动：sudo service mongod start
停止：sudo service mongod stop
重启：sudo service mongod restart

额外记录：
mysql端口：3306
redis端口：6379
mongodb端口：27017
以后工作可能运行的方式会不一样

指定目录存放数据启动
先建立文件夹python34 在指定存放的文件夹
sudo mongod --dbpath=/home/python/python34
生产环境正式启动方式（可以实现定制方向的使用）

启动：sudo mongod[--auth --dbpath=dbpath --logpath=logpath --append --fork] [--f logfile]

1.只以sudo mongod 命令启动时，默认将数据存放在/data/db 目录下，需要手动创建
2.–dbpath: 指定数据库存放路径
3.–logpath：指定日志的存放路径
4.–append：或–logappend 设置日志的写入形式为追加模式
5.–fork：或-fork开启新的进程运行mongodb服务
6.–f：或-f配置文件路径(可以将上述配置信息写入文件然后通过该文件中的参数进行加载启动)
7.–auth：以权限认证的方式启动

还有一种常用的启动方式：
在终端直接输入mongo启动

mongo一些小的注意点

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

三、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})

判断是否是固定大小集合：
db.集合名.isCapped()

注意：创建固定大小的集合，size代表大小，单位为字节
当文档大小达到上限时，会将之前的数据覆盖
capped：默认值为false表示不设置上限，值为true表示设置上限
固定大小集合，内容不允许修改
（不足256字节时按照256字节来算） 当数据达到规定的字节时新的数据可以插入，旧的数据将被挤出去

查看集合：show collections
删除集合：db.集合名称.drop()

四、mongodb 的增删改查

1. 新增（插入数据）：db.集合名.insert(document)
mongodb插入数据：db.集合名.insert(document)

示例：
1. db.stu.insert({name:'gj',gender:1})
2. db.stu.insert({_id:"20170101",name:'gj',gender:1})
批量插入数据是在在数据上添加成列表 ：db.stu.insert([{name:'gj',gender:1},{name:'bj',gender:2}])

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

2. 查询：(3种看个人需求)

查询数据：db.集合名称.find() 查询所有
查询数据，db.集合名.findOne{()} # 只返回第一个，
查询数据：db.集合名.find().pretty() # 将查询的结果格式化，不能和findOne()一起使用

2.2 查询拓展（高级点的查询）

比较运算符：
等于：默认是等于运算
小于： $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}})

逻辑运算符
逻辑运算符主要指与，或逻辑
and:在json中写多个条件即可

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

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

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

范围运算
使用 $i n ，$ nin 判断数据是否在某个数组内( $i n 是否在这个范围，$ nin不再这个范围)

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

正则表达式查询
使用//或$regex编写正则表达式

5. 查询sku以abc开头的数据
db.products.find({sku:/^abc/})
6. 查询sku以789结尾的数据
db.products.find({sku:{$regex:'789$'}})

自定义查询
由于mongo的shell是一个js的执行环境使用$where后面写一个函数，返回满足条件的数据

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

skip和limit
① 方法limit():用于读取指定数量的文档
db.集合名.find().limit(NUMBER)

查询2条学生信息
db.stu.find().limit(2)

② 方法skip():用于跳过指定数量的文档
db.集合名.find().skip(NUMBER)
db.stu.find().skip(2)

③ 同时使用skip和limit
db.stu.find().limit(4).skip(5)
或
db.stu.find().skip(5).limit(4)

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

投影(只显示我们想要的数据)
在查询到的返回结果中，只选择必要的字段
命令：db.集合名.find({},{字段名称:1,…})
参数为字段与值，值为1表示显示，值为0不显示，特别注意：对于_id列默认是显示的，如果不需要显示需要明确设置为0
db.stu.find({},{_id:0,name:1,gender:1})
排序
方法sort(),用于对集进行排序
命令：db.集合名.find().sort({字段:1,…})
参数1为升序排序列，参数-1为降序排序列

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

统计个数：
方法count()用于统计结果集中文档条数
命令：db.集合名.find({条件}).count() 命令：db.集合名.count({条件})
使用示例：
db.stu.find({gender:true}).count()
db.stu.count({age:{$gt:20},gender:true})
消除重复
方法 distinct() 对数据进行去重
命令：db.集合名.distinct(‘去重字段’，{条件})

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

保存：（用的应该比较少，我是没怎么用过）

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

更新：(只适用于$操作符)
命令：db.集合名.update(,,{multi:})

参数query：查询条件
参数update：更新操作符
参数multi：可选，默认是false，表示只更新找到的第一条记录，值为true表示把满足条件的文档全部更新
使用方式：

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

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

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

五、mongodb的聚合
MongoDB中聚合(aggregate)主要用于处理数据(诸如统计平均值,求和等)，并返回计算后的数据结果。有点类似sql语句中的 count(*)。
我写的可能有点不清楚具体可以感兴趣的可以查看：https://www.runoob.com/mongodb/mongodb-aggregate.html
这里的介绍和使用

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

常用管道命令
在mongodb中，文档处理完毕之后，通过管道进行下一次处理常用管道命令如下

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

常用表达式
表达式：处理输入文档并输出语法，表达式：" $列名 " 常用（$ 和sum之间没有空格的这个编辑器的问题不空格就输出错误）
$ sum：计算总和，$sum:1表示以一倍计数
$avg：计算平均值
$min：获取最⼩值
$max：获取最大值
$push：在结果⽂档中插⼊值到⼀个数组中

管道命令之$group

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

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

注意点：

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

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

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

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

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

示例：
1. 统计不同性别的学生
 db.stu.aggregate(
     {$group:
         {
             _id:null,
             name:{$push:"$name"}
         }
     }
 )
 
2. 使用$$ROOT可以将整个文档放入数组中
db.stu.aggregate(
    {$group:
        {
            _id:null,
            name:{$push:"$$ROOT"}
        }
    }
)

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

示例：
1. 查询年龄大于20的学生
db.stu.aggregate(
    {$match:{age:{$gt:20}}
    )
    
2. 查询年龄大于20的男女学生的人数
db.stu.aggregate(
    {$match:{age:{$gt:20}}
    {$group:{_id:"$gender",counter:{$sum:1}}}
    )

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

示例：
1. 查询学生的年龄、姓名，仅输出年龄姓名
db.stu.aggregate(
     {$project:{_id:0,name:1,age:1}}
     )

2. 查询男女生人生，输出人数
db.stu.aggregate(
    {$group:{_id:"$gender",counter:{$sum:1}}}
    {$project:{_id:0,counter:1}}
    )

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

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

2. 查询男女人数，按照人数降序
db.stu.aggregate(
     {$group:{_id:"$gender",counter:{$sum:1}}},
     {$sort:{counter:-1}}
 )

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

示例：
1. 查询2条学生信息
db.stu.aggregate(
     {$limit:2}
 )

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

3. 统计男女生人数，按照人数升序，返回第二条数据
db.stu.aggregate(
     {$group:{_id:"$gender",counter:{$sum:1}}},
     {$sort:{counter:-1}},
     {$skip:1},
     {$limit:1}
 )

六、mongodb的索引

mongodb的索引（看：“如果有人问你数据库”这篇文章）
加快查询速度
进行数据去重

语法：
db.集合.ensureIndex({属性:1})，1表示升序， -1表示降序
db.集合.createIndex({属性:1})
上面两个命令效果等价
具体操作：db.db_name.ensureIndex({name:1})
测试：
1).插入10万条数据到数据库中插入数据：
for(i=0;i<100000;i++){db.t1.insert({name:‘test’+i,age:i})}
2).创建索引前：
db.t1.find({name:‘test10000’})
db.t1.find({name:‘test10000’}).explain(‘executionStats’) # 这句是查看查询数据的时间
3).创建索引后：
db.t255.ensureIndex({name:1})
db.t1.find({name:‘test10000’}).explain(‘executionStats’)# 这句是查看查询数据的时间
找到：executionTimeMillis 的值来查看运行时间
，会发现加上索引之后会快很多
索引的查看

默认情况下_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"
    }
]

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 }"
    }
})

删除索引
语法：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"
    }
]

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

例如：抓全贴吧信息，如果把帖子的名字作为唯一索引对数据进行去重是不可取的，因为可能有很多帖子名字相同
建立复合索引的语法：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需要升序的方式排序输出，字段2需要降序的方式排序输出，那么此时复合索引的建立需要把字段1设置为1，字段2设置为-1

七、mongodb的备份和恢复

备份
备份的语法：mongodump -h dbhost -d dbname -o dbdirectory
-h：服务器地址，也可以指定端⼝号
-d：需要备份的数据库名称
-o：备份的数据存放位置，此⽬录中存放着备份出来的数据

示例：mongodump -h 192.168.196.128:27017 -d test1 -o ~/Desktop/test1bak

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

示例：mongorestore -h 192.168.196.128:27017 -d test2 --dir ~/Desktop/test1bak/test1

八、权限管理

在那个数据库上创建的权限就需要在那个数据库上进行登陆认证

创建超级用户

进入monogo shell
sudo shell
使用admin数据库(超级管理员账号必须创建在改数据库中)（一定要是admin这个数据库）
use admin
创建超级用户(用户名：python，密码：python)
db.createUser({“user”:“python”,“pwd”:“python”,“roles”:[“root”]})
创建成功会显示如下信息
Successfully addeduser:{“user”:“python”,“roles”:[“root”]}
退出mongo shell
exit

可以以权限认证方式启动mongo数据库
sudo mongod --auth

创建普通用户
use test1

1.创建用户
db.createUser(“user”:“usre1”,“pwd”:“pwd1”,roles:[“read”])
创建普通用户user1，该用户在test1上的权限是只读
db.createUser(“user”:“user1”,“pwd”:“pwd1”,roles:[“readwrite”])
创建普通用户user1，该用户在test1上的权限是读写

为了方便统一管理所以可以：
统一管理所有用户：在admin上创建所有用户的权限

在admin用户数据库上创建普通用户
use admin
db.createUser({"user":"python1","pwd":"python1",roles:[{"role":"read","db":"dbname1"},{"role":"radewrite"，"db":"dbname1"}]})
在admin上创建python1用户，python1用户的权限有两个，一个在dbname1上的只读，另一个是在dbname2上的读写

九、与python交互

pymongo模块
安装：pip install pymongo

我是在pycharm中使用的

使用：

1. 无需权限认证的方式创建连接对象以及集合操作对象
from pymongo import MongoClient
client = MongoClient(host,port) # 如果连接是本地host port参数可以省略
collenction = client[db名][集合名]
# collection = client.db名.集合名

2. 需要权限认证的方式创建链接对象以及集合操作对象
from pymongo import MongoClient

# 创建数据库连接
client = MongoClient('127.0.0.1',27017)
# 选择数据库
db = client['admin']
# 权限认证result = col.find()
# print(result) # 获取的是游标对象
# for data in result:
#     print(data)
db.authenticate('python','python')

# 选择集合
# col = client['数据库']['数据库中的集合']
col = client['python34']['normal_col']

# 查找数据
data = col.find_one() # 查找一条
print(data)

result = col.find()
print(result) # 获取的是游标对象
for data in result:
    print(data)


# 插入数据
col.insert({"name":"yang","age":"18"})

result = col.find()
print(result) # 获取的是游标对象
for data in result:
    print(data)

十、使用pymongo命令（增删改查）

1.添加一条数据

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

2.添加多条数据

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

3.查找一条数据

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

4.查找全部数据

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

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

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

6.更行全部数据

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

7.删除一条数据

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

8.删除全部数据

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

一个简单的小示例：

from pymongo import MongoClient

class TestMongo:
    def __init__(self):
        client = MongoClient(host="127.0.0.1",port=27017)
        self.collection = client["test"]["t1"] # --> 使用方括号的方式选择数据库和集合

    def test_insert(self):
        # insert 接收字典，返回objectID
        ret = self.collection.insert({"name":"test10010","age":"33"})
        print(ret)

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

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

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

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

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

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

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

数据库整体总结：
（没有写命令注释）

1. 数据库操作
    db # 查看当前所在的库
    show dbs #查看所有的数据库
    use db  # 跳转到某个数据库
    db.dropDatabase()  # 删除当前数据库

集合操作

    show collections
    db.colname.insert({}/[{},{}])
    db.createCollection("normal")
    db.createCollection("normal",{capped:true,size:n}) n默认为256,若n小于256则设置为256
    db.colname.drop()

增删改查操作

 1.查询
    db.col.find()
 2.插入
    db.col.insert({}/[{},{}])

高级查询操作

1.查询多个
    find().pretty()
    
2.查询一个
    findOne()
    
3.比较运算
      $lt
      $lte
      db.col.find({age:{$lt:18}})
      
4.逻辑运算
      $and
        db.col.find({$and:[{},{}])
        db.col.find({key1:value,key2:value2})
      $or
        db.col.find({$or:[{},{}])
        
5.范围运算
      $in
        db.col.find({key:{$in:[]}})
      $nin
        db.col.find({key:{$nin:[]}})
        
6.正则运算
      $regex
      db.col.find({key:{$regex:"正则"}})
      数据必须为字符串类型

7.自定义查询
      $where
      db.col.find({$where:function(){return this.age * 1000==18*1000}})

查询结果的操作

    # 跳过指定数量的数据
      skip(n)
    # 返回指定条数的结果
      limit(n)
    # 投影
      db.col.find({query},{name:1})
    # 排序
      sort({key:1,key1:-1})
    # 统计
      db.col.count({query})
    # 去重
      db.col.distinct(key,{query})

索引


db.colname.ensureIndex({name:1})      创建索引
db.colname.dropIndex({key:1})         删除索引
db.colname.getIndexes()               获取索引
db.colname.find().explain()

权限管理

在那个数据库上创建管理员用户，就在那个数据库上认证登录
use admin
db.createUser({user:"python",pwd:"python",roles:["root"]})
use db
db.createUser({user:"python19",pwd:"python19",roles:["readWrite"]})
use admin
db.createUser({user:"python",pwd:"python",roles:[{role:'read',db:"db1"},{role:'readWrite',db:"db2"}]})

pymongo


from pymongo import MongoClient
cli = MongoClient("127.0.0.1",27017)
db = cli.db

数据库认证
db.authenticate("","")
print(dir(db))
col = db.col

长安白猫

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
python mongodb数据库的基础教程

Mongodb 数据库一、优势：（集合，去重）易扩展：数据之间无关系大数据量，高性能：数据库的结构简单，非关系性灵活的数据模型：无需事先为要存的数据建立字段，随时可以储存自定义的数据格式，二、安装这个安装时基于Ubuntu虚拟机的安装（虚拟机16.04）5. 命令安装：安装：sudo apt-get install mongodb 或 sudo apt-get install ...
复制链接

扫一扫

专栏目录