一、NoSQL简介
- NoSQL，全名为Not Only SQL，指的是非关系型的数据库
- 随着访问量的上升，网站的数据库性能出现了问题，于是nosql被设计出来
1. 优点/缺点
1.1 优点
1）高可扩展性
2）分布式计算
3）低成本
4）架构的灵活性，半结构化数据
5）没有复杂的关系
1.2 缺点
1）没有标准化
2）有限的查询功能（到目前为止）
3）最终一致是不直观的程序
2. 分类
四大分类
类型 | 部分代表 | 特点 |
列存储 | Hbase Cassandra Hypertable | 顾名思义，是按列存储数据的。最大的特点是方便存储结构化和半结构化数据，方便做数据压缩，对针对某一列或者某几列的查询有非常大的IO优势。 |
文档存储 | MongoDB CouchDB | 文档存储一般用类似json的格式存储，存储的内容是文档型的。这样也就有有机会对某些字段建立索引，实现关系数据库的某些功能。 |
key-value存储 | Tokyo Cabinet / Tyrant Berkeley DB MemcacheDB Redis | 可以通过key快速查询到其value。一般来说，存储不管value的格式，照单全收。（Redis包含了其他功能） |
图存储 | Neo4J FlockDB | 图形关系的最佳存储。使用传统关系数据库来解决的话性能低下，而且设计使用不方便。 |
对象存储 | db4o Versant | 通过类似面向对象语言的语法操作数据库，通过对象的方式存取数据。 |
xml数据库 | Berkeley DB XML BaseX | 高效的存储XML数据，并支持XML的内部查询语法，比如XQuery,Xpath。 |
二、MongoDB简介
官方网站：https://www.mongodb.com/
1）MongoDB 是一个基于分布式,文件存储的NoSQL数据库。
2）由C++语言编写，运行稳定，性能高，旨在为 WEB 应用提供可扩展的高性能数据存储解决方案。
3）MongoDB是为快速开发互联网web应用而设计的数据库系统。
4）MongoDB的设计目标是极简单、灵活、作为Web应用栈的一部分。
5）MongoDB的数据模型是面向文档的，所谓文档是一种类似JSON的结构，简单理解MongoDB这个数据库中存在的是各种各样的Json.
6）MongoDB 是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。
1. MongoDB特点
- 模式自由 :可以把不同结构的文档存储在同一个数据库里
- 面向集合的存储：适合存储 JSON风格文件的形式
- 完整的索引支持：对任何属性可索引
- 复制和高可用性：支持服务器之间的数据复制，支持主-从模式及服务器之间的相互复制。复制的主要目的是提供冗余及自动故障转移
- 自动分片：支持云级别的伸缩性：自动分片功能支持水平的数据库集群，可动态添加额外的机器
- 丰富的查询：支持丰富的查询表达方式，查询指令使用JSON形式的标记，可轻易查询文档中的内嵌的对象及数组
- 快速就地更新：查询优化器会分析查询表达式，并生成一个高效的查询计划
- 高效的传统存储方式：支持二进制数据及大型对象（如照片或图片）
2. 基本概念
MongoDB将数据存储为一个文档，数据结构由键值(key=>value)对 组成。
MongoDB文档类似于JSON对象，字段值可以包含其他文档、数组、文档数组。
主要内容：
安装管理mongodb环境
完成数据库、集合的管理
数据的增加、修改、删除、查询
和MongoDB与python交互
2.1 SQL和MongoDB术语/概名词对比
SQL术语/概念 | MongoDB术语/概念 | 解释/说明 |
database | database | 数据库 |
table | collection | 数据库表/集合 |
row | document | 数据记录行/文档 |
column | field | 数据字段/域 |
index | index | 索引 |
table joins |
| 表连接,MongoDB不支持 |
primary key | primary key | 主键,MongoDB自动将_id字段设置为主键 |
2.2 MongoDB的三元素
2.2.1 数据库(database)
数据库是一个仓库，在仓库中可以存放集合。
是一个集合的物理容器，一个数据库中可以包含多个文档.
一个服务器通常有多个数据库,一般一个项目一个数据库.
2.2.2 集合(collection)
类似于python的列表，在集合中可以存放文档；集合就是关系数 据库中的表。
集合：类似于关系数据库中的表，储存多个文档，结构不固定，如可以存储如下文档在一个集合中
{'name':'guojing','gender':'男'}
{'name':'huangrong','age':18}
{'book':'shuihuzhuan','heros':'108'}
2.2.3 文档(document)
就是一个对象，由键值对构成，是json的扩展Bson形式，是数据库中最小单位。文档对应着关系数据库表中的行
{'name':'guojing','gender':'男'}
2.2 分布式
分布式：一个业务分拆多个子业务，部署在不同的服务器上。
集群：同一个业务，部署在多个服务器上。
例如：小饭店原来只有一个厨师，切菜洗菜备料炒菜全干。后来客人多了，厨房一个厨师忙不过来，又请了个厨师，两个厨师都能炒一样的菜，这两个厨师的关系是集群。为了让厨师专心炒菜，把菜做到极致，又请了个配菜师负责切菜，备菜，备料，厨师和配菜师的关系是分布式，一个配菜师也忙不过来了，又请了个配菜师，两个配菜师关系是集群。
集群是个物理形态，分布式是个工作方式。
只要是一堆机器，就可以叫集群，他们是不是一起协作着干活，这个谁也不知道；一个程序或系统，只要运行在不同的机器上，就可以叫分布式，嗯，C/S架构也可以叫分布式。
集群一般是物理集中、统一管理的，而分布式系统则不强调这一点。
所以，集群可能运行着一个或多个分布式系统，也可能根本没有运行分布式系统；分布式系统可能运行在一个集群上，也可能运行在不属于一个集群的多台（2台也算多台）机器上。
解释下单机结构、集群结构、分布式结构三种结构的区别
单机结构
我想大家最最最熟悉的就是单机结构，一个系统业务量很小的时候所有的代码都放在一个项目中就好了，然后这个项目部署在一台服务器上就好了。整个项目所有的服务都由这台服务器提供。这就是单机结构。
那么，单机结构有啥缺点呢？我想缺点是显而易见的，单机的处理能力毕竟是有限的，当你的业务增长到一定程度的时候，单机的硬件资源将无法满足你的业务需求。此时便出现了集群模式，往下接着看。
集群结构
集群模式在程序猿界有各种装逼解释，有的让你根本无法理解，其实就是一个很简单的玩意儿，且听我一一道来。
单机处理到达瓶颈的时候，你就把单机复制几份，这样就构成了一个“集群”。集群中每台服务器就叫做这个集群的一个“节点”，所有节点构成了一个集群。每个节点都提供相同的服务，那么这样系统的处理能力就相当于提升了好几倍（有几个节点就相当于提升了这么多倍）。
但问题是用户的请求究竟由哪个节点来处理呢？最好能够让此时此刻负载较小的节点来处理，这样使得每个节点的压力都比较平均。要实现这个功能，就需要在所有节点之前增加一个“调度者”的角色，用户的所有请求都先交给它，然后它根据当前所有节点的负载情况，决定将这个请求交给哪个节点处理。这个“调度者”有个牛逼了名字——负载均衡服务器。
集群结构的好处就是系统扩展非常容易。如果随着你们系统业务的发展，当前的系统又支撑不住了，那么给这个集群再增加节点就行了。但是，当你的业务发展到一定程度的时候，你会发现一个问题——无论怎么增加节点，貌似整个集群性能的提升效果并不明显了。这时候，你就需要使用微服务结构了。
分布式结构
先来对前面的知识点做个总结。
从单机结构到集群结构，你的代码基本无需要作任何修改，你要做的仅仅是多部署几台服务器，每台服务器上运行相同的代码就行了。但是，当你要从集群结构演进到微服务结构的时候，之前的那套代码就需要发生较大的改动了。所以对于新系统我们建议，系统设计之初就采用微服务架构，这样后期运维的成本更低。但如果一套老系统需要升级成微服务结构的话，那就得对代码大动干戈了。所以，对于老系统而言，究竟是继续保持集群模式，还是升级成微服务架构，这需要你们的架构师深思熟虑、权衡投入产出比。
OK，下面开始介绍所谓的分布式结构。
分布式结构就是将一个完整的系统，按照业务功能，拆分成一个个独立的子系统，在分布式结构中，每个子系统就被称为“服务”。这些子系统能够独立运行在web容器中，它们之间通过RPC（远程过程调用）方式通信。
举个例子，假设需要开发一个在线商城。按照微服务的思想，我们需要按照功能模块拆分成多个独立的服务，如：用户服务、产品服务、订单服务、后台管理服务、数据分析服务等等。这一个个服务都是一个个独立的项目，可以独立运行。如果服务之间有依赖关系，那么通过RPC（远程过程调用）方式调用。
这样的好处有很多：
系统之间的耦合度大大降低，可以独立开发、独立部署、独立测试，系统与系统之间的边界非常明确，排错也变得相当容易，开发效率大大提升。
系统之间的耦合度降低，从而系统更易于扩展。我们可以针对性地扩展某些服务。假设这个商城要搞一次大促，下单量可能会大大提升，因此我们可以针对性地提升订单系统、产品系统的节点数量，而对于后台管理系统、数据分析系统而言，节点数量维持原有水平即可。
服务的复用性更高。比如，当我们将用户系统作为单独的服务后，该公司所有的产品都可以使用该系统作为用户系统，无需重复开发。
三、环境安装
请参照专门的写好的文档
- 安装
1.1 下载
下载地址：
下载mongodb的版本，两点注意
1）根据业界规则，偶数为稳定版，如1.6.X，奇数为开发版，如1.7.X
2）32bit的mongodb最大只能存放2G的数据，系统支持不好，64bit就没有限制。
1.2 解压安装
到官网，选择合适的版本下载解压
tar -zxvf mongodb-linux-x86_64-ubuntu1604-3.4.0.tgz
移动到/usr/local/目录下
sudo mv mongodb-linux-x86_64-ubuntu1604-3.4.0/ /usr/local/mongodb/
将可执行文件添加到PATH路径中
export PATH=/usr/local/mongodb/bin:$PATH
2. mongodb服务端
2.1 启动mongodb服务简写命令
默认会随机分配一个端口号：2275下次有可能是另外一个数
sudo /usr/local/mongodb/bin/mongod --config /etc/mongodb.conf |
2.2 配置文件在/etc/mongod.conf
在mongod.conf文件配置默认端口27017
打开配置文件命令： sudo subl /etc/mongod.conf
默认端口27017
# mongod.conf
# for documentation of all options, see:
# http://docs.mongodb.org/manual/reference/configuration-options/
# Where and how to store data.
storage:
dbPath: /var/lib/mongodb
journal:
enabled: true
# engine:
# mmapv1:
# wiredTiger:
# where to write logging data.
systemLog:
destination: file
logAppend: true
path: /var/log/mongodb/mongod.log
# network interfaces
net:
port: 27017
bind_ip: 0.0.0.0
#processManagement:
#security:
#operationProfiling:
#replication:
#sharding:
## Enterprise-Only Options:
#auditLog:
#snmp:2.3 查询状态命令查询状态
sudo systemctl status mongodb
2.4 启动mongodb服务端
sudo systemctl start mongodb
或者
sudo service mongodb start
2.5 停止mongodb服务端
sudo systemctl stop mongodb
或者
sudo service mongodb stop
2.6 重新启动
sudo systemctl restart mongodb
或者
sudo service mongodb restart
3. Mongodb客户端mongo
注意使用前mongo，先要开启服务器
使用终端连接，这个shell就是mongodb的客户端，同时也是一个js的编译器。
3.1 使用mongo进入客户端
命令：mongo
3.2 查看当前数据库名称命令
db查看当前数据库名称
db.stats()查看当前数据库信息
3.3 终端退出连接
exit
或
ctrl+c
- robomongo可视化工具
robomongo，解压后在bin目录下找到robomongo点击运行程序
界面如下：
弹出下面界面
四、数据库操作
1. 查看所有数据库名称
列出所有在物理上存在的数据库
show dbs
如图：
2. 数据库切换（选择）
- 切换数据库
use test
- 切换数据库
- 如果数据库不存在，则指向数据库，但不创建，直到插入数据或创建集合时数据库才被创建
use 数据库名称
注意：默认的数据库为test，如果你没有创建新的数据库，集合将存放在test数据库中
3. 查看当前数据库名称
db
如图：
4 创建数据库
创建py3数据库：use py3
注意：当创建集合后数据库才出现
5. 数据库删除
删除当前指向的数据库，如果数据库不存在，则什么也不做。
db.dropDatabase()
如图：
五、集合(表)操作
1. 集合创建
1.1 语法
在某个数据库里面创建集合
db.createCollection(name, options)
- name是要创建的集合的名称
- options是一个文档，用于指定集合的配置
- 选项参数是可选的，所以只需要到指定的集合名称。以下是可以使用的选项列表：
1.2 不限制集合大小
db.createCollection("stu")
如图：
2. 查看当前数据库的集合
- 语法
show collections
3. 删除集合
- 语法
db.集合名称.drop()
删除成功返回true,如果再删除返回false
六、数据类型
1. 数据类型
- 下表为MongoDB中常用的几种数据类型：
- Object ID：文档ID，一般系统维护，自己也可以维护
- String：字符串，最常用，必须是有效的UTF-8
- Boolean：存储一个布尔值，true或false
- Integer：整数可以是32位或64位，这取决于服务器
- Double：存储浮点值
- Arrays：数组或列表，多个值存储到一个键
- Object：用于嵌入式的文档，即一个值为一个文档
- Null：存储Null值
- Timestamp：时间戳
- Date：存储当前日期或时间的UNIX时间格式
2. object id
- 每个文档都有一个属性，为_id，保证每个文档的唯一性
- 可以自己去设置_id插入文档
- 如果没有提供，那么MongoDB为每个文档提供了一个独特的_id，类型为objectID
- objectID是一个12字节的十六进制数
- 前4个字节为当前时间戳
- 接下来3个字节的机器ID
- 接下来的2个字节中MongoDB的服务进程id
- 最后3个字节是简单的增量值
七、数据基本操作
1. 插入
1.1 语法
db.集合名称.insert(document)
- 插入文档时，如果不指定_id参数，MongoDB会为文档分配一个唯一的ObjectId
1.2 案例
1.2.1 例1 默认分配一个唯一的ObjectId
db.stu.insert({name:'gj',gender:1})
注意key可以不加双引号，但是值要加上双引号或者单引号
如图：
1.2.2 例2也可以自己指定id
s1={_id:'20160101',name:'hr'}
s1.gender=0
db.stu.insert(s1)
如图：
2. 简单查询
2.1 语法
db.集合名称.find()
或者
db.集合名称.find({})
2.2 案例
如图：
3. 更新
3.1 语法
db.集合名称.update(
<query>,
<update>,
{
upsert: <boolean>,
multi: <boolean>
}
)- 参数query:查询条件，类似sql语句update中where部分
- 参数update:更新操作符，类似sql语句update中set部分
- 参数upsert : 可选，这个参数的意思是，如果不存在update的记录，是否插入objNew,true为插入，默认是false，不插入。
- 参数multi:可选，默认是false，表示只更新找到的第一条记录，值为true表示把满足条件的文档全部更新
3.2 案例
3.2.1 例1：默认值更新一条数据，并且结构被修改
db.stu.update({},{name:'mnc'})
3.2.2 例2：默认值更新一条数据，只修改字段，不破坏数据
db.stu.update({},{$set:{name:'mnc'}})如图
3.2.3 例3：全文档找更新找到的第一条，把{name:'hr'}对应的这条修改成{name:'mnc'}，其他字段全部丢掉
如果有两条满足，会找到并且只更新的第一条，数据结构被破坏。
db.stu.update({name:'hr'},{name:'mnc'})如图：
3.2.4 例4：指定属性更新，通过操作符$set
数据结构不会被破坏，也是只修改一条
db.stu.insert({name:'hr',gender:0})
db.stu.update({name:'hr'},{$set:{name:'hys'}})如图：
3.2.2 例5：修改多条匹配到的数据
多条操作一定要配合$set，否则会报错
db.stu.update({},{$set:{gender:0}},{multi:true})如图：
3.2.3 例6：把所有name是hr修改成gj
db.stu.update({name:'hr'},{$set:{name:'gj'}},{multi:true})
4. 保存
4.1 语法
语法
db.集合名称.save(document)
如果文档的_id已经存在则修改，如果文档的_id不存在则添加
注意，如果_id写成是id，则会把id当成key
4.2 案例
4.2.1 例1
db.stu.save({_id:'20160102','name':'yk',gender:1})4.2.2 例2
db.stu.save({_id:'20160102','name':'wyk'})
4.3 save和insert函数的区别
相同点：
save和insert函数都可以向collection里插入数据。
区别：
一、使用save()函数，如果原来的对象不存在，那他们都可以向collection里插入数据，如果已经存在，save会调用update更新里面的记录，而insert则会忽略操作，并且提示报错。
二、insert可以一次性插入一个列表，而不用遍历，效率高， save则需要遍历列表，一个个插入。
5. 删除
5.1 语法
db.集合名称.remove(
<query>,
{
justOne: <boolean>
}
)- 参数query:可选，删除的文档的条件
- 参数justOne:可选，如果设为true或1，则只删除一条，默认false，表示删除多条
5.2 案例
5.2.1 例1：只删除匹配到的第一条
db.stu.remove({gender:0},{justOne:true})
5.2.2 例2：全部删除
没有写条件就是全部删除
db.stu.remove({})
6. 关于max的示例
6.1 创建一个名为sub的定长集合，长度为5个字节，可容纳的文档数为3
db.createCollection('sub',{capped:true,size:5,max:3})在robomongo工具中和pymongo模块中：
capped:封顶，结合size,max:3就是当第3条数据时,再插入数据覆盖之前插入的第1条数据给覆盖了，也就是说最多数据不能超过3条，也就是说数据只能存放3条。
注意在命令行中，会插入不进去，不会覆盖。
使用Robomongo执行命令，还有提示
- 插入第一条数据库查询
db.sub.insert({title:'linux',count:10})
db.sub.find()如图：
查询并且不同方式显示
- 插入第二条数据库查询
db.sub.insert({title:'python',count:20})
db.sub.find()如图：
- 插入第三条数据库查询
db.sub.insert({title:'sql',count:8})
db.sub.find()- 插入第四条数据库查询
db.sub.insert({title:'django',count:12})
db.sub.find()- 插入第五条数据库查询
db.sub.insert({title:'web',count:14})
db.sub.find()
6.2 注意点
在robomongo工具中和pymongo模块中：
capped:封顶，结合size,max:3就是当第3条数据时,再插入数据覆盖之前插入的第1条数据给覆盖了，也就是说最多数据不能超过3条，也就是说数据只能存放3条。
注意在命令行中，会插入不进去，不会覆盖
6.3 优点及使用场景
优点：
1：对固定集合进行插入速度极快
2：按照插入顺序的查询输出速度极快。
3：能够在插入最新数据时，淘汰最早的数据。
使用场景：
1：储存日志信息。
2：缓存一些少量的文档
- 数据查询
1 准备数据
1.1 插入下面数据
db.sub.insert({title:"sql",count:8})
db.sub.insert({title:"django",count:12})
db.sub.insert({title:"web",count:14})
db.sub.insert({title:"linx",count:2})
db.sub.insert({title:"redis",count:1})
db.sub.insert({title:"scrapy",count:11})
db.sub.insert({title:"mongodb",count:1})1.2 查看准备好的数据
2. 基本查询
2.1 语法
- 方法find()：查询
db.集合名称.find({条件文档})
- 方法findOne()：查询，只返回第一个文档
db.集合名称.findOne({条件文档})
- 方法pretty()：将结果格式化
db.集合名称.find({条件文档}).pretty()
2.2 示例
2.2.1 方法find()：查询
db.sub.find({})
2.2.2 方法findOne()：查询，只返回第一个文档
db.集合名称.findOne({条件文档})
db.sub.findOne()如图：
2.2.3 方法pretty()：将结果格式化
方法pretty()：将结果格式化，这个在mongo请求下有用，目的是为了更好的呈现数据
db.集合名称.find({条件文档}).pretty()
格式化后的数据
加上条件的案例
查看标题是web的数据
3. 比较运算符
3.1 语法说明
- 等于，默认是等于判断，没有运算符
- 小于$lt
- 小于或等于$lte
- 大于$gt
- 大于或等于$gte
- 不等于$ne
说明：
计算机术语里面是 less than，意思是小于，缩写是lt
对应 greater than，意思是大于，缩写是gt ；
对应equal ,意思是等于，缩写e;
对应 Not equal to，意思是不等于，缩写ne;
3.2 示例
3.2.1 例1：查询标题等于'sql'的学科
db.sub.find({title:'sql'})
3.2.2 例2：查询课时大于或等于2的学科
db.sub.find({count:{$gte:2}})如图：
使用默认终端查询
3.2.3 查找标题不是mongo的学科
db.sub.find({title:{$ne:'mongodb'}})
4. 逻辑运算符
4.1 语法
- 查询时可以有多个条件，多个条件之间需要通过逻辑运算符连接
- 逻辑与：默认是逻辑与的关系，多个条件直接用逗号连接
- 逻辑或：使用$or
- and和or一起使用
4.2 案例
4.2.1 逻辑与
默认是逻辑与的关系，多个条件直接用逗号连接
- 例3：查询课时大于或等于10，并且标题为web的学科
db.sub.find({count:{$gte:10},title:"web"})
4.2.2 逻辑或：使用$or
- 逻辑或：使用$or
- 例4：查询课时大于10，或标题为web的学科
db.sub.find({$or:[{count:{$gt:10}},{title:'web'}]})如图：
4.2.3 and和or一起使用
- and和or一起使用
- 例5：查询课时大于10或标题为web的学科，并且学科的课时为14
db.sub.find({$or:[{count:{$gte:10}},{title:'web'}],count:14})如图：
5. 范围运算符--"$in"
5.1 语法
- 使用"$in"，"$nin" 判断是否在某个范围内
5.2 案例
5.2.1 例6：查询课时为8、14的学科
db.sub.find({count:{$in:[8,14]}})如图：
6. Limit与Skip
6.1 limit
- 方法limit()：用于读取指定数量的文档
7.1.1 语法
db.集合名称.find().limit(NUMBER)
- 参数NUMBER表示要获取文档的条数
- 如果没有指定参数或者0则显示集合中的所有文档
7.1.2 案例
- 例1：查询2条学生信息
db.stu.find().limit(2)
6.2 skip
- 方法skip()：用于跳过指定数量的文档
- 语法：
db.集合名称.find().skip(NUMBER)
- 参数NUMBER表示跳过的记录条数，默认值为0
6.2.1 例2：查询从第3条开始的学生信息
db.stu.find().skip(2)
6.2 limit()和skip()一起使用
- 方法limit()和skip()可以一起使用，不分先后顺序
6.2.1 案例1 从第二条开始，并且只要三条
db.sub.find().skip(2).limit(3)
6.2.2 创建数据集
for(i=0;i<10;i++){db.stu.insert({_id:i,name:'name_'+i})}6.2.3 查询第5至8条数据
db.stu.find().limit(4).skip(5)
或
db.stu.find().skip(5).limit(4)
九、MongoDB与python交互
- 点击查看官方文档
- http://api.mongodb.com/python/current/tutorial.html
1. 安装pymongo包
sudo pip3 install pymongo
Python2中安装
sudo pip install pymongo
Python3中安装
或源码安装
python setup.py
2. 准备操作数据
2.1 引入包pymongo
from pymongo import MongoClient
2.2 连接，创建客户端
#无安全认证：
client = MongoClient('localhost', 27017)
client = MongoClient('mongodb://localhost:27017/数据库名称')
client = MongoClient('mongodb://localhost:27017/test1')
#有安全认证：
client = MongoClient('mongodb://用户名:密码@localhost:27017/数据库名称')
client = MongoClient('mongodb://t1:123@localhost:27017/test1')类database
2.3 获得名字叫test1数据库
db=client.test1
或者
db=client['test1']2.4 类collection
主要方法如下：
- insert_one
- insert_many
- update_one
- update_many
- delete_one
- delete_many
- find_one
- find
2.5 获得名字叫t1的集合
t1 = db.t1
或者
t1 = db['t1']3. 基本操作
3.1 添加一个文档
实例代码
s1={name:'郭靖',age:18}
s1_id = t1.insert_one(s1)代码如下图：
下面是代码
from pymongo import MongoClient
client = MongoClient("mongodb://localhost:27017/test1")
#得到名字叫test1的数据库
# test1 = client.test1
test1 = client['test1']
#得到名字叫t1的集合
# t1 = test1.t1
t1 = test1['t1']
#要插入的数据
s1 = {"name":"郭靖","age":18}
s = t1.insert_one(s1)
print(s)
查看插入的效果
3.2 修改一个文档
实例代码-把郭靖修改成黄蓉
#把郭靖修改成黄蓉
from pymongo import MongoClient
client = MongoClient("mongodb://192.168.31.114:27017/test1")
#得到名字叫test1的数据库
# test1 = client.test1
test1 = client['test1']
#得到名字叫t1的集合
# t1 = test1.t1
t1 = test1['t1']#修改一条数据
s = t1.update_one({"name":"郭靖"},{"$set":{"name":"黄蓉"}})
print(s)查看效果
3.3 删除一个文档
准备数据
实例代码
from pymongo import MongoClient
client = MongoClient("mongodb://192.168.31.114:27017/test1")
#得到名字叫test1的数据库
# test1 = client.test1
test1 = client['test1']
#得到名字叫t1的集合
# t1 = test1.t1
t1 = test1['t1']
#删除一个文档
#删除名字为'黄药师'的文档
s1 = t1.delete_one({'name':'黄药师'})
print(s1)
查看效果
3.4 删除多个文档
准备数据：
#得到名字叫t1的集合
# t1 = test1.t1
t1 = test1['t1']
docments = [{"name":"黄药师"},{"name":"黄药师"},{"name":"黄药师"}]
#插入多条数据
t1.insert_many(docments)
运行结果：
实例代码
#删除多个文档
#删除名字为'黄药师'的所以文档
test1 = client['test1']
#得到名字叫t1的集合
t1 = test1.t1
#删除多个文档
#删除名字为'黄药师'的所以文档
s1 = t1.delete_many({'name':'黄药师'})
print(s1)运行结果：
查看效果
4. 查询
4.1 查找一个文档
实例代码
#得到名字叫test1的数据库
# test1 = client.test1
test1 = client['test1']
#得到名字叫t1的集合
# t1 = test1.t1
t1 = test1['t1']
#查找一条数据
s1 = t1.find_one({'name':'黄蓉'})
print(s1)如果是t1.find_one()默认返回第1条数据
运行结果:
4.2 查找多个文档1
#查找所有数据
s1 = t1.find()
print(s1)
for cur in s1:
print(cur)运行结果：
4.3 查找多个文档2
s1 = t1.find()
print(s1.next())
print(s1.next())运行结果：
4.4 查找多个文档3
4.4.1 先准备数据-插入多个文档
插入多个文档语句
说明：插入多个文档使用insert_many
t1.insert_many([{'name':'黄蓉它妹妹','age':16},
{'name':'黄药师','age':35},
{'name':'郭靖','age':20},
{'name':'欧阳锋','age':36},
{'name':'杨康','age':21}
])
查看插入的数据
4.4.2 查看多个文档
代码
#查找所有数据
#查看多个文档
#并且把名字得到
cursor = t1.find()
for cur in cursor:
#name = cur['name']#这个代码如果在没有name这个key会报错
name = cur.get('name')
money = cur.get("money","一毛钱没有")
print("姓名：",name,",money：",money)运行效果：
4.5 查询年龄大于18的所有文档
4.5.1 代码和查询效果
#查询年龄大于18的所以数据
cursor = t1.find({"age":{"$gt":18}})
for cur in cursor:
#name = cur['name']#这个代码如果在没有name这个key会报错
name = cur.get('name')
money = cur.get("money","一毛钱没有")
age = cur.get("age")
print("姓名：",name,",money：",money,",age：",age)运行效果：
4.6 子集--limit()和skip()
cursor = t1.find({"age":{"$gt":18}}).skip(2).limit(2)
for cur in cursor:
#name = cur['name']#这个代码如果在没有name这个key会报错
name = cur.get('name')
money = cur.get("money","一毛钱没有")
age = cur.get("age")
print("姓名：",name,",money：",money,",age：",age)代码如图：
4.9 获取文档个数
print(t1.count())
5. 创建数据和集合
5.1 查看当前数据库
5.2 用代码创建数据库test2里面创建集合t2
主要要插入数据才看到数据库
from pymongo import MongoClient
client = MongoClient(host="192.168.31.114",port=27017)
# client = MongoClient("mongodb://192.168.31.114:27017")
#得到或者创建名字叫test2的数据库
# test2 = client.test2
test2 = client['test2']
#得到或者创建名字叫t1的集合
t2 = test2.t2
# t2 = test1['t2']
#要插入数据，数据库，表才会成功创建
s = t2.insert({"name":"afu"})
5.3 查看创建后的情况
