Python MongoDB - Kurzanleitung

Pymongo ist eine Python-Distribution, die Tools für die Arbeit mit MongoDB bereitstellt. Dies ist die am meisten bevorzugte Methode, um mit der MongoDB-Datenbank von Python aus zu kommunizieren.

Installation

Um pymongo zu installieren, stellen Sie zunächst sicher, dass Sie python3 (zusammen mit PIP) und MongoDB ordnungsgemäß installiert haben. Führen Sie dann den folgenden Befehl aus.

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

Überprüfung

Nachdem Sie pymongo installiert haben, öffnen Sie ein neues Textdokument, fügen Sie die folgende Zeile ein und speichern Sie es als test.py.

import pymongo

Wenn Sie pymongo ordnungsgemäß installiert haben und die Datei test.py wie unten gezeigt ausführen, sollten keine Probleme auftreten.

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

Im Gegensatz zu anderen Datenbanken bietet MongoDB keinen separaten Befehl zum Erstellen einer Datenbank.

Im Allgemeinen wird der Befehl use verwendet, um die spezifische Datenbank auszuwählen / zu wechseln. Dieser Befehl überprüft zunächst, ob die von uns angegebene Datenbank vorhanden ist. Wenn ja, stellt er eine Verbindung zu ihr her. Wenn die mit dem Befehl use angegebene Datenbank nicht vorhanden ist, wird eine neue Datenbank erstellt.

Daher können Sie eine Datenbank in MongoDB mit dem erstellen Use Befehl.

Syntax

Grundlegende Syntax von use DATABASE Aussage ist wie folgt -

use DATABASE_NAME

Beispiel

Der folgende Befehl erstellt eine Datenbank mit dem Namen in mydb.

>use mydb
switched to db mydb

Sie können Ihre Erstellung mit dem Befehl db überprüfen. Dadurch wird die aktuelle Datenbank angezeigt.

>db
mydb

Datenbank mit Python erstellen

Um mit Pymongo eine Verbindung zu MongoDB herzustellen, müssen Sie einen MongoClient importieren und erstellen. Anschließend können Sie direkt auf die Datenbank zugreifen, die Sie in Attribut Leidenschaft erstellen müssen.

Beispiel

Das folgende Beispiel erstellt eine Datenbank in 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())

Ausgabe

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

Sie können beim Erstellen eines MongoClient auch die Port- und Hostnamen angeben und im Wörterbuchstil auf die Datenbanken zugreifen.

Beispiel

from pymongo import MongoClient

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

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

Ausgabe

Database created........

Eine Sammlung in MongoDB enthält eine Reihe von Dokumenten. Sie entspricht einer Tabelle in relationalen Datenbanken.

Sie können eine Sammlung mit dem erstellen createCollection()Methode. Diese Methode akzeptiert einen String-Wert, der den Namen der zu erstellenden Sammlung darstellt, und einen Optionsparameter (optional).

Hiermit können Sie Folgendes angeben:

  • Die Größe der Sammlung.

  • Die maximale Anzahl von Dokumenten, die in der begrenzten Sammlung zulässig sind.

  • Gibt an, ob die von uns erstellte Sammlung eine begrenzte Sammlung sein soll (Sammlung mit fester Größe).

  • Ob die von uns erstellte Sammlung automatisch indiziert werden soll.

Syntax

Im Folgenden finden Sie die Syntax zum Erstellen einer Sammlung in MongoDB.

db.createCollection("CollectionName")

Beispiel

Die folgende Methode erstellt eine Sammlung mit dem Namen ExampleCollection.

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

In ähnlicher Weise folgt eine Abfrage, die eine Sammlung mit den Optionen der Methode createCollection () erstellt.

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

Erstellen einer Sammlung mit Python

Das folgende Python-Beispiel stellt eine Verbindung zu einer Datenbank in MongoDB (mydb) her und erstellt eine Sammlung darin.

Beispiel

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

Ausgabe

Collection created........

Sie können Dokumente mit der Methode insert () in MongoDB speichern . Diese Methode akzeptiert ein JSON-Dokument als Parameter.

Syntax

Es folgt die Syntax der Einfügemethode.

>db.COLLECTION_NAME.insert(DOCUMENT_NAME)

Beispiel

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

In ähnlicher Weise können Sie auch mehrere Dokumente mit dem einfügen insert() Methode.

> 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" : [ ]
})
>

Erstellen einer Sammlung mit Python

Pymongo bietet eine Methode namens insert_one () zum Einfügen eines Dokuments in MangoDB. Für diese Methode müssen wir das Dokument im Wörterbuchformat übergeben.

Beispiel

Das folgende Beispiel fügt ein Dokument in die Sammlung mit dem Namen example ein.

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())

Ausgabe

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

Um mit pymongo mehrere Dokumente in MongoDB einzufügen, müssen Sie die Methode insert_many () aufrufen.

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)

Ausgabe

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

Sie können gespeicherte Dokumente aus MongoDB mit dem lesen / abrufen find()Methode. Diese Methode ruft alle Dokumente in MongoDB nicht strukturiert ab und zeigt sie an.

Syntax

Es folgt die Syntax von find() Methode.

>db.COLLECTION_NAME.find()

Beispiel

Angenommen, wir haben 3 Dokumente mit den folgenden Abfragen in eine Datenbank mit dem Namen testDB in einer Sammlung mit dem Namen sample eingefügt:

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

Sie können die eingefügten Dokumente mit der find () -Methode abrufen als -

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

Sie können das erste Dokument in der Sammlung auch mit der findOne () -Methode als - abrufen

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

Abrufen von Daten (Suchen) mit Python

Das find_One() Die Methode von Pymongo wird verwendet, um ein einzelnes Dokument basierend auf Ihrer Abfrage abzurufen. Wenn keine Übereinstimmungen vorliegen, gibt diese Methode nichts zurück. Wenn Sie keine Abfrage verwenden, wird das erste Dokument der Sammlung zurückgegeben.

Diese Methode ist praktisch, wenn Sie nur ein Dokument eines Ergebnisses abrufen müssen oder wenn Sie sicher sind, dass Ihre Abfrage nur ein Dokument zurückgibt.

Beispiel

Im folgenden Python-Beispiel das erste Dokument einer Sammlung abrufen -

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

Ausgabe

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'}

Um mehrere Dokumente in einer einzigen Abfrage abzurufen (Einzelaufruf oder Suchmethode), können Sie die verwenden find()Methode des Pymongo. Wenn Sie keine Abfrage übergeben haben, werden alle Dokumente einer Sammlung zurückgegeben. Wenn Sie eine Abfrage an diese Methode übergeben haben, werden alle übereinstimmenden Dokumente zurückgegeben.

Beispiel

#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)

Ausgabe

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'}

Beim Abrufen mit find()Methode können Sie die Dokumente mit dem Abfrageobjekt filtern. Sie können die Abfrage, die die Bedingung für die erforderlichen Dokumente als Parameter angibt, an diese Methode übergeben.

Betreiber

Im Folgenden finden Sie eine Liste der Operatoren, die in den Abfragen in MongoDB verwendet werden.

Betrieb Syntax Beispiel
Gleichberechtigung {"Schlüsselwert"} db.mycol.find ({"by": "tutorials point"})
Weniger als {"key": {$ lt: "value"}} db.mycol.find ({"liken": {$ lt: 50}})
Weniger als gleich {"key": {$ lte: "value"}} db.mycol.find ({"gefällt": {$ lte: 50}})
Größer als {"key": {$ gt: "value"}} db.mycol.find ({"liken": {$ gt: 50}})
Größer als gleich {"key" {$ gte: "value"}} db.mycol.find ({"gefällt": {$ gte: 50}})
Nicht gleich {"key": {$ ne: "value"}} db.mycol.find ({"liken": {$ ne: 50}})

Beispiel 1

Das folgende Beispiel ruft das Dokument in einer Sammlung ab, deren Name sarmista ist.

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)

Ausgabe

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

Beispiel2

Das folgende Beispiel ruft das Dokument in einer Sammlung ab, deren Alterswert größer als 26 ist.

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)

Ausgabe

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

Während Sie den Inhalt einer Sammlung abrufen, können Sie ihn in aufsteigender oder absteigender Reihenfolge sortieren und anordnen sort() Methode.

An diese Methode können Sie die Felder und die Sortierreihenfolge 1 oder -1 übergeben. Dabei steht 1 für aufsteigende Reihenfolge und -1 für absteigende Reihenfolge.

Syntax

Es folgt die Syntax der sort () -Methode.

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

Beispiel

Angenommen, wir haben eine Sammlung erstellt und 5 Dokumente wie unten gezeigt eingefügt.

> 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" : [ ]
})

In der folgenden Zeile werden alle Dokumente der Sammlung abgerufen, die nach Alter in aufsteigender Reihenfolge sortiert sind.

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

Sortieren der Dokumente mit Python

Um die Ergebnisse einer Abfrage in aufsteigender oder absteigender Reihenfolge zu sortieren, bietet pymongo die sort()Methode. Übergeben Sie dieser Methode einen Zahlenwert, der die Anzahl der Dokumente darstellt, die Sie im Ergebnis benötigen.

Standardmäßig sortiert diese Methode die Dokumente in aufsteigender Reihenfolge basierend auf dem angegebenen Feld. Wenn Sie in absteigender Reihenfolge sortieren müssen, übergeben Sie -1 zusammen mit dem Feldnamen -

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

Beispiel

Das folgende Beispiel ruft alle Dokumente einer Sammlung ab, die nach den Alterswerten in aufsteigender Reihenfolge angeordnet sind.

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)

Ausgabe

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'}

Sie können Dokumente in einer Sammlung mit dem löschen remove()Methode von MongoDB. Diese Methode akzeptiert zwei optionale Parameter -

  • Löschkriterien, die die Bedingung zum Löschen von Dokumenten angeben.

  • Nur eine, wenn Sie true oder 1 als zweiten Parameter übergeben, wird nur ein Dokument gelöscht.

Syntax

Es folgt die Syntax der remove () -Methode -

>db.COLLECTION_NAME.remove(DELLETION_CRITTERIA)

Beispiel

Angenommen, wir haben eine Sammlung erstellt und 5 Dokumente wie unten gezeigt eingefügt.

> 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" : [ ]
})

Die folgende Abfrage löscht die Dokumente der Sammlung, die den Namenswert Sarmista haben.

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

Wenn Sie aufrufen remove() Methode ohne Übergabe der Löschkriterien werden alle Dokumente in der Sammlung gelöscht.

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

Löschen von Dokumenten mit Python

Um Dokumente aus einer Sammlung von MangoDB zu löschen, können Sie Dokumente mit den Methoden aus einer Sammlung löschen delete_one() und delete_many() Methoden.

Diese Methoden akzeptieren ein Abfrageobjekt, das die Bedingung für das Löschen von Dokumenten angibt.

Die Methode detele_one () löscht im Falle einer Übereinstimmung ein einzelnes Dokument. Wenn keine Abfrage angegeben ist, löscht diese Methode das erste Dokument in der Sammlung.

Beispiel

Das folgende Python-Beispiel löscht das Dokument in der Sammlung mit dem ID-Wert 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)

Ausgabe

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'}

Ebenso die delete_many() Die Methode von Pymongo löscht alle Dokumente, die die angegebene Bedingung erfüllen.

Beispiel

Das folgende Beispiel löscht alle Dokumente in der Sammlung, deren Alterswert größer als 26 Jahre ist.

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)

Ausgabe

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'}

Wenn Sie die Methode delete_many () aufrufen, ohne eine Abfrage zu übergeben, löscht diese Methode alle Dokumente in der Auflistung.

coll.delete_many({})

Sie können Sammlungen mit löschen drop() Methode von MongoDB.

Syntax

Es folgt die Syntax der drop () -Methode -

db.COLLECTION_NAME.drop()

Beispiel

Das folgende Beispiel lässt die Sammlung mit dem Namensbeispiel fallen -

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

Sammlung mit Python löschen

Sie können eine Sammlung löschen / aus der aktuellen löschen, indem Sie die drop () -Methode aufrufen.

Beispiel

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)

Ausgabe

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

Sie können den Inhalt vorhandener Dokumente mit dem aktualisieren update() Methode oder save() Methode.

Die Aktualisierungsmethode ändert das vorhandene Dokument, während die Speichermethode das vorhandene Dokument durch das neue ersetzt.

Syntax

Es folgt die Syntax der Methoden update () und save () von MangoDB -

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

Beispiel

Angenommen, wir haben eine Sammlung in einer Datenbank erstellt und 3 Datensätze wie unten gezeigt eingefügt.

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

Die folgende Methode aktualisiert den Stadtwert des Dokuments mit der 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" }

Ebenso können Sie das Dokument durch neue Daten ersetzen, indem Sie es mit der Methode save () unter derselben ID speichern.

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

Aktualisieren von Dokumenten mit Python

Ähnlich wie bei der find_one () -Methode, mit der ein einzelnes Dokument abgerufen wird, aktualisiert die update_one () -Methode von pymongo ein einzelnes Dokument.

Diese Methode akzeptiert eine Abfrage, die angibt, welches Dokument aktualisiert werden soll, und den Aktualisierungsvorgang.

Beispiel

Das folgende Python-Beispiel aktualisiert den Speicherortwert eines Dokuments in einer Sammlung.

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)

Ausgabe

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'}

Ebenso die update_many() Die Methode von Pymongo aktualisiert alle Dokumente, die die angegebene Bedingung erfüllen.

Beispiel

Das folgende Beispiel aktualisiert den Speicherortwert in allen Dokumenten in einer Sammlung (leerer Zustand) -

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)

Ausgabe

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'}

Beim Abrufen des Inhalts einer Sammlung können Sie die Anzahl der Dokumente im Ergebnis mithilfe der Methode limit () begrenzen. Diese Methode akzeptiert einen Zahlenwert, der die Anzahl der gewünschten Dokumente im Ergebnis darstellt.

Syntax

Es folgt die Syntax der Methode limit () -

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

Beispiel

Angenommen, wir haben eine Sammlung erstellt und 5 Dokumente wie unten gezeigt eingefügt.

> 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" : [ ]
})

In der folgenden Zeile werden die ersten 3 Dokumente der Sammlung abgerufen.

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

Einschränken der Dokumente mit Python

Um die Ergebnisse einer Abfrage auf eine bestimmte Anzahl von Dokumenten zu beschränken, bietet pymongo die limit()Methode. Übergeben Sie an diese Methode einen Zahlenwert, der die Anzahl der Dokumente darstellt, die Sie im Ergebnis benötigen.

Beispiel

Im folgenden Beispiel werden die ersten drei Dokumente in einer Sammlung abgerufen.

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)

Ausgabe

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'}
ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved