MongoDB API和python操作

MongoDB API和python操作
安装
- 下载mongodb的版本，两点注意
  - 根据业界规则，偶数为稳定版，如1.6.X，奇数为开发版，如1.7.X
  - 32bit的mongodb最大只能存放2G的数据，64bit就没有限制
- 到官网，选择合适的版本下载
- 解压 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
管理mongo
- 配置文件在/etc/mongod.conf
- 默认端口27017
- 启动 sudo service mongod start
- 停止 sudo service mongod stop
- 使用终端连接
- 这个shell就是mongodb的客户端，同时也是一个js的编译器 mongo
- 命令
```
db查看当前数据库名称
db.stats()查看当前数据库信息
```
- 终端退出连接
```
exit
或ctrl+c
```
- GUI：robomongo，解压后在bin目录下找到运行程序
数据库切换
- 查看当前数据库名称 --db
- 查看所有数据库名称
- 列出所有在物理上存在的数据库 --show dbs
- 切换数据库
- 如果数据库不存在，则指向数据库，但不创建，直到插入数据或创建集合时数据库才被创建 --use 数据库名称
- 默认的数据库为test，如果你没有创建新的数据库，集合将存放在test数据库中
数据库删除
- 删除当前指向的数据库
- 如果数据库不存在，则什么也不做 --db.dropDatabase()
集合创建
- 语法 --db.createCollection(name, options)
- name是要创建的集合的名称
- options是一个文档，用于指定集合的配置
- 选项参数是可选的，所以只需要到指定的集合名称。以下是可以使用的选项列表：
- 例1：不限制集合大小 --db.createCollection("stu")
- 例2：限制集合大小，后面学会插入语句后可以查看效果
- 参数capped：默认值为false表示不设置上限，值为true表示设置上限
- 参数size：当capped值为true时，需要指定此参数，表示上限大小，当文档达到上限时，会将之前的数据覆盖，单位为字节
```
db.createCollection("sub", { capped : true, size : 10 } )
```
查看当前数据库的集合
- 语法 --show collections
删除
- 语法 --db.集合名称.drop()
数据类型
- 下表为MongoDB中常用的几种数据类型：
- Object ID：文档ID
- String：字符串，最常用，必须是有效的UTF-8
- Boolean：存储一个布尔值，true或false
- Integer：整数可以是32位或64位，这取决于服务器
- Double：存储浮点值
- Arrays：数组或列表，多个值存储到一个键
- Object：用于嵌入式的文档，即一个值为一个文档
- Null：存储Null值
- Timestamp：时间戳
- Date：存储当前日期或时间的UNIX时间格式
object id
- 每个文档都有一个属性，为_id，保证每个文档的唯一性
- 可以自己去设置_id插入文档
- 如果没有提供，那么MongoDB为每个文档提供了一个独特的_id，类型为objectID
- objectID是一个12字节的十六进制数
  - 前4个字节为当前时间戳
  - 接下来3个字节的机器ID
  - 接下来的2个字节中MongoDB的服务进程id
  - 最后3个字节是简单的增量值
插入
- 语法
```
db.集合名称.insert(document)
```
- 插入文档时，如果不指定_id参数，MongoDB会为文档分配一个唯一的ObjectId
- 例1
```
db.stu.insert({name:'gj',gender:1})
```
- 例2
```
s1={_id:'20160101',name:'hr'}
s1.gender=0
db.stu.insert(s1)
```
简单查询
- 语法
```
db.集合名称.find()
```
更新
- 语法
```
db.集合名称.update(
   <query>,
   <update>,
   {multi: <boolean>}
)
```
- 参数query:查询条件，类似sql语句update中where部分
- 参数update:更新操作符，类似sql语句update中set部分
- 参数multi:可选，默认是false，表示只更新找到的第一条记录，值为true表示把满足条件的文档全部更新
- 例3：全文档更新
```
db.stu.update({name:'hr'},{name:'mnc'})
```
- 例4：指定属性更新，通过操作符$set
```
db.stu.insert({name:'hr',gender:0})
db.stu.update({name:'hr'},{$set:{name:'hys'}})
```
- 例5：修改多条匹配到的数据
```
db.stu.update({},{$set:{gender:0}},{multi:true})
```
保存
- 语法
```
db.集合名称.save(document)
```
- 如果文档的_id已经存在则修改，如果文档的_id不存在则添加
- 例6
```
db.stu.save({_id:'20160102','name':'yk',gender:1})
```
- 例7
```
db.stu.save({_id:'20160102','name':'wyk'})
```
删除
- 语法
```
db.集合名称.remove(
   <query>,
   {
     justOne: <boolean>
   }
)
```
- 参数query:可选，删除的文档的条件
- 参数justOne:可选，如果设为true或1，则只删除一条，默认false，表示删除多条
- 例8：只删除匹配到的第一条 db.stu.remove({gender:0},{justOne:true})
- 例9：全部删除 db.stu.remove({})
关于size的示例
- 例10
- 创建集合 db.createCollection('sub',{capped:true,size:10})
- 插入第一条数据库查询
```
db.sub.insert({title:'linux',count:10})
db.sub.find()
```
- 插入第二条数据库查询
```
db.sub.insert({title:'web',count:15})
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:'python',count:14})
db.sub.find()
```
数据查询

基本查询
- 方法find()：查询 db.集合名称.find({条件文档})
- 方法findOne()：查询，只返回第一个 db.集合名称.findOne({条件文档})
- 方法pretty()：将结果格式化 db.集合名称.find({条件文档}).pretty()
比较运算符
- 等于，默认是等于判断，没有运算符
- 小于$lt
- 小于或等于$lte
- 大于$gt
- 大于或等于$gte
- 不等于$ne
- 例1：查询名称等于'gj'的学生 db.stu.find({name:'gj'})
- 例2：查询年龄大于或等于18的学生 db.stu.find({age:{$gte:18}})
逻辑运算符
- 查询时可以有多个条件，多个条件之间需要通过逻辑运算符连接
- 逻辑与：默认是逻辑与的关系
- 例3：查询年龄大于或等于18，并且性别为1的学生 --db.stu.find({age:{$gte:18},gender:1})
- 逻辑或：使用$or
- 例4：查询年龄大于18，或性别为0的学生 --db.stu.find({$or:[{age:{$gt:18}},{gender:1}]})
- and和or一起使用
- 例5：查询年龄大于18或性别为0的学生，并且学生的姓名为gj ---db.stu.find({$or:[{age:{$gte:18}},{gender:1}],name:'gj'})
范围运算符
- 使用"$in"，"$nin" 判断是否在某个范围内
- 例6：查询年龄为18、28的学生 --db.stu.find({age:{$in:[18,28]}})
支持正则表达式
- 使用//或$regex编写正则表达式
- 例7：查询姓黄的学生
```
db.stu.find({name:/^黄/})
db.stu.find({name:{$regex:'^黄'}}})
```
自定义查询
- 使用$where后面写一个函数，返回满足条件的数据
- 例7：查询年龄大于30的学生 --db.stu.find({$where:function(){return this.age>20}})
Limit
- 方法limit()：用于读取指定数量的文档
- 语法： --db.集合名称.find().limit(NUMBER)
- 参数NUMBER表示要获取文档的条数
- 如果没有指定参数则显示集合中的所有文档
- 例1：查询2条学生信息 --db.stu.find().limit(2)
skip
- 方法skip()：用于跳过指定数量的文档
- 语法： db.集合名称.find().skip(NUMBER)
- 参数NUMBER表示跳过的记录条数，默认值为0
- 例2：查询从第3条开始的学生信息 db.stu.find().skip(2)
一起使用
- 方法limit()和skip()可以一起使用，不分先后顺序
- 创建数据集 --for(i=0;i<15;i++){db.t1.insert({_id:i})}
- 查询第5至8条数据
```
db.stu.find().limit(4).skip(5)
或
db.stu.find().skip(5).limit(4)
```
投影
- 在查询到的返回结果中，只选择必要的字段，而不是选择一个文档的整个字段
- 如：一个文档有5个字段，需要显示只有3个，投影其中3个字段即可
- 语法：
- 参数为字段与值，值为1表示显示，值为0不显示 db.集合名称.find({},{字段名称:1,...})
- 对于需要显示的字段，设置为1即可，不设置即为不显示
- 特殊：对于_id列默认是显示的，如果不显示需要明确设置为0
- 例1 db.stu.find({},{name:1,gender:1})
- 例2 db.stu.find({},{_id:0,name:1,gender:1})
排序
- 方法sort()，用于对结果集进行排序
- 语法 db.集合名称.find().sort({字段:1,...})
- 参数1为升序排列
- 参数-1为降序排列
- 例1：根据性别降序，再根据年龄升序 db.stu.find().sort({gender:-1,age:1})
统计个数
- 方法count()用于统计结果集中文档条数
- 语法 db.集合名称.find({条件}).count()
- 也可以与为 db.集合名称.count({条件})
- 例1：统计男生人数 db.stu.find({gender:1}).count()
- 例2：统计年龄大于20的男生人数 db.stu.count({age:{$gt:20},gender:1})
消除重复
- 方法distinct()对数据进行去重
- 语法 db.集合名称.distinct('去重字段',{条件})
- 例1:查找年龄大于18的性别（去重） db.stu.distinct('gender',{age:{$gt:18}})
聚合 aggregate
- 聚合(aggregate)主要用于计算数据，类似sql中的sum()、avg()
- 语法 db.集合名称.aggregate([{管道:{表达式}}])
管道
- 管道在Unix和Linux中一般用于将当前命令的输出结果作为下一个命令的输入 ps ajx | grep mongo
- 在mongodb中，管道具有同样的作用，文档处理完毕后，通过管道进行下一次处理
- 常用管道
  - $group：将集合中的文档分组，可用于统计结果
  - $match：过滤数据，只输出符合条件的文档
  - $project：修改输入文档的结构，如重命名、增加、删除字段、创建计算结果
  - $sort：将输入文档排序后输出
  - $limit：限制聚合管道返回的文档数
  - $skip：跳过指定数量的文档，并返回余下的文档
  - $unwind：将数组类型的字段进行拆分
表达式
- 处理输入文档并输出
- 语法 表达式:'$列名'
- 常用表达式
  - $sum：计算总和，$sum:1同count表示计数
  - $avg：计算平均值
  - $min：获取最小值
  - $max：获取最大值
  - $push：在结果文档中插入值到一个数组中
  - $first：根据资源文档的排序获取第一个文档数据
  - $last：根据资源文档的排序获取最后一个文档数据
$group
- 将集合中的文档分组，可用于统计结果
- _id表示分组的依据，使用某个字段的格式为'$字段'
- 例1：统计男生、女生的总人数
```
db.stu.aggregate([
    {$group:
        {
            _id:'$gender',
            counter:{$sum:1}
        }
    }
])
```
Group by null
- 将集合中所有文档分为一组
- 例2：求学生总人数、平均年龄
```
db.stu.aggregate([
    {$group:
        {
            _id:null,
            counter:{$sum:1},
            avgAge:{$avg:'$age'}
        }
    }
])
```
透视数据
- 例3：统计学生性别及学生姓名
```
db.stu.aggregate([
    {$group:
        {
            _id:'$gender',
            name:{$push:'$name'}
        }
    }
])
```
- 使用$$ROOT可以将文档内容加入到结果集的数组中，代码如下
```
db.stu.aggregate([
    {$group:
        {
            _id:'$gender',
            name:{$push:'$$ROOT'}
        }
    }
])
```
$match
- 用于过滤数据，只输出符合条件的文档
- 使用MongoDB的标准查询操作
- 例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
- 修改输入文档的结构，如重命名、增加、删除字段、创建计算结果
- 例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
- 将输入文档排序后输出
- 例1：查询学生信息，按年龄升序
```
b.stu.aggregate([{$sort:{age:1}}])
```
- 例2：查询男生、女生人数，按人数降序
```
db.stu.aggregate([
    {$group:{_id:'$gender',counter:{$sum:1}}},
    {$sort:{counter:-1}}
])
```
$limit
- 限制聚合管道返回的文档数
- 例1：查询2条学生信息
```
db.stu.aggregate([{$limit:2}])
```
$skip
- 跳过指定数量的文档，并返回余下的文档
- 例2：查询从第3条开始的学生信息
```
db.stu.aggregate([{$skip:2}])
```
- 例3：统计男生、女生人数，按人数升序，取第二条数据
```
db.stu.aggregate([
    {$group:{_id:'$gender',counter:{$sum:1}}},
    {$sort:{counter:1}},
    {$skip:1},
    {$limit:1}
])
```
- 注意顺序：先写skip，再写limit
$unwind
- 将文档中的某一个数组类型字段拆分成多条，每条包含数组中的一个值
语法1
- 对某字段值进行拆分
```
db.集合名称.aggregate([{$unwind:'$字段名称'}])
```
- 构造数据
```
db.t2.insert({_id:1,item:'t-shirt',size:['S','M','L']})
```
- 查询
```
db.t2.aggregate([{$unwind:'$size'}])
```
语法2
- 对某字段值进行拆分
- 处理空数组、非数组、无字段、null情况
```
db.inventory.aggregate([{
    $unwind:{
        path:'$字段名称',
        preserveNullAndEmptyArrays:<boolean>#防止数据丢失
    }
}])
```
- 构造数据
```
db.t3.insert([
{ "_id" : 1, "item" : "a", "size": [ "S", "M", "L"] },
{ "_id" : 2, "item" : "b", "size" : [ ] },
{ "_id" : 3, "item" : "c", "size": "M" },
{ "_id" : 4, "item" : "d" },
{ "_id" : 5, "item" : "e", "size" : null }
])
```
- 使用语法1查询
```
db.t3.aggregate([{$unwind:'$size'}])
```
- 查看查询结果，发现对于空数组、无字段、null的文档，都被丢弃了
- 问：如何能不丢弃呢？
- 答：使用语法2查询
```
db.t3.aggregate([{$unwind:{path:'$sizes',preserveNullAndEmptyArrays
```
与python交互
```
#!/usr/bin/env python
# -*- coding: utf-8 -*-

import pymongo
import datetime


def get_db():
    # 建立连接
    client = pymongo.MongoClient(host="10.244.25.180", port=27017)
    db = client['example']
    #或者 db = client.example
    return db


def get_collection(db):
    # 选择集合（mongo中collection和database都是延时创建的）
    coll = db['informations']
    print db.collection_names()
    return coll


def insert_one_doc(db):
    # 插入一个document
    coll = db['informations']
    information = {"name": "quyang", "age": "25"}
    information_id = coll.insert(information)
    print information_id


def insert_multi_docs(db):
    # 批量插入documents,插入一个数组
    coll = db['informations']
    information = [{"name": "xiaoming", "age": "25"}, {"name": "xiaoqiang", "age": "24"}]
    information_id = coll.insert(information)
    print information_id


def get_one_doc(db):
    # 有就返回一个，没有就返回None
    coll = db['informations']
    print coll.find_one()  # 返回第一条记录
    print coll.find_one({"name": "quyang"})
    print coll.find_one({"name": "none"})


def get_one_by_id(db):
    # 通过objectid来查找一个doc
    coll = db['informations']
    obj = coll.find_one()
    obj_id = obj["_id"]
    print "_id 为ObjectId类型，obj_id:" + str(obj_id)

    print coll.find_one({"_id": obj_id})
    # 需要注意这里的obj_id是一个对象，不是一个str，使用str类型作为_id的值无法找到记录
    print "_id 为str类型 "
    print coll.find_one({"_id": str(obj_id)})
    # 可以通过ObjectId方法把str转成ObjectId类型
    from bson.objectid import ObjectId

    print "_id 转换成ObjectId类型"
    print coll.find_one({"_id": ObjectId(str(obj_id))})


def get_many_docs(db):
    # mongo中提供了过滤查找的方法，可以通过各种条件筛选来获取数据集，还可以对数据进行计数，排序等处理
    coll = db['informations']
    #ASCENDING = 1 升序;DESCENDING = -1降序;default is ASCENDING
    for item in coll.find().sort("age", pymongo.DESCENDING):
        print item

    count = coll.count()
    print "集合中所有数据 %s个" % int(count)

    #条件查询
    count = coll.find({"name":"quyang"}).count()
    print "quyang: %s"%count

def clear_all_datas(db):
    #清空一个集合中的所有数据
    db["informations"].remove()

if __name__ == '__main__':
    db = get_db()
    my_collection = get_collection(db)
    post = {"author": "Mike", "text": "My first blog post!", "tags": ["mongodb", "python", "pymongo"],
            "date": datetime.datetime.utcnow()}
    # 插入记录
    my_collection.insert(post)
    insert_one_doc(db)
    # 条件查询
    print my_collection.find_one({"x": "10"})
    # 查询表中所有的数据
    for iii in my_collection.find():
        print iii
    print my_collection.count()
    my_collection.update({"author": "Mike"},
                         {"author": "quyang", "text": "My first blog post!", "tags": ["mongodb", "python", "pymongo"],
                          "date": datetime.datetime.utcnow()})
    for jjj in my_collection.find():
        print jjj
    get_one_doc(db)
    get_one_by_id(db)
    get_many_docs(db)
    # clear_all_datas(db)
```
　
```
 
```
　　
相关阅读:
Tree Grafting
敌兵布阵
 畅通工程(并查集)
The Suspects(并查集)
Ubiquitous Religions(friends变形)
Friends(采用树结构的非线性表编程)
小球下落（二叉树）
铁轨
 卡片游戏
 征服C指针
原文地址：https://www.cnblogs.com/alamZ/p/7203813.html

MongoDB API和python操作

安装

管理mongo

数据库切换

数据库删除

集合创建

查看当前数据库的集合

删除

数据类型

object id

插入

简单查询

更新

保存

删除

关于size的示例

数据查询

基本查询

比较运算符

逻辑运算符

范围运算符

支持正则表达式

自定义查询

Limit

skip

一起使用

投影

排序

统计个数

消除重复

聚合 aggregate

管道

表达式

$group

Group by null

透视数据

$match

$project

$sort

$limit

$skip

$unwind

语法1

语法2

与python交互