[bigdata-020]用python3+pymogo 操作 mongodb数据库（python连接mongodb数据库）

25-02-05 16

对于想了解[bigdata-020]用python3+pymogo操作mongodb数据库的读者，本文将是一篇不可错过的文章，我们将详细介绍python连接mongodb数据库，并且为您提供关于121

对于想了解[bigdata-020]用python3+pymogo 操作 mongodb数据库的读者，本文将是一篇不可错过的文章，我们将详细介绍python连接mongodb数据库，并且为您提供关于121 monogdb安装, 增删改查, mongodb中的update修改器 pymomgo、Mongodb-- python中使用pymongo连接mongodb数据库、MongoDB学习【四】—pymongo操作mongodb数据库、mongodb数据库操作 python+命令行的有价值信息。

本文目录一览：

[bigdata-020]用python3+pymogo 操作 mongodb数据库（python连接mongodb数据库）
121 monogdb安装, 增删改查, mongodb中的update修改器 pymomgo
Mongodb-- python中使用pymongo连接mongodb数据库
MongoDB学习【四】—pymongo操作mongodb数据库
mongodb数据库操作 python+命令行

[bigdata-020]用python3+pymogo 操作 mongodb数据库（python连接mongodb数据库）

1. 安装pymongo

pip install pymongo

2. 写一个例子

#!/usr/bin/env python3
#! coding:utf-8 -*-

import pymongo
import time

client = pymongo.MongoClient(''localhost'',27017)

db = client.get_database(''user-behavior-data'')
print(db.name)

backend = db.get_collection(''backend'')
backend.insert_one({"x":8})

backend.insert_many([{''y'':15},{''z'':99}])

many_docs = []
for i in range(100000):
    doc = {}
    for t in ''abcdefghijklmnopqrstuvwxyz'':
        doc[t] = i
    many_docs.append(doc)

t1 = time.time()
backend.insert_many(many_docs)
dt = time.time() - t1

print(dt)
client.close()

3. 文档

http://api.mongodb.com/python/current/index.html

4. 性能

10万条复杂记录插入时间是2.5s，每秒4万条。性能可观。如果记录是单key的，可以更快，每秒10万条。

121 monogdb安装, 增删改查, mongodb中的update修改器 pymomgo

主要内容:

1 mongodb的安装:https://www.cnblogs.com/DragonFire/p/9135630.html

2 使用mongodb数据库的增删改查　　

　　use db  使用该数据库

　　show dbs 查看当前服务器中写在磁盘上的数据库

　　show tables 查看数据库中的collection

　　a : 数据的增加:

db.user_info.insertOne({name:"ywb",age:73})
db.user_info.insertMany([{name:"dwb",age:999},{name:"lwb",age:999.5}])

　　b : 数据的查询:

db.collection.find({条件})
db.collection.findOne({条件})
db.user_info.find({},{"_id":0,"name":0})    #find后面可以跟过滤条件
	带关键字的查询:
	    数学比较符: $gte, $lte, $eq, $gt, $lt
		db.user_info.findOne({id:{$gt: 1}})
		db.user_info.findOne({id:{$eq: 1}})
	$or db.collection.find({$or:[{name:1},{age:73}]})
	$in db.collection.find({age:{$in:[1,2,3,4]}}) #符合其中一个条件即可
	$all db.collection.find({hobby:{$all:[1,2,3,4]}}) #子集查询

　　c : 数据的修改:

db.collection.updateOne({条件},{$修改器:{数据}}) 更新一条数据
	db.collection.updateMany({条件},{$修改器:{数据}}) 更新所有数据
	db.user_info.updateMany({id:{$gt: 0}},{$set:{name:2}})

　　d : 数据的删除:

　　　　 db.collection.deleteOne({条件}) 删除一条数据
        db.collection.deleteMany({条件}) 删除所有符合条件的数据
　　　　 db.collection.drop() 删除表

3 mongodb中的update修改器: $inc $set $unset $push $pull

　　a : $inc 对查询的结果在原有的基础上进行增加或者减少

db.user_info.updateOne({age:27},{$inc:{age:1}})
db.user_info.updateOne({age:28},{$inc:{age:-8}})

　　b : $set 直接替换原来的值; 对原有的数据增加一个field

db.user_info.updateOne({},{$set:{test_list:[1,2,3,4,5,6,7,8]}})
db.user_info.updateOne({age:20},{$set:{age:21}})

　　c : $unset 用来删除key(field)

db.user_info.updateOne({id:1},{$unset:{name:1}})

　　d : $push 用来操作array数据类型进行增加新元素, 相当于列表的append方法

db.user_info.updateOne({id:1},{$push:{hobby:3}})

　　e : $pull 与push对应,用来删除array中的某个元素

db.user_info.updateOne({id:1},{$pull:{test_list:8}})

　　f : $pop 指定删除array中的第一个或者最后一个元素. -1代表最前面, 1代表最后面, 正数后面,复数前面

db.user_info.updateOne({id:1},{$pop:{test_list:1}})

4 $字符保存符合索引条件数据的下标

#当出现多个四时, 采用$保存符合条件的数据的下标.
db.user_info.updateOne({test_list:4},{$set:{"test_list.$":"四"}})

5 object的操作

db.user_info.updateOne({id:1},{$set:{"info.height":161}})
db.user_info.updateOne({id:1},{$inc:{"info.weight":-7}})

6 array +object的操作　

db.user_info.updateOne({"hobby.weight":100},{$set:{"hobby.$.height":164}})

7 limit sort skip

db.user_info.find().limit(2).skip(1).sort({ id:-1 })
重点: limit +skip +sort执行是有优先级别的, sort>skip>limit
         skip + limit的优先级: 先skip再limit

8 pymongo

　　a : 用于连接数据库

import pymongo
import json
from bson import ObjectId
mongo_client = pymongo.MongoClient(host="127.0.0.1",port=27017)
db = mongo_client["day120"]

　　b : 增加数据

res = db.user_info.insert_one({"id":15,"name":16})
print(list(db.user_info.find()))
print(res, res.inserted_id)
# <pymongo.results.InsertOneResult object at 0x000001BF04838308> 5c21f8429221292820de73b2
res = db.user_info.insert_many([{"id":16,"name":17},{"id":17,"name":18}])
print(list(db.user_info.find()))
# 查询多个id, 用inserted_ids
print(res, res.inserted_ids)
print(res, type(res))

View Code

　　c : 删除数据

res = db.user_info.delete_many({"id":7})
res = db.user_info.delete_one({"id":6})
# 显示删除了几条数据, res.raw_result
print(res, dir(res), res.raw_result)

View Code

　　d : 修改数据

res = db.user_info.update_one({"id":1},{"$set":{"name":"yuanyuan"}})
print(res, res.raw_result)
res_obj = db.user_info.find_one({"name":"yuanyuan"})
print(res_obj)

View Code

　　e : 查询数据

    # 把获取的生成器转换成列表
# res = list(db.user_info.find({}))
# print(res)
# res = db.user_info.find_one({"id":1})
# print(res)
# res = list(db.user_info.find({"name":{"$in":["shishi",3,4]}}))
# print(res)

# res = list(db.user_info.find({"$or":[{"name":2},{"id":3}]}))
# print(res)

View Code

　　f : 对于objectid json的操作

res = db.user_info.find_one({"id":2,"name":3})
print(res)
# 对于json序列化的时候, 不能直接序列化ObjectId的类型, 所以把其转换成字符串
# 对于再反过来取的时候, 需要把字符串转换成ObjectId类型
res["_id"] = str(res["_id"])
res_json = json.dumps(res)
print(res_json)  #Object of type ''ObjectId'' is not JSON serializable
res_obj = db.user_info.find_one({"_id":ObjectId(res.get("_id"))})
print(res_obj)

View Code

　　h : python中的update

# 相比较于下面的方法更加的方便
res = db.user_info.find_one({"name":"yuanyuan"})
res.get("info")[''height''] = 170
res.get("info")[''weight''] = 115
print(res)

res = db.user_info.update_one({"id":1},{"$set":{"info.height":180}})
print(list(db.user_info.find()))

　　l : skip sort limit

res = list(db.user_info.find().limit(2))
print(res)
# limit+skip的优先级: skip>limit
res = list(db.user_info.find().limit(2).skip(1))
print(res)
# 注意排序和mongo中的语法不一致
# limit skip sort:  sort> skip > limit
res = list(db.user_info.find({}).sort("id",pymongo.DESCENDING).skip(1).limit(3))
print(res)

9 mongodb的使用场景及优势:https://wenku.baidu.com/view/da471b54773231126edb6f1aff00bed5b9f373b4.html

Mongodb-- python中使用pymongo连接mongodb数据库

一.使用

通过pip或者pychrm下载pymongo模块

import json

from pymongo import MongoClient
from bson import ObjectId

mc = MongoClient("127.0.0.1",27017)
MONGODB = mc["数据库名"]

MONGODB.users.find({}) # 可以操作了

上面的文件一般单独写一个settings.py,在用到的时候,通过引入MONGO来操作

关于bson:

　　mongo中取出的数据有一个''_id''字段相当于mysql中的id, 这个字段的类型是Objectid,所以查询的结果不能直接json序列化,需要将这个''_id''转化为str类型后才能json序列化,相应的,从前端传过来的''_id''也要通过bson转化为ObjectId才能查到Mongodb中的数据

@au.route(''/auto_login'',methods=[''POST''])
def auto_login():
    user_info = request.form.to_dict()
    print(user_info)

    try:
        user_id = user_info.get(''user_id'')
        user = MONGODB.users.find_one({''_id'': ObjectId(user_id)})
        user[''_id''] = str(user[''_id''])
        RET = {
            ''code'': 1,
            ''msg'': ''自动登陆成功'',
            ''data'': user
        }
    except:
        RET = {
            ''code'': 0,
            ''msg'': ''自动登陆失败'',
            ''data'': {}
        }

    return jsonify(RET)

操作示例

# MONGODB = mc["admin"]
# res = MONGODB.users.find_one({"name":"Tom"})
# res["cours"].append({"name":"Tom","money":"100"})
# for index,cours in enumerate(res["cours"]):
#     if cours.get("name") == "Tom":
#         res["cours"][index]["score"] = 99


# MONGODB.users.delete_one({"age":84})
# MONGODB.users.delete_many({"age":84})

# user = MONGODB.users.find_one({"_id":ObjectId("5cb6eb7322b9441020186701")})
# print(user.get("_id"),type(user.get("_id")))
#
# user["_id"] = str(user["_id"])
# jsonstr = json.dumps(user)
# print(jsonstr , type(jsonstr))

MongoDB学习【四】—pymongo操作mongodb数据库

一、pymongodb的安装

Python 要连接 MongoDB 需要 MongoDB 驱动，这里我们使用 PyMongo 驱动来连接。

pip安装

pip 是一个通用的 Python 包管理工具，提供了对 Python 包的查找、下载、安装、卸载的功能。

安装 pymongo

python3 -m pip3 install pymongo
python3 -m pip3 install pymongo==3.5.1  # 指定版本安装

二、pymongodb操作mongodb数据库

1.连接数据库

通过pymongo连接mongodb数据库

import pymongo
client = pymongo.MongoClient("127.0.0.1", 27017)
dblist = client.database_names()  # 显示服务器上的所有数据库
# 新版本写法
dblist = client.list_database_names()

db = client["practice"]  # 连接数据库，获取库，如果库名存在，则使用，不存在创建
# print(db)  # 数据库操作对象

2.文档的增加

集合中插入文档使用 insert_one() 方法，该方法的第一参数是字典 name => value 对。

import pymongo

client = pymongo.MongoClient("127.0.0.1", 27017)
db = client["practice"]  # 连接数据库，获取库，如果库名存在，则使用，不存在创建
# print(db)  # 数据库操作对象

"""增加"""
# 增加单条
mydict = {"name":"ryxiong","age":99}
res = db.stu.insert_one(mydict)
print(res.inserted_id)  # 5d2ed8f865d6b8f1c494ff78 ObjectId对象，不是字符串

# 增加多条
mylist = [{"name":"black"},{"name":"white"}]
res = db.stu.insert_many(mylist)
print(res.inserted_ids)  # [ObjectId(''5d2fcc93c4f3d6ecb7178c87''), ObjectId(''5d2fcc93c4f3d6ecb7178c88'')]

3.查询文档

MongoDB 中使用了 find 和 find_one 方法来查询集合中的数据，它类似于 SQL 中的 SELECT 语句。

查询一条数据

我们可以使用 find_one() 方法来查询集合中的一条数据。

import pymongo
from bson import ObjectId

client = pymongo.MongoClient("127.0.0.1", 27017)
db = client["practice"]  # 连接数据库，获取库，如果库名存在，则使用，不存在创建

res1 = db.stu.find_one({"name": "ryxiong"})
res2 = db.stu.find_one({"_id": ObjectId("5d2f0a052a8ee222edddb297")})  # 将字符串的ObjectID转为对象后查询

查询集合中的所有数据或多条

find() 方法可以查询集合中的所有数据，类似 SQL 中的 SELECT * 操作。

import pymongo
from bson import ObjectId

client = pymongo.MongoClient("127.0.0.1", 27017)
db = client["practice"]  # 连接数据库，获取库，如果库名存在，则使用，不存在创建

# 查询多个
res3 = db.stu.find({})  # 查询所有记录
res4 = db.stu.find({"name": "ryxiong"})  # 查询符合条件的所有，生成器

高级查询

查询的条件语句中，我们还可以使用修饰符。

以下实例用于读取 name 字段中第一个字母 ASCII 值大于 "H" 的数据，大于的修饰符条件为 {"$gt": "H"}

import pymongo

client = pymongo.MongoClient("127.0.0.1", 27017)
db = client["practice"]  # 连接数据库，获取库，如果库名存在，则使用，不存在创建

myquery = { "name": { "$gt": "H" } }
res = mycol.find(myquery)

正则表达式查询

我们还可以使用正则表达式作为修饰符。

正则表达式修饰符只用于搜索字符串的字段。

以下实例用于读取 name 字段中第一个字母为 "R" 的数据，正则表达式修饰符条件为 {"$regex": "^R"}

import pymongo

client = pymongo.MongoClient("127.0.0.1", 27017)
db = client["practice"]  # 连接数据库，获取库，如果库名存在，则使用，不存在创建

myquery = { "name": { "$regex": "^R" } }
mydoc = mycol.find(myquery)
for x in mydoc:
    print(x)

查询结果排序，跳过，截取条数

如果我们要对查询结果设置指定条数的记录可以使用 limit() 方法

对结果排序通过sort()方法，对结果忽略某些结果用skip

import pymongo

client = pymongo.MongoClient("127.0.0.1", 27017)
db = client["practice"]  # 连接数据库，获取库，如果库名存在，则使用，不存在创建

# 1.查询结果的排序，跳过，和截取
sort_res = list(db.stu.find().sort("age", pymongo.DESCENDING))  # 查询所有结果，并根据年龄的降序排序
skip_res = list(db.stu.find().skip(2))  # 查询所有结果，并过滤掉前两条
limit_res = list(db.stu.find().limit(2))  # 查询所有结果，并截取前两条显示

# 2.分页效果
pagination_res = list(db.stu.find().sort("age", pymongo.ASCENDING).limit(2).skip(2))

4.修改文档

在 MongoDB 中使用 update_one() 方法修改文档中的记录。该方法第一个参数为查询的条件，第二个参数为要修改的字段。

如果查找到的匹配数据多余一条，则只会修改第一条。

import pymongo

client = pymongo.MongoClient("127.0.0.1", 27017)
db = client["practice"]  # 连接数据库，获取库，如果库名存在，则使用，不存在创建

"""修改"""
# 方式一
# 查询到直接更新设置值
res = db.stu.update_one({"name":"ryxiong"},{"$set":{"age":222}})
print(res.modified_count)

# 方式二.1
# 查到记录，在字典中添加值
res = db.stu.find_one({"name":"ryxiong"})
res["gender"] = "male"
res["hobby"] = "photography"
res["name"] = "ryxiong1"
# 将值更新到记录中去
res = db.stu.update_one({"name":"ryxiong"},{"$set":res})
print(res.modified_count)

5.删除数据

删除单挑

使用 delete_one() 方法来删除一个文档，该方法第一个参数为查询对象，指定要删除哪些数据

import pymongo

client = pymongo.MongoClient("127.0.0.1", 27017)
db = client["practice"] 

del_res1 = db.stu.delete_one({"name": "ryxiong"})  # 删除满足条件的结果中的第一条
print(del_res1.deleted_count)

删除多条

使用 delete_many() 方法来删除多个文档，该方法第一个参数为查询对象，指定要删除哪些数据。

import pymongo

client = pymongo.MongoClient("127.0.0.1", 27017)
db = client["practice"] 

query = { "name": {"$regex": "^F"} }
del_res = db.stu.delete_many(myquery)  # 删除满足条件的多条
print(del_res.deleted_count)

# 删除所有
del_res = db.stu.delete_many({})

mongodb数据库操作 python+命令行

一、python操作

from bson.objectid import ObjectId

import pymongo
client1 = pymongo.MongoClient(host=''localhost'', port=27017)

from pymongo import MongoClient
client2 = MongoClient(''mongodb://localhost:27017/'')

''''''
两种方式都行
''''''

''''''
指定数据库
''''''
db = client1.test
db2 = client1[''test'']



''''''
指定集合
''''''
collection = db.students
collection2 = db[''students'']

''''''
指定要插入的数据
''''''
student = {
    ''id'': ''20170101'',
    ''name'': ''Jordan'',
    ''age'': 20,
    ''gender'': ''male''
}
student2 = {
    ''id'': ''20170202'',
    ''name'': ''Mike'',
    ''age'': 21,
    ''gender'': ''male''
}


''''''
保存（可以插入多条）   结果返回id集合
''''''
result = collection.insert(student)
print(result)

result = collection.insert([student, student2])
print(result)
#=====================================================官方推荐=====================================
result = collection.insert_one(student)
print(result)
print(result.inserted_id)

result = collection.insert_many([student, student2])
print(result)
print(result.inserted_ids)


''''''
================================================================查询===============================
''''''
#单条查询
result = collection.find_one({''name'': ''Mike''})
print(type(result))
print(result)



#根据id查询
result = collection.find_one({''_id'': ObjectId(''593278c115c2602667ec6bae'')})
print(result)
#多条查询
results = collection.find({''age'': 20})
print(results)
for result in results:
    print(result)
#查询年龄大于20
results = collection.find({''age'': {''$gt'': 20}})

# $lt  小于
#
# $gt  大于
#
# $lte  小于等于
#
# $gte  大于等于
#
# $ne   不等于
#
# $in  在范围内
#
# $nin  不在范围内

#利用正则

#查询以m开头的
results1 = collection.find({''name'': {''$regex'': ''^M.*''}})

# 符号  含义  示例  示例含义
#
# $regex  匹配正则表达式  {''name'': {''$regex'': ''^M.*''}}  name以M开头
#
# $exists  属性是否存在  {''name'': {''$exists'': True}}  name属性存在
#
# $type  类型判断  {''age'': {''$type'': ''int''}}  age的类型为int
#
# $mod   数字模操作  {''age'': {''$mod'': [5, 0]}}  年龄模5余0
#
# $text  文本查询  {''$text'': {''$search'': ''Mike''}}  text类型的属性中包含Mike字符串
#
# $where  高级条件查询  {''$where'': ''obj.fans_count == obj.follows_count''}  自身粉丝数等于关注数
''''''
===========================================================统计==================================
''''''
count = collection.find().count()
print(count)
# 或者统计符合某个条件的数据：

count = collection.find({''age'': 20}).count()
print(count)


''''''
===========================================================排序==================================
升序   pymongo.ASCENDING
降序   pymongo.DESCENDING
''''''
results11 = collection.find().sort(''name'', pymongo.ASCENDING)
print([result[''name''] for result in results])

#跳过两个 取两个
results = collection.find().sort(''name'', pymongo.ASCENDING).skip(2).limit(2)
print([result[''name''] for result in results])


''''''
===========================================================修改==================================
''''''

condition = {''name'': ''Kevin''}
student = collection.find_one(condition)
student[''age''] = 25
result = collection.update(condition, student)
print(result)


#推荐
condition = {''name'': ''Kevin''}
student = collection.find_one(condition)
student[''age''] = 26
result = collection.update_one(condition, {''$set'': student})
print(result)
print(result.matched_count, result.modified_count)
#返回结果----匹配的数据条数和影响的数据条数

condition = {''age'': {''$gt'': 20}}
result = collection.update_one(condition, {''$inc'': {''age'': 1}})
print(result)
print(result.matched_count, result.modified_count)

condition = {''age'': {''$gt'': 20}}
result = collection.update_many(condition, {''$inc'': {''age'': 1}})
print(result)
print(result.matched_count, result.modified_count)

''''''
===========================================================删除==================================
''''''

result = collection.remove({''name'': ''Kevin''})
print(result)

#推荐
result = collection.delete_one({''name'': ''Kevin''})
print(result)
print(result.deleted_count)
result = collection.delete_many({''age'': {''$lt'': 25}})
print(result.deleted_count)

二、命令行

# 命令操作
''''''
1、显示当前数据库服务上的数据库


show dbs;


2、切换到指定的数据库进行操作


use mydb


3、显示当前数据库的所有集合（collections）


show collections;


4、查看数据库服务的状态


db.serverStatus();


5、查询指定数据库的统计信息


use admin


db.stat()


6、查询指定数据库包含的集合名称列表


use test1


db.getCollectionNames()


7、统计集合记录数


db.test1.count()


8、统计指定条件的记录数


db.test1.find({"name":"yunweicai"}).count()


9、查询指定数据库的集合当前可用的存储空间


db.test1.storageSize()


10、查询指定数据库的集合分配的存储空间


db.test1.totalSize()

1、创建数据库


不需要什么create database的命令，只要使用use命令就可以创建数据库


use test1


2、删除数据库


use test1


db.dropDatabase()


3、创建集合


可以使用命令db.createCollection(name, { size : ..., capped : ..., max : ... } )创建集合


也可以直接插入一个数据库就直接创建了


db.test1.insert({"name":"mongodb","user":"opcai"})


4、删除集合


db.test1.drop()


5、插入记录


db.test1.save({"name":"yunweicai"})


或者


db.test1.insert({"name":"mongodb","user":"opcai"})


6、查询记录


db.test1.find()


find()里面可以指定多个条件进行查询，如果为空，就查询所有的数据


7、删除记录


db.test1.remove({"name":"yunweicai"})


需要指定一个条件，没有条件是不允许删除操作的。
''''''

参考：

https://www.cnblogs.com/aademeng/articles/9779271.html

https://baijiahao.baidu.com/s?id=1612042780837847633&wfr=spider&for=pc

今天关于[bigdata-020]用python3+pymogo 操作 mongodb数据库和python连接mongodb数据库的介绍到此结束，谢谢您的阅读，有关121 monogdb安装, 增删改查, mongodb中的update修改器 pymomgo、Mongodb-- python中使用pymongo连接mongodb数据库、MongoDB学习【四】—pymongo操作mongodb数据库、mongodb数据库操作 python+命令行等更多相关知识的信息可以在本站进行查询。

本文标签：