Python MongoDB - Guia rápido

Pymongo é uma distribuição python que fornece ferramentas para trabalhar com MongoDB, é a forma preferida de se comunicar com o banco de dados MongoDB a partir de python.

Instalação

Para instalar o pymongo em primeiro lugar, certifique-se de ter instalado o python3 (junto com o PIP) e o MongoDB corretamente. Em seguida, execute o seguinte comando.

C:\WINDOWS\system32>pip install pymongo
Collecting pymongo
Using cached https://files.pythonhosted.org/packages/cb/a6/b0ae3781b0ad75825e00e29dc5489b53512625e02328d73556e1ecdf12f8/pymongo-3.9.0-cp37-cp37m-win32.whl
Installing collected packages: pymongo
Successfully installed pymongo-3.9.0

Verificação

Depois de instalar o pymongo, abra um novo documento de texto, cole a seguinte linha nele e salve-o como test.py.

import pymongo

Se você instalou o pymongo corretamente, se você executar o test.py conforme mostrado abaixo, você não deverá ter problemas.

D:\Python_MongoDB>test.py
D:\Python_MongoDB>

Ao contrário de outros bancos de dados, o MongoDB não fornece comandos separados para criar um banco de dados.

Em geral, o comando use é usado para selecionar / alternar para o banco de dados específico. Este comando verifica inicialmente se o banco de dados que especificamos existe; em caso afirmativo, ele se conecta a ele. Se o banco de dados que especificamos com o comando use não existe, um novo banco de dados será criado.

Portanto, você pode criar um banco de dados no MongoDB usando o Use comando.

Sintaxe

Sintaxe básica de use DATABASE declaração é a seguinte -

use DATABASE_NAME

Exemplo

O comando a seguir cria um banco de dados denominado mydb.

>use mydb
switched to db mydb

Você pode verificar sua criação usando o comando db , que exibe o banco de dados atual.

>db
mydb

Criação de banco de dados usando Python

Para se conectar ao MongoDB usando o pymongo, você precisa importar e criar um MongoClient, então você pode acessar diretamente o banco de dados que você precisa criar no atributo passion.

Exemplo

O exemplo a seguir cria um banco de dados em MangoDB.

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['mydb']
print("Database created........")

#Verification
print("List of databases after creating new one")
print(client.list_database_names())

Resultado

Database created........
List of databases after creating new one:
['admin', 'config', 'local', 'mydb']

Você também pode especificar os nomes de porta e host ao criar um MongoClient e pode acessar os bancos de dados no estilo de dicionário.

Exemplo

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['mydb']
print("Database created........")

Resultado

Database created........

Uma coleção no MongoDB contém um conjunto de documentos, é análogo a uma tabela em bancos de dados relacionais.

Você pode criar uma coleção usando o createCollection()método. Este método aceita um valor String que representa o nome da coleção a ser criada e um parâmetro options (opcional).

Usando isso, você pode especificar o seguinte -

O tamanho da coleção.
O número máximo de documentos permitidos na coleção limitada.
Se a coleção que criamos deve ser uma coleção limitada (coleção de tamanho fixo).
Se a coleção que criamos deve ser auto-indexada.

Sintaxe

A seguir está a sintaxe para criar uma coleção no MongoDB.

db.createCollection("CollectionName")

Exemplo

O método a seguir cria uma coleção chamada ExampleCollection.

> use mydb
switched to db mydb
> db.createCollection("ExampleCollection")
{ "ok" : 1 }
>

Da mesma forma, a seguir está uma consulta que cria uma coleção usando as opções do método createCollection ().

>db.createCollection("mycol", { capped : true, autoIndexId : true, size :
6142800, max : 10000 } )
{ "ok" : 1 }
>

Criação de uma coleção usando Python

O exemplo de python a seguir se conecta a um banco de dados no MongoDB (mydb) e cria uma coleção nele.

Exemplo

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['mydb']

#Creating a collection
collection = db['example']
print("Collection created........")

Resultado

Collection created........

Você pode armazenar documentos no MongoDB usando o método insert () . Este método aceita um documento JSON como parâmetro.

Sintaxe

A seguir está a sintaxe do método de inserção.

>db.COLLECTION_NAME.insert(DOCUMENT_NAME)

Exemplo

> use mydb
switched to db mydb
> db.createCollection("sample")
{ "ok" : 1 }
> doc1 = {"name": "Ram", "age": "26", "city": "Hyderabad"}
{ "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
> db.sample.insert(doc1)
WriteResult({ "nInserted" : 1 })
>

Da mesma forma, você também pode inserir vários documentos usando o insert() método.

> use testDB
switched to db testDB
> db.createCollection("sample")
{ "ok" : 1 }
> data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"}, 
   {"_id": "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }, 
   {"_id": "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
]
[
   {"_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad"},
   {"_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore"},
   {"_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai"}
]
> db.sample.insert(data)
BulkWriteResult({
   "writeErrors" : [ ],
   "writeConcernErrors" : [ ],
   "nInserted" : 3,
   "nUpserted" : 0,
   "nMatched" : 0,
   "nModified" : 0,
   "nRemoved" : 0,
   "upserted" : [ ]
})
>

Criação de uma coleção usando Python

Pymongo fornece um método denominado insert_one () para inserir um documento no MangoDB. Para este método, precisamos passar o documento em formato de dicionário.

Exemplo

O exemplo a seguir insere um documento na coleção denominada example.

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['mydb']

#Creating a collection
coll = db['example']

#Inserting document into a collection
doc1 = {"name": "Ram", "age": "26", "city": "Hyderabad"}
coll.insert_one(doc1)
print(coll.find_one())

Resultado

{'_id': ObjectId('5d63ad6ce043e2a93885858b'), 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}

Para inserir vários documentos no MongoDB usando pymongo, você precisa invocar o método insert_many ().

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['mydb']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")
print(res.inserted_ids)

Resultado

Data inserted ......
['101', '102', '103']

Você pode ler / recuperar documentos armazenados do MongoDB usando o find()método. Este método recupera e exibe todos os documentos no MongoDB de uma maneira não estruturada.

Sintaxe

A seguir está a sintaxe do find() método.

>db.COLLECTION_NAME.find()

Exemplo

Suponha que inserimos 3 documentos em um banco de dados chamado testDB em uma coleção chamada sample usando as seguintes consultas -

> use testDB
> db.createCollection("sample")
> data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" },
   {"_id": "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
]
> db.sample.insert(data)

Você pode recuperar os documentos inseridos usando o método find () como -

> use testDB
switched to db testDB
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
>

Você também pode recuperar o primeiro documento da coleção usando o método findOne () como -

> db.sample.findOne()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }

Recuperando dados (localizar) usando Python

o find_One() O método de pymongo é usado para recuperar um único documento com base na sua consulta, caso não corresponda este método não retorna nada e se você não usa nenhuma consulta retorna o primeiro documento da coleção.

Este método é útil sempre que você precisa recuperar apenas um documento de um resultado ou, se você tiver certeza de que sua consulta retorna apenas um documento.

Exemplo

Seguindo o exemplo python, recupere o primeiro documento de uma coleção -

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['mydatabase']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")
print(res.inserted_ids)

#Retrieving the first record using the find_one() method
print("First record of the collection: ")
print(coll.find_one())

#Retrieving a record with is 103 using the find_one() method
print("Record whose id is 103: ")
print(coll.find_one({"_id": "103"}))

Resultado

Data inserted ......
['101', '102', '103']
First record of the collection:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
Record whose id is 103:
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

Para obter vários documentos em uma única consulta (método de busca única de chamada), você pode usar o find()método do pymongo. Se não passou em nenhuma consulta, retorna todos os documentos de uma coleção e, se você passou uma consulta para este método, retorna todos os documentos correspondentes.

Exemplo

#Getting the database instance
db = client['myDB']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving all the records using the find() method
print("Records of the collection: ")
for doc1 in coll.find():
   print(doc1)

#Retrieving records with age greater than 26 using the find() method
print("Record whose age is more than 26: ")
for doc2 in coll.find({"age":{"$gt":"26"}}):
   print(doc2)

Resultado

Data inserted ......
Records of the collection:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
Record whose age is more than 26:
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

Ao recuperar usando find()método, você pode filtrar os documentos usando o objeto de consulta. Você pode passar a consulta especificando a condição para os documentos necessários como um parâmetro para este método.

Operadores

A seguir está a lista de operadores usados nas consultas no MongoDB.

Operação	Sintaxe	Exemplo
Igualdade	{"valor chave"}	db.mycol.find ({"by": "tutorials point"})
Menor que	{"chave": {$ lt: "valor"}}	db.mycol.find ({"likes": {$ lt: 50}})
Menor do que igual	{"chave": {$ lte: "valor"}}	db.mycol.find ({"likes": {$ lte: 50}})
Maior que	{"chave": {$ gt: "valor"}}	db.mycol.find ({"likes": {$ gt: 50}})
Maior que igual	{"chave" {$ gte: "valor"}}	db.mycol.find ({"likes": {$ gte: 50}})
Diferente	{"chave": {$ ne: "valor"}}	db.mycol.find ({"likes": {$ ne: 50}})

Exemplo 1

O exemplo a seguir recupera o documento em uma coleção cujo nome é sarmista.

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['sdsegf']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": "25", "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": "23", "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": "26", "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving data
print("Documents in the collection: ")
for doc1 in coll.find({"name":"Sarmista"}):
   print(doc1)

Resultado

Data inserted ......
Documents in the collection:
{'_id': '1005', 'name': 'Sarmista', 'age': '23', 'city': 'Delhi'}

Exemplo 2

O exemplo a seguir recupera o documento em uma coleção cujo valor de idade é maior que 26.

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['ghhj']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": "25", "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": "23", "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": "26", "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving data
print("Documents in the collection: ")
for doc in coll.find({"age":{"$gt":"26"}}):
   print(doc)

Resultado

Data inserted ......
Documents in the collection:
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

Ao recuperar o conteúdo de uma coleção, você pode classificar e organizá-los em ordem crescente ou decrescente usando o sort() método.

Para este método, você pode passar o (s) campo (s) e a ordem de classificação que é 1 ou -1. Onde, 1 é para ordem crescente e -1 é para ordem decrescente.

Sintaxe

A seguir está a sintaxe do método sort () .

>db.COLLECTION_NAME.find().sort({KEY:1})

Exemplo

Suponha que criamos uma coleção e inserimos 5 documentos nela, conforme mostrado abaixo -

> use testDB
switched to db testDB
> db.createCollection("myColl")
{ "ok" : 1 }
> data = [
   ... {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   ... {"_id": "1002", "name": "Rahim", "age": 27, "city": "Bangalore"},
   ... {"_id": "1003", "name": "Robert", "age": 28, "city": "Mumbai"},
   ... {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   ... {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   ... {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
> db.sample.insert(data)
BulkWriteResult({
   "writeErrors" : [ ],
   "writeConcernErrors" : [ ],
   "nInserted" : 6,
   "nUpserted" : 0,
   "nMatched" : 0,
   "nModified" : 0,
   "nRemoved" : 0,
   "upserted" : [ ]
})

A linha seguinte recupera todos os documentos da coleção que são classificados em ordem crescente com base na idade.

> db.sample.find().sort({age:1})
{ "_id" : "1005", "name" : "Sarmista", "age" : 23, "city" : "Delhi" }
{ "_id" : "1004", "name" : "Romeo", "age" : 25, "city" : "Pune" }
{ "_id" : "1006", "name" : "Rasajna", "age" : 26, "city" : "Chennai" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }

Classificando os documentos usando Python

Para classificar os resultados de uma consulta em ordem crescente ou decrescente, o pymongo fornece o sort()método. Para este método, passe um valor numérico que representa a quantidade de documentos que você precisa no resultado.

Por padrão, esse método classifica os documentos em ordem crescente com base no campo especificado. Se você precisar classificar em ordem decrescente, passe -1 junto com o nome do campo -

coll.find().sort("age",-1)

Exemplo

O exemplo a seguir recupera todos os documentos de uma coleção organizados de acordo com os valores de idade em ordem crescente -

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['b_mydb']

#Creating a collection
coll = db['myColl']

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving first 3 documents using the find() and limit() methods
print("List of documents (sorted in ascending order based on age): ")
for doc1 in coll.find().sort("age"):
   print(doc1)

Resultado

Data inserted ......
List of documents (sorted in ascending order based on age):
{'_id': '1005', 'name': 'Sarmista', 'age': 23, 'city': 'Delhi'}
{'_id': '1004', 'name': 'Romeo', 'age': 25, 'city': 'Pune'}
{'_id': '1006', 'name': 'Rasajna', 'age': 26, 'city': 'Chennai'}
{'_id': '1001', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

Você pode excluir documentos de uma coleção usando o remove()método do MongoDB. Este método aceita dois parâmetros opcionais -

Critérios de exclusão que especificam a condição para excluir documentos.
Apenas um, se passar verdadeiro ou 1 como segundo parâmetro, então apenas um documento será apagado.

Sintaxe

A seguir está a sintaxe do método remove () -

>db.COLLECTION_NAME.remove(DELLETION_CRITTERIA)

Exemplo

Suponha que criamos uma coleção e inserimos 5 documentos nela, conforme mostrado abaixo -

> use testDB
switched to db testDB
> db.createCollection("myColl")
{ "ok" : 1 }
> data = [
   ... {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   ... {"_id": "1002", "name": "Rahim", "age": 27, "city": "Bangalore"},
   ... {"_id": "1003", "name": "Robert", "age": 28, "city": "Mumbai"},
   ... {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   ... {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   ... {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
> db.sample.insert(data)
BulkWriteResult({
   "writeErrors" : [ ],
   "writeConcernErrors" : [ ],
   "nInserted" : 6,
   "nUpserted" : 0,
   "nMatched" : 0,
   "nModified" : 0,
   "nRemoved" : 0,
   "upserted" : [ ]
})

A consulta a seguir exclui o (s) documento (s) da coleção cujo valor de nome é Sarmista.

> db.sample.remove({"name": "Sarmista"})
WriteResult({ "nRemoved" : 1 })
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
{ "_id" : "1004", "name" : "Romeo", "age" : 25, "city" : "Pune" }
{ "_id" : "1006", "name" : "Rasajna", "age" : 26, "city" : "Chennai" }

Se você invocar remove() sem passar nos critérios de exclusão, todos os documentos da coleção serão excluídos.

> db.sample.remove({})
WriteResult({ "nRemoved" : 5 })
> db.sample.find()

Exclusão de documentos usando Python

Para excluir documentos de uma coleção de MangoDB, você pode excluir documentos de uma coleção usando os métodos delete_one() e delete_many() métodos.

Esses métodos aceitam um objeto de consulta especificando a condição para exclusão de documentos.

O método detele_one () exclui um único documento, em caso de correspondência. Se nenhuma consulta for especificada, este método exclui o primeiro documento da coleção.

Exemplo

O exemplo de python a seguir exclui o documento da coleção que tem o valor de id como 1006.

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['lpaksgf']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Deleting one document
coll.delete_one({"_id" : "1006"})

#Retrieving all the records using the find() method
print("Documents in the collection after update operation: ")
for doc2 in coll.find():
   print(doc2)

Resultado

Data inserted ......
Documents in the collection after update operation:
{'_id': '1001', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
{'_id': '1004', 'name': 'Romeo', 'age': 25, 'city': 'Pune'}
{'_id': '1005', 'name': 'Sarmista', 'age': 23, 'city': 'Delhi'}

Da mesma forma, o delete_many() método de pymongo exclui todos os documentos que satisfaçam a condição especificada.

Exemplo

O exemplo a seguir exclui todos os documentos da coleção cujo valor de idade é maior que 26 -

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['sampleDB']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": "25", "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": "23", "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": "26", "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Deleting multiple documents
coll.delete_many({"age":{"$gt":"26"}})

#Retrieving all the records using the find() method
print("Documents in the collection after update operation: ")
for doc2 in coll.find():
   print(doc2)

Resultado

Data inserted ......
Documents in the collection after update operation:
{'_id': '1001', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '1004', 'name': 'Romeo', 'age': '25', 'city': 'Pune'}
{'_id': '1005', 'name': 'Sarmista', 'age': '23', 'city': 'Delhi'}
{'_id': '1006', 'name': 'Rasajna', 'age': '26', 'city': 'Chennai'}

Se você invocar o método delete_many () sem passar nenhuma consulta, esse método exclui todos os documentos da coleção.

coll.delete_many({})

Você pode excluir coleções usando drop() método do MongoDB.

Sintaxe

A seguir está a sintaxe do método drop () -

db.COLLECTION_NAME.drop()

Exemplo

O exemplo a seguir descarta a coleção com amostra de nome -

> show collections
myColl
sample
> db.sample.drop()
true
> show collections
myColl

Descartando a coleção usando Python

Você pode descartar / excluir uma coleção da atual invocando o método drop ().

Exemplo

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['example2']

#Creating a collection
col1 = db['collection']
col1.insert_one({"name": "Ram", "age": "26", "city": "Hyderabad"})
col2 = db['coll']
col2.insert_one({"name": "Rahim", "age": "27", "city": "Bangalore"})
col3 = db['myColl']
col3.insert_one({"name": "Robert", "age": "28", "city": "Mumbai"})
col4 = db['data']
col4.insert_one({"name": "Romeo", "age": "25", "city": "Pune"})

#List of collections
print("List of collections:")
collections = db.list_collection_names()
for coll in collections:
   print(coll)

#Dropping a collection
col1.drop()
col4.drop()
print("List of collections after dropping two of them: ")

#List of collections
collections = db.list_collection_names()
for coll in collections:
   print(coll)

Resultado

List of collections:
coll
data
collection
myColl
List of collections after dropping two of them:
coll
myColl

Você pode atualizar o conteúdo de um documento existente usando o update() método ou save() método.

O método de atualização modifica o documento existente, enquanto o método de salvamento substitui o documento existente pelo novo.

Sintaxe

A seguir está a sintaxe dos métodos update () e save () do MangoDB -

>db.COLLECTION_NAME.update(SELECTION_CRITERIA, UPDATED_DATA)
Or,
db.COLLECTION_NAME.save({_id:ObjectId(),NEW_DATA})

Exemplo

Suponha que criamos uma coleção em um banco de dados e inserimos 3 registros como mostrado abaixo -

> use testdatabase
switched to db testdatabase
> data = [
   ... {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   ... {"_id": "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" },
   ... {"_id": "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
]
[
   {"_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad"},
   {"_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore"},
   {"_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai"}
]
> db.createCollection("sample")
{ "ok" : 1 }
> db.sample.insert(data)

O método a seguir atualiza o valor da cidade do documento com id 1002.

>db.sample.update({"_id":"1002"},{"$set":{"city":"Visakhapatnam"}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Visakhapatnam" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }

Da mesma forma, você pode substituir o documento por novos dados salvando-o com o mesmo id usando o método save ().

> db.sample.save({ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Vijayawada" })
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Vijayawada" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Visakhapatnam" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }

Atualização de documentos usando python

Semelhante ao método find_one () que recupera um único documento, o método update_one () de pymongo atualiza um único documento.

Este método aceita uma consulta que especifica qual documento atualizar e a operação de atualização.

Exemplo

O exemplo de python a seguir atualiza o valor de localização de um documento em uma coleção.

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['myDB']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving all the records using the find() method
print("Documents in the collection: ")
for doc1 in coll.find():
   print(doc1)
coll.update_one({"_id":"102"},{"$set":{"city":"Visakhapatnam"}})

#Retrieving all the records using the find() method
print("Documents in the collection after update operation: ")
for doc2 in coll.find():
   print(doc2)

Resultado

Data inserted ......
Documents in the collection:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
Documents in the collection after update operation:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Visakhapatnam'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

Da mesma forma, o update_many() método de pymongo atualiza todos os documentos que satisfaçam a condição especificada.

Exemplo

O exemplo a seguir atualiza o valor da localização em todos os documentos em uma coleção (condição vazia) -

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['myDB']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving all the records using the find() method
print("Documents in the collection: ")
for doc1 in coll.find():
   print(doc1)
coll.update_many({},{"$set":{"city":"Visakhapatnam"}})

#Retrieving all the records using the find() method
print("Documents in the collection after update operation: ")
for doc2 in coll.find():
   print(doc2)

Resultado

Data inserted ......
Documents in the collection:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
Documents in the collection after update operation:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Visakhapatnam'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Visakhapatnam'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Visakhapatnam'}

Ao recuperar o conteúdo de uma coleção, você pode limitar o número de documentos no resultado usando o método limit (). Este método aceita um valor numérico que representa o número de documentos que você deseja no resultado.

Sintaxe

A seguir está a sintaxe do método limit () -

>db.COLLECTION_NAME.find().limit(NUMBER)

Exemplo

Suponha que criamos uma coleção e inserimos 5 documentos nela, conforme mostrado abaixo -

> use testDB
switched to db testDB
> db.createCollection("sample")
{ "ok" : 1 }
> data = [
   ... {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   ... {"_id": "1002", "name": "Rahim", "age": 27, "city": "Bangalore"},
   ... {"_id": "1003", "name": "Robert", "age": 28, "city": "Mumbai"},
   ... {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   ... {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   ... {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
> db.sample.insert(data)
BulkWriteResult({
   "writeErrors" : [ ],
   "writeConcernErrors" : [ ],
   "nInserted" : 6,
   "nUpserted" : 0,
   "nMatched" : 0,
   "nModified" : 0,
   "nRemoved" : 0,
   "upserted" : [ ]
})

A linha seguinte recupera os 3 primeiros documentos da coleção.

> db.sample.find().limit(3)
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }

Limitando os documentos usando Python

Para restringir os resultados de uma consulta a um determinado número de documentos, o pymongo fornece o limit()método. Para este método passe um valor numérico que representa a quantidade de documentos que você precisa no resultado.

Exemplo

O exemplo a seguir recupera os três primeiros documentos de uma coleção.

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['l']

#Creating a collection
coll = db['myColl']

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving first 3 documents using the find() and limit() methods
print("First 3 documents in the collection: ")
for doc1 in coll.find().limit(3):
   print(doc1)

Resultado

Data inserted ......
First 3 documents in the collection:
{'_id': '1001', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

↰ Previous page