Python und MongoDB:Verbindung zu NoSQL-Datenbanken herstellen

MongoDB ist eine dokumentenorientierte und NoSQL-Datenbanklösung, die eine hervorragende Skalierbarkeit und Flexibilität sowie ein leistungsstarkes Abfragesystem bietet. Mit MongoDB und Python können Sie schnell viele verschiedene Arten von Datenbankanwendungen entwickeln. Wenn Ihre Python-Anwendung also eine Datenbank benötigt, die genauso flexibel ist wie die Sprache selbst, dann ist MongoDB genau das Richtige für Sie.

In diesem Tutorial lernen Sie:

• Welche MongoDB ist
• Wie man installiert und ausführt MongoDB
• Arbeiten mit MongoDB-Datenbanken
• Verwendung des Low-Level-PyMongo-Treibers zur Schnittstelle mit MongoDB
• Verwendung des High-Level-MongoEngine Object-Document Mapper (ODM)

In diesem Tutorial schreiben Sie einige Beispiele, die die Flexibilität und Leistungsfähigkeit von MongoDB und seine großartige Python-Unterstützung demonstrieren. Um den Quellcode für diese Beispiele herunterzuladen, klicken Sie auf den folgenden Link:

Quellcode abrufen: Klicken Sie hier, um den Quellcode abzurufen, den Sie verwenden, um in diesem Tutorial mehr über die Verwendung von MongoDB mit Python zu erfahren.

Verwendung von SQL vs. NoSQL-Datenbanken

Jahrzehntelang waren SQL-Datenbanken eine der wenigen Möglichkeiten für Entwickler, die große und skalierbare Datenbanksysteme aufbauen wollten. Die zunehmende Notwendigkeit, komplexe Datenstrukturen zu speichern, führte jedoch zur Geburt von NoSQL Datenbanken. Dieses neuartige Datenbanksystem ermöglicht es Entwicklern, heterogene und strukturlose Daten effizient zu speichern.

Im Allgemeinen speichern und rufen NoSQL-Datenbanksysteme Daten ganz anders ab als relationale SQL-Datenbankverwaltungssysteme (RDBMS).

Bei der Auswahl aus den derzeit verfügbaren Datenbanktechnologien müssen Sie sich möglicherweise zwischen der Verwendung von SQL- oder NoSQL-Systemen entscheiden. Beide haben spezifische Merkmale, die Sie bei der Auswahl des einen oder anderen berücksichtigen sollten. Hier sind einige der wesentlichen Unterschiede:

Es gibt noch viele andere Unterschiede zwischen den beiden Arten von Datenbanken, aber die oben genannten sind einige der wichtigsten, über die man Bescheid wissen sollte.

Bei der Auswahl einer Datenbank sollten Sie deren Stärken und Schwächen sorgfältig abwägen. Sie müssen auch überlegen, wie die Datenbank in Ihr spezifisches Szenario und die Anforderungen Ihrer Anwendung passt. Manchmal besteht die richtige Lösung darin, eine Kombination aus SQL- und NoSQL-Datenbanken zu verwenden, um verschiedene Aspekte eines breiteren Systems zu handhaben.

Einige gängige Beispiele für SQL-Datenbanken sind:

• SQLite
• MySQL
• Orakel
• PostgreSQL
• Microsoft SQL-Server

Beispiele für NoSQL-Datenbanken sind:

• DynamoDB
• Kassandra
• Redis
• CouchDB
• Denken Sie DB neu
• RavenDB
• MongoDB

In den letzten Jahren haben SQL- und NoSQL-Datenbanken sogar begonnen zu verschmelzen. Beispielsweise unterstützen Datenbanksysteme wie PostgreSQL, MySQL und Microsoft SQL Server jetzt das Speichern und Abfragen von JSON-Daten, ähnlich wie NoSQL-Datenbanken. Damit können Sie jetzt mit beiden Technologien viele der gleichen Ergebnisse erzielen. Viele der NoSQL-Features, wie die horizontale Skalierung und die benutzerfreundliche Oberfläche, stehen Ihnen jedoch immer noch nicht zur Verfügung.

Mit diesem kurzen Hintergrund zu SQL- und NoSQL-Datenbanken können Sie sich auf das Hauptthema dieses Tutorials konzentrieren:die MongoDB-Datenbank und wie man es in Python verwendet.

NoSQL-Datenbanken mit MongoDB verwalten

MongoDB ist dokumentenorientiert Datenbank als NoSQL klassifiziert. Es ist in den letzten Jahren in der gesamten Branche populär geworden und lässt sich hervorragend in Python integrieren. Im Gegensatz zu herkömmlichen SQL-RDBMS verwendet MongoDB Sammlungen von Dokumenten statt Tabellen von Zeilen um Daten zu organisieren und zu speichern.

MongoDB speichert Daten in schemalosen und flexiblen JSON-ähnlichen Dokumenten. Hier schemalos bedeutet, dass Sie Dokumente mit unterschiedlichen Feldern in derselben Sammlung haben können, ohne ein starres Tabellenschema erfüllen zu müssen .

Sie können die Struktur Ihrer Dokumente und Daten im Laufe der Zeit ändern, was zu einem flexiblen System führt, mit dem Sie sich schnell an geänderte Anforderungen anpassen können, ohne dass ein komplexer Prozess der Datenmigration erforderlich ist. Der Nachteil beim Ändern der Struktur neuer Dokumente besteht jedoch darin, dass vorhandene Dokumente mit dem aktualisierten Schema inkonsistent werden. Dies ist also ein Thema, das mit Sorgfalt behandelt werden muss.

Hinweis: JSON steht für JavaScript Object Notation . Es ist ein Dateiformat mit einer für Menschen lesbaren Struktur, die aus Schlüssel-Wert-Paaren besteht, die beliebig tief verschachtelt werden können.

MongoDB ist in C++ geschrieben und wird aktiv von MongoDB Inc. entwickelt. Es läuft auf allen wichtigen Plattformen wie macOS, Windows, Solaris und den meisten Linux-Distributionen. Im Allgemeinen gibt es drei Hauptentwicklungsziele hinter der MongoDB-Datenbank:

1. Gut skalieren
2. Speichern Sie reichhaltige Datenstrukturen
3. Stellen Sie einen ausgefeilten Abfragemechanismus bereit

MongoDB ist eine verteilte Datenbank, sodass Hochverfügbarkeit, horizontale Skalierung und geografische Verteilung in das System integriert sind. Es speichert Daten in flexiblen JSON-ähnlichen Dokumenten. Sie können diese Dokumente modellieren, um die Objekte in Ihren Anwendungen abzubilden, wodurch Sie effektiv mit Ihren Daten arbeiten können.

MongoDB bietet eine leistungsstarke Abfragesprache, die Ad-hoc-Abfragen, Indizierung, Aggregation, Geodatensuche, Textsuche und vieles mehr unterstützt. Dies bietet Ihnen ein leistungsstarkes Toolkit, um auf Ihre Daten zuzugreifen und mit ihnen zu arbeiten. Schließlich ist MongoDB frei verfügbar und bietet großartige Python-Unterstützung.

Überprüfung der Funktionen von MongoDB

Bisher haben Sie gelernt, was MongoDB ist und was seine Hauptziele sind. In diesem Abschnitt lernen Sie einige der wichtigeren Funktionen von MongoDB kennen. Hinsichtlich der Datenbankverwaltung bietet MongoDB die folgenden Funktionen:

• Abfrageunterstützung: Sie können viele Standardabfragetypen verwenden, z. B. den Abgleich (== ), Vergleich (< , > ) und reguläre Ausdrücke.
• Datenanpassung: Sie können praktisch jede Art von Daten speichern, seien sie strukturiert, teilstrukturiert oder sogar polymorph.
• Skalierbarkeit: Es verarbeitet mehr Abfragen, indem es einfach mehr Maschinen zum Server-Cluster hinzufügt.
• Flexibilität und Agilität: Sie können damit schnell Anwendungen entwickeln.
• Dokumentorientierung und Schemalosigkeit: Sie können alle Informationen zu einem Datenmodell in einem einzigen Dokument speichern.
• Anpassbares Schema: Sie können das Schema der Datenbank im Handumdrehen ändern, was die Zeit reduziert, die zum Bereitstellen neuer Funktionen oder zum Beheben bestehender Probleme benötigt wird.
• Relationale Datenbankfunktionen: Sie können Aktionen ausführen, die für relationale Datenbanken üblich sind, wie z. B. das Indizieren.

Auf der Betriebsseite bietet MongoDB einige Tools und Funktionen, die Sie in anderen Datenbanksystemen nicht finden werden:

• Skalierbarkeit: Unabhängig davon, ob Sie einen eigenständigen Server oder komplette Cluster unabhängiger Server benötigen, Sie können MongoDB auf die gewünschte Größe skalieren.
• Load-Balancing-Unterstützung: MongoDB verschiebt Daten automatisch über verschiedene Shards hinweg.
• Automatische Failover-Unterstützung: Wenn Ihr primärer Server ausfällt, wird automatisch ein neuer primärer Server eingerichtet und ausgeführt.
• Verwaltungstools: Sie können Ihre Maschinen mit dem cloudbasierten MongoDB Management Service (MMS) verfolgen.
• Speichereffizienz: Dank der speicherabgebildeten Dateien ist MongoDB oft effizienter als relationale Datenbanken.

Alle diese Funktionen sind sehr nützlich. Wenn Sie beispielsweise die Indizierungsfunktion nutzen, werden viele Ihrer Daten für einen schnellen Abruf im Speicher gehalten. Selbst ohne Indizierung bestimmter Dokumentschlüssel speichert MongoDB eine ganze Menge Daten unter Verwendung der am längsten verwendeten Technik.

Installieren und Ausführen von MongoDB

Jetzt, da Sie mit MongoDB vertraut sind, ist es an der Zeit, sich die Hände schmutzig zu machen und es zu verwenden. Aber zuerst müssen Sie es auf Ihrem Computer installieren. Die offizielle Website von MongoDB bietet zwei Editionen des Datenbankservers:

1. Die Community Edition bietet das flexible Dokumentenmodell zusammen mit Ad-hoc-Abfragen, Indizierung und Echtzeit-Aggregation, um leistungsstarke Möglichkeiten für den Zugriff und die Analyse Ihrer Daten bereitzustellen. Diese Ausgabe ist frei verfügbar.
2. Die Enterprise-Edition bietet die gleichen Funktionen wie die Community-Edition sowie weitere erweiterte Funktionen in Bezug auf Sicherheit und Überwachung. Dies ist die kommerzielle Edition, aber Sie können sie für Evaluierungs- und Entwicklungszwecke unbegrenzt kostenlos verwenden.

Wenn Sie Windows verwenden, können Sie das Installations-Tutorial für vollständige Anweisungen lesen. Im Allgemeinen können Sie zur Download-Seite gehen, die Windows-Plattform im Feld „Verfügbare Downloads“ auswählen und die Datei .msi auswählen Installer, der zu Ihrem aktuellen System passt, und klicken Sie auf Herunterladen .

Führen Sie das Installationsprogramm aus und befolgen Sie die Anweisungen des Installationsassistenten auf dem Bildschirm. Diese Seite enthält auch Informationen zum Ausführen von MongoDB als Windows-Dienst.

Wenn Sie unter macOS arbeiten, können Sie Homebrew verwenden, um MongoDB auf Ihrem System zu installieren. Sehen Sie sich das Installations-Tutorial an, um die vollständige Anleitung zu erhalten. Befolgen Sie außerdem unbedingt die Anweisungen zum Ausführen von MongoDB als macOS-Dienst.

Wenn Sie Linux verwenden, hängt der Installationsvorgang von Ihrer spezifischen Distribution ab. Eine detaillierte Anleitung zur Installation von MongoDB auf verschiedenen Linux-Systemen finden Sie auf der Installations-Tutorial-Seite und wählen Sie das Tutorial aus, das Ihrem aktuellen Betriebssystem entspricht. Stellen Sie sicher, dass Sie den MongoDB-Daemon mongod ausführen , am Ende der Installation.

Schließlich können Sie MongoDB auch mit Docker installieren. Dies ist praktisch, wenn Sie Ihr System nicht mit einer weiteren Installation überladen möchten. Wenn Sie diese Installationsoption bevorzugen, können Sie das offizielle Tutorial durchlesen und den Anweisungen folgen. Beachten Sie, dass in diesem Fall Vorkenntnisse in der Verwendung von Docker erforderlich sind.

Wenn die MongoDB-Datenbank auf Ihrem System installiert ist und ausgeführt wird, können Sie mithilfe von mongo mit echten Datenbanken arbeiten Schale.

MongoDB-Datenbanken mit dem mongo erstellen Schale

Wenn Sie die Installations- und Ausführungsanweisungen befolgt haben, sollte bereits eine Instanz von MongoDB auf Ihrem System ausgeführt werden. Jetzt können Sie damit beginnen, Ihre eigenen Datenbanken zu erstellen und zu testen. In diesem Abschnitt erfahren Sie, wie Sie mongo verwenden Shell zum Erstellen, Lesen, Aktualisieren und Löschen von Dokumenten in einer Datenbank.

Ausführen des mongo Schale

Der mongo Shell ist eine interaktive JavaScript-Schnittstelle zu MongoDB. Mit diesem Tool können Sie Ihre Daten abfragen und manipulieren sowie administrative Vorgänge durchführen. Da es sich um eine JavaScript-Schnittstelle handelt, verwenden Sie nicht die vertraute SQL-Sprache, um die Datenbank abzufragen. Stattdessen verwenden Sie JavaScript-Code.

Zum Starten des mongo Shell, öffnen Sie Ihr Terminal oder Ihre Befehlszeile und führen Sie den folgenden Befehl aus:

$ mongo

Dieser Befehl führt Sie zum mongo Hülse. An dieser Stelle sehen Sie wahrscheinlich eine Reihe von Nachrichten mit Informationen zur Shell-Version sowie zur Serveradresse und zum Port. Schließlich wird Ihnen die Shell-Eingabeaufforderung (> ), um Abfragen und Befehle einzugeben.

Sie können die Datenbankadresse als Argument an mongo übergeben Befehl. Sie können auch mehrere Optionen verwenden, wie z. B. das Angeben des Hosts und des Ports für den Zugriff auf eine entfernte Datenbank usw. Weitere Einzelheiten zur Verwendung von mongo Befehl können Sie mongo --help ausführen .

Herstellen einer Verbindung

Wenn Sie mongo ausführen Befehl ohne Argumente, startet er die Shell und verbindet sich mit dem lokalen Standardserver, der von mongod bereitgestellt wird Prozess unter mongod://127.0.0.1:27017 . Das bedeutet, dass Sie über Port 27017 mit dem lokalen Host verbunden sind .

Standardmäßig ist der mongo Shell startet die Sitzung, indem sie eine Verbindung zum test aufbaut Datenbank. Sie können auf die aktuelle Datenbank über db zugreifen Objekt:

> db
test
>

In diesem Fall db enthält einen Verweis auf test , die die Standarddatenbank ist. Um zwischen Datenbanken zu wechseln, geben Sie den Befehl use ein , wobei ein Datenbankname als Argument angegeben wird.

Angenommen, Sie möchten eine Website zum Veröffentlichen von Python-Inhalten erstellen und planen, MongoDB zum Speichern Ihrer Tutorials und Artikel zu verwenden. In diesem Fall können Sie mit dem folgenden Befehl zur Datenbank der Website wechseln:

> use rptutorials
switched to db rptutorials

Dieser Befehl schaltet Ihre Verbindung zu den rptutorials um Datenbank. MongoDB erstellt die physische Datenbankdatei im Dateisystem erst, wenn Sie echte Daten in die Datenbank einfügen. In diesem Fall also rptutorials wird nicht in Ihrer aktuellen Datenbankliste angezeigt:

> show dbs
admin          0.000GB
config         0.000GB
local          0.000GB
>

Der mongo Shell bietet viele Funktionen und Optionen. Es erlaubt Ihnen, Ihre Daten abzufragen und zu manipulieren und auch den Datenbankserver selbst zu verwalten.

Anstatt eine standardisierte Abfragesprache wie SQL zu verwenden, wird mongo Shell verwendet die Programmiersprache JavaScript und eine benutzerfreundliche API. Diese API ermöglicht es Ihnen, mit Ihren Daten herumzuspielen, was das Thema des nächsten Abschnitts ist.

Sammlungen und Dokumente erstellen

Eine MongoDB-Datenbank ist ein physischer Container für Sammlungen von Dokumenten. Jede Datenbank erhält ihren eigenen Satz von Dateien im Dateisystem. Diese Dateien werden vom MongoDB-Server verwaltet, der mehrere Datenbanken verwalten kann.

In MongoDB eine Sammlung ist eine Gruppe von Dokumenten . Sammlungen ähneln in gewisser Weise Tabellen in einem herkömmlichen RDBMS, ohne jedoch ein starres Schema aufzuerlegen. Theoretisch kann jedes Dokument in einer Sammlung eine völlig andere Struktur oder Gruppe von Feldern haben.

In der Praxis haben Dokumente in einer Sammlung üblicherweise eine ähnliche Struktur, um einheitliche Abruf-, Einfügungs- und Aktualisierungsprozesse zu ermöglichen. Sie können eine einheitliche Dokumentstruktur erzwingen, indem Sie Dokumentvalidierungsregeln während Aktualisierungen und Einfügungen verwenden.

Das Zulassen unterschiedlicher Dokumentstrukturen ist ein Hauptmerkmal von MongoDB-Sammlungen. Diese Funktion bietet Flexibilität und ermöglicht das Hinzufügen neuer Felder zu Dokumenten, ohne dass ein formales Tabellenschema geändert werden muss.

So erstellen Sie eine Sammlung mit dem mongo Shell müssen Sie auf db zeigen zu Ihrer Zieldatenbank und erstellen Sie dann die Sammlungen mit der Punktnotation :

> use rptutorials
switched to db rptutorials
> db
rptutorials
> db.tutorial
rptutorials.tutorial

In diesem Beispiel verwenden Sie die Punktnotation, um tutorial zu erstellen als Sammlung in rptutorials , die Ihre aktuelle Datenbank ist. Es ist wichtig zu beachten, dass MongoDB Datenbanken und Sammlungen faul erstellt . Mit anderen Worten, sie werden erst physisch erstellt, nachdem Sie das erste Dokument eingefügt haben.

Sobald Sie eine Datenbank und eine Sammlung haben, können Sie mit dem Einfügen von Dokumenten beginnen. Dokumente sind die Speichereinheit in MongoDB. In einem RDBMS würde dies einer Tabellenzeile entsprechen. Die Dokumente von MongoDB sind jedoch viel vielseitiger als Zeilen, da sie komplexe Informationen wie Arrays, eingebettete Dokumente und sogar Arrays von Dokumenten speichern können.

MongoDB speichert Dokumente in einem Format namens Binary JSON (BSON), die eine binäre Darstellung von JSON ist. Die Dokumente von MongoDB bestehen aus Feld-Wert-Paaren und haben die folgende Struktur:

{
   field1 → value1,
   field2 → value2,
   field3 → value3,
   ...
   fieldN → valueN
}

Der Wert eines Felds kann ein beliebiger BSON-Datentyp sein, einschließlich anderer Dokumente, Arrays und Arrays von Dokumenten. In der Praxis spezifizieren Sie Ihre Dokumente im JSON-Format.

Wenn Sie eine MongoDB-Datenbankanwendung erstellen, betrifft Ihre wahrscheinlich wichtigste Entscheidung die Struktur der Dokumente. Mit anderen Worten, Sie müssen entscheiden, welche Felder und Werte Ihre Dokumente haben sollen.

Im Falle der Tutorials für Ihre Python-Site könnten Ihre Dokumente wie folgt strukturiert sein:

{
    "title": "Reading and Writing CSV Files in Python",
    "author": "Jon",
    "contributors": [
        "Aldren",
        "Geir Arne",
        "Joanna",
        "Jason"
    ],
    "url": "https://realpython.com/python-csv/"
}

Ein Dokument besteht im Wesentlichen aus einer Reihe von Eigenschaftsnamen und ihren Werten. Die Werte können einfache Datentypen wie Strings und Zahlen sein, aber auch Arrays wie contributors im obigen Beispiel.

Das dokumentenorientierte Datenmodell von MongoDB stellt komplexe Daten natürlich als einzelnes Objekt dar. Dadurch können Sie ganzheitlich mit Datenobjekten arbeiten, ohne mehrere Stellen oder Tabellen betrachten zu müssen.

Wenn Sie ein herkömmliches RDBMS zum Speichern Ihrer Tutorials verwenden würden, hätten Sie wahrscheinlich eine Tabelle zum Speichern Ihrer Tutorials und eine weitere Tabelle zum Speichern Ihrer Mitwirkenden. Dann müssten Sie eine Beziehung zwischen beiden Tabellen herstellen, damit Sie die Daten später abrufen können.

Mit Sammlungen und Dokumenten arbeiten

Bisher kennen Sie die Grundlagen zum Ausführen und Verwenden von mongo Hülse. Sie wissen auch, wie Sie eigene Dokumente im JSON-Format erstellen. Jetzt ist es an der Zeit zu lernen, wie Sie Dokumente in Ihre MongoDB-Datenbank einfügen.

Um ein Dokument mit dem mongo in eine Datenbank einzufügen Shell müssen Sie zuerst eine Sammlung auswählen und dann .insertOne() aufrufen auf der Sammlung mit Ihrem Dokument als Argument:

> use rptutorials
switched to db rptutorials

> db.tutorial.insertOne({
...     "title": "Reading and Writing CSV Files in Python",
...     "author": "Jon",
...     "contributors": [
...         "Aldren",
...         "Geir Arne",
...         "Joanna",
...         "Jason"
...     ],
...     "url": "https://realpython.com/python-csv/"
... })
{
    "acknowledged" : true,
    "insertedId" : ObjectId("600747355e6ea8d224f754ba")
}

Mit dem ersten Befehl wechseln Sie zu der Datenbank, die Sie verwenden möchten. Der zweite Befehl ist ein JavaScript-Methodenaufruf, der ein einfaches Dokument in die ausgewählte Sammlung tutorial einfügt . Sobald Sie Enter gedrückt haben erhalten Sie eine Meldung auf Ihrem Bildschirm, die Sie über das neu eingefügte Dokument und seine insertedId informiert .

So wie relationale Datenbanken einen Primärschlüssel benötigen, um jede Zeile in einer Tabelle eindeutig zu identifizieren, müssen MongoDB-Dokumente eine _id haben Feld, das das Dokument eindeutig identifiziert. MongoDB ermöglicht Ihnen die Eingabe einer benutzerdefinierten _id solange Sie dessen Einzigartigkeit garantieren. Eine weithin akzeptierte Praxis besteht jedoch darin, MongoDB das automatische Einfügen einer _id zu erlauben für dich.

Ebenso können Sie mit .insertMany() mehrere Dokumente auf einmal hinzufügen :

> tutorial1 = {
...     "title": "How to Iterate Through a Dictionary in Python",
...     "author": "Leodanis",
...     "contributors": [
...         "Aldren",
...         "Jim",
...         "Joanna"
...     ],
...     "url": "https://realpython.com/iterate-through-dictionary-python/"
... }

> tutorial2 = {
...      "title": "Python 3's f-Strings: An Improved String Formatting Syntax",
...      "author": "Joanna",
...      "contributors": [
...          "Adriana",
...          "David",
...          "Dan",
...          "Jim",
...          "Pavel"
...      ],
...      "url": "https://realpython.com/python-f-strings/"
... }

> db.tutorial.insertMany([tutorial1, tutorial2])
{
    "acknowledged" : true,
    "insertedIds" : [
        ObjectId("60074ff05e6ea8d224f754bb"),
        ObjectId("60074ff05e6ea8d224f754bc")
    ]
}

Hier der Aufruf von .insertMany() nimmt eine Liste von Tutorials und fügt sie in die Datenbank ein. Auch hier zeigt die Shell-Ausgabe Informationen über die neu eingefügten Dokumente und ihre automatisch hinzugefügte _id Felder.

Der mongo Shell bietet auch Methoden zum Ausführen von Lese-, Aktualisierungs- und Löschvorgängen in der Datenbank. Beispielsweise können Sie .find() verwenden um die Dokumente in einer Sammlung abzurufen:

> db.tutorial.find()
{ "_id" : ObjectId("600747355e6ea8d224f754ba"),
"title" : "Reading and Writing CSV Files in Python",
"author" : "Jon",
"contributors" : [ "Aldren", "Geir Arne", "Joanna", "Jason" ],
"url" : "https://realpython.com/python-csv/" }
    ...

> db.tutorial.find({author: "Joanna"})
{ "_id" : ObjectId("60074ff05e6ea8d224f754bc"),
"title" : "Python 3's f-Strings: An Improved String Formatting Syntax (Guide)",
"author" : "Joanna",
"contributors" : [ "Adriana", "David", "Dan", "Jim", "Pavel" ],
"url" : "https://realpython.com/python-f-strings/" }

Der erste Aufruf von .find() ruft alle Dokumente im tutorial ab Sammlung. Andererseits der zweite Aufruf von .find() ruft die Tutorials ab, die von Joanna verfasst wurden.

Mit diesem Hintergrundwissen zur Verwendung von MongoDB über seinen mongo Shell sind Sie bereit, MongoDB mit Python zu verwenden. In den nächsten Abschnitten werden Sie durch verschiedene Optionen für die Verwendung von MongoDB-Datenbanken in Ihren Python-Anwendungen geführt.

MongoDB mit Python und PyMongo verwenden

Jetzt wissen Sie, was MongoDB ist und wie Sie Datenbanken mit mongo erstellen und verwalten Shell können Sie MongoDB verwenden, diesmal jedoch mit Python. MongoDB bietet einen offiziellen Python-Treiber namens PyMongo.

In diesem Abschnitt gehen Sie einige Beispiele durch, die Ihnen helfen, ein Gefühl dafür zu bekommen, wie Sie mit PyMongo Ihre eigenen Datenbankanwendungen mit MongoDB und Python erstellen können.

Jedes Modul in PyMongo ist für eine Reihe von Operationen in der Datenbank verantwortlich. Sie haben Module für mindestens die folgenden Aufgaben:

• Datenbankverbindungen aufbauen
• Mit Datenbanken arbeiten
• Mit Sammlungen und Dokumenten arbeiten
• Manipulieren des Cursors
• Mit Datenverschlüsselung arbeiten

Im Allgemeinen bietet PyMongo eine Vielzahl von Tools, mit denen Sie mit einem MongoDB-Server kommunizieren können. Es bietet Funktionen zum Abfragen, Abrufen von Ergebnissen, Schreiben und Löschen von Daten und Ausführen von Datenbankbefehlen.

PyMongo installieren

Um mit der Verwendung von PyMongo zu beginnen, müssen Sie es zunächst in Ihrer Python-Umgebung installieren. Sie können eine virtuelle Umgebung oder Ihre systemweite Python-Installation verwenden, obwohl die erste Option bevorzugt wird. PyMongo ist auf PyPI verfügbar, daher lässt es sich am schnellsten mit pip installieren . Starten Sie Ihr Terminal und führen Sie den folgenden Befehl aus:

$ pip install pymongo==3.11.2

Nach einigen Downloads und anderen verwandten Schritten installiert dieser Befehl PyMongo in Ihrer Python-Umgebung. Beachten Sie, dass, wenn Sie keine bestimmte Versionsnummer angeben, pip installiert die neueste verfügbare Version.

Hinweis: Eine vollständige Anleitung zur Installation von PyMongo finden Sie auf der Seite „Installieren/Aktualisieren“ der offiziellen Dokumentation.

Sobald Sie mit der Installation fertig sind, können Sie eine interaktive Python-Sitzung starten und den folgenden Import ausführen:

>>> import pymongo

Wenn dies ausgeführt wird, ohne eine Ausnahme in der Python-Shell auszulösen, funktioniert Ihre Installation einwandfrei. Wenn nicht, führen Sie die Schritte sorgfältig erneut durch.

Herstellen einer Verbindung

Um eine Verbindung zu einer Datenbank herzustellen, müssen Sie einen MongoClient erstellen Beispiel. Diese Klasse stellt einen Client für eine MongoDB-Instanz oder einen Server bereit. Jedes Client-Objekt verfügt über einen integrierten Verbindungspool, der standardmäßig bis zu hundert Verbindungen zum Server verarbeitet.

Kehren Sie zu Ihrer interaktiven Python-Sitzung zurück und importieren Sie MongoClient von pymongo . Erstellen Sie dann ein Client-Objekt, um mit Ihrer aktuell ausgeführten MongoDB-Instanz zu kommunizieren:

>>> from pymongo import MongoClient
>>> client = MongoClient()
>>> client
MongoClient(host=['localhost:27017'], ..., connect=True)

Der obige Code stellt eine Verbindung zum Standardhost her (localhost ) und Port (27017 ). MongoClient akzeptiert eine Reihe von Argumenten, mit denen Sie benutzerdefinierte Host-, Port- und andere Verbindungsparameter angeben können. Um beispielsweise einen benutzerdefinierten Host und Port bereitzustellen, können Sie den folgenden Code verwenden:

>>> client = MongoClient(host="localhost", port=27017)

Dies ist praktisch, wenn Sie einen host bereitstellen müssen und port die sich von der Standardkonfiguration von MongoDB unterscheiden. Sie können auch das MongoDB-URI-Format verwenden:

>>> client = MongoClient("mongodb://localhost:27017")

All diese Instanzen von MongoClient Stellen Sie dasselbe Client-Setup bereit, um Ihre aktuelle MongoDB-Instance zu verbinden. Welche Sie verwenden sollten, hängt nur davon ab, wie explizit Sie in Ihrem Code sein möchten.

Nachdem Sie MongoClient instanziiert haben , können Sie seine Instanz verwenden, um auf diese bestimmte Datenbankverbindung zu verweisen, genau wie Sie es mit mongo getan haben db der Shell Objekt im obigen Abschnitt.

Mit Datenbanken, Sammlungen und Dokumenten arbeiten

Sobald Sie eine verbundene Instanz von MongoClient haben , können Sie auf jede Datenbank zugreifen, die vom angegebenen MongoDB-Server verwaltet wird. Um festzulegen, welche Datenbank Sie verwenden möchten, können Sie die Punktnotation verwenden, genau wie im mongo Schale:

>>> db = client.rptutorials
>>> db
Database(MongoClient(host=['localhost:27017'], ..., connect=True), 'rptutorials')

In diesem Fall rptutorials ist der Name der Datenbank, mit der Sie arbeiten werden. Wenn die Datenbank nicht vorhanden ist, erstellt MongoDB sie für Sie, aber nur, wenn Sie die erste Operation in der Datenbank ausführen.

Sie können auch den Wörterbuchzugriff verwenden, wenn der Name der Datenbank kein gültiger Python-Bezeichner ist:

>>> db = client["rptutorials"]

Diese Anweisung ist praktisch, wenn der Name Ihrer Datenbank kein gültiger Python-Bezeichner ist. Zum Beispiel, wenn Ihre Datenbank rp-tutorials heißt , dann müssen Sie den Wörterbuchzugriff verwenden.

Hinweis: Wenn Sie den mongo verwenden Shell haben Sie über db Zugriff auf die Datenbank globales Objekt. Wenn Sie PyMongo verwenden, können Sie die Datenbank einer Variablen namens db zuweisen um ein ähnliches Verhalten zu erhalten.

Das Speichern von Daten in Ihrer Datenbank mit PyMongo ähnelt dem, was Sie mit mongo gemacht haben Shell in den obigen Abschnitten. Aber zuerst müssen Sie Ihre Dokumente erstellen. In Python verwenden Sie Wörterbücher, um Dokumente zu erstellen:

>>> tutorial1 = {
...     "title": "Working With JSON Data in Python",
...     "author": "Lucas",
...     "contributors": [
...         "Aldren",
...         "Dan",
...         "Joanna"
...     ],
...     "url": "https://realpython.com/python-json/"
... }

Nachdem Sie das Dokument als Wörterbuch erstellt haben, müssen Sie angeben, welche Sammlung Sie verwenden möchten. Dazu können Sie die Punktnotation für das Datenbankobjekt verwenden:

>>> tutorial = db.tutorial
>>> tutorial
Collection(Database(..., connect=True), 'rptutorials'), 'tutorial')

In diesem Fall tutorial ist eine Instanz von Collection und stellt eine physische Sammlung von Dokumenten in Ihrer Datenbank dar. Sie können Dokumente in tutorial einfügen durch Aufruf von .insert_one() darauf mit einem Dokument als Argument:

>>> result = tutorial.insert_one(tutorial1)
>>> result
<pymongo.results.InsertOneResult object at 0x7fa854f506c0>

>>> print(f"One tutorial: {result.inserted_id}")
One tutorial: 60084b7d87eb0fbf73dbf71d

Hier .insert_one() nimmt tutorial1 , fügt es in das tutorial ein Sammlung und gibt ein InsertOneResult zurück Objekt. Dieses Objekt gibt Feedback zum eingefügten Dokument. Beachten Sie, dass MongoDB die ObjectId generiert dynamisch stimmt Ihre Ausgabe nicht mit der ObjectId überein oben gezeigt.

Wenn Sie der Datenbank viele Dokumente hinzufügen möchten, können Sie .insert_many() verwenden um sie auf einmal einzufügen:

>>> tutorial2 = {
...     "title": "Python's Requests Library (Guide)",
...     "author": "Alex",
...     "contributors": [
...         "Aldren",
...         "Brad",
...         "Joanna"
...     ],
...     "url": "https://realpython.com/python-requests/"
... }

>>> tutorial3 = {
...     "title": "Object-Oriented Programming (OOP) in Python 3",
...     "author": "David",
...     "contributors": [
...         "Aldren",
...         "Joanna",
...         "Jacob"
...     ],
...     "url": "https://realpython.com/python3-object-oriented-programming/"
... }

>>> new_result = tutorial.insert_many([tutorial2, tutorial3])

>>> print(f"Multiple tutorials: {new_result.inserted_ids}")
Multiple tutorials: [
   ObjectId('6008511c87eb0fbf73dbf71e'),
   ObjectId('6008511c87eb0fbf73dbf71f')
]

Dies ist schneller und einfacher als der Aufruf von .insert_one() mehrmals. Der Aufruf von .insert_many() Nimmt eine Iteration von Dokumenten und fügt sie in das tutorial ein Sammlung in Ihren rptutorials Datenbank. Die Methode gibt eine Instanz von InsertManyResult zurück , die Auskunft über die eingefügten Dokumente gibt.

Um Dokumente aus einer Sammlung abzurufen, können Sie .find() verwenden . Ohne Argumente, .find() gibt einen Cursor zurück Objekt, das die Dokumente in der Sammlung auf Anfrage liefert:

>>> import pprint

>>> for doc in tutorial.find():
...     pprint.pprint(doc)
...
{'_id': ObjectId('600747355e6ea8d224f754ba'),
 'author': 'Jon',
 'contributors': ['Aldren', 'Geir Arne', 'Joanna', 'Jason'],
 'title': 'Reading and Writing CSV Files in Python',
 'url': 'https://realpython.com/python-csv/'}
    ...
{'_id': ObjectId('6008511c87eb0fbf73dbf71f'),
 'author': 'David',
 'contributors': ['Aldren', 'Joanna', 'Jacob'],
 'title': 'Object-Oriented Programming (OOP) in Python 3',
 'url': 'https://realpython.com/python3-object-oriented-programming/'}

Here, you run a loop on the object that .find() returns and print successive results, using pprint.pprint() to provide a user-friendly output format.

You can also use .find_one() to retrieve a single document. In this case, you can use a dictionary that contains fields to match. For example, if you want to retrieve the first tutorial by Jon, then you can do something like this:

>>> import pprint

>>> jon_tutorial = tutorial.find_one({"author": "Jon"})

>>> pprint.pprint(jon_tutorial)
{'_id': ObjectId('600747355e6ea8d224f754ba'),
 'author': 'Jon',
 'contributors': ['Aldren', 'Geir Arne', 'Joanna', 'Jason'],
 'title': 'Reading and Writing CSV Files in Python',
 'url': 'https://realpython.com/python-csv/'}

Note that the tutorial’s ObjectId is set under the _id key, which is the unique document identifier that MongoDB automatically adds when you insert a document into your database.

PyMongo also provides methods to replace, update, and delete documents from a database. If you want to dive deeper into these features, then take a look at the documentation for Collection .

Closing Connections

Establishing a connection to a MongoDB database is typically an expensive operation. If you have an application that constantly retrieves and manipulates data in a MongoDB database, then you probably don’t want to be opening and closing the connection all the time since this might affect your application’s performance.

In this kind of situation, you should keep your connection alive and only close it before exiting the application to clear all the acquired resources. You can close the connection by calling .close() on the MongoClient instance:

>>> client.close()

Another situation is when you have an application that occasionally uses a MongoDB database. In this case, you might want to open the connection when needed and close it immediately after use for freeing the acquired resources. A consistent approach to this problem would be to use the with Erklärung. Yes, MongoClient implements the context manager protocol:

>>> import pprint
>>> from pymongo import MongoClient

>>> with MongoClient() as client:
...     db = client.rptutorials
...     for doc in db.tutorial.find():
...         pprint.pprint(doc)
...
{'_id': ObjectId('600747355e6ea8d224f754ba'),
 'author': 'Jon',
 'contributors': ['Aldren', 'Geir Arne', 'Joanna', 'Jason'],
 'title': 'Reading and Writing CSV Files in Python',
 'url': 'https://realpython.com/python-csv/'}
    ...
{'_id': ObjectId('6008511c87eb0fbf73dbf71f'),
 'author': 'David',
 'contributors': ['Aldren', 'Joanna', 'Jacob'],
 'title': 'Object-Oriented Programming (OOP) in Python 3',
 'url': 'https://realpython.com/python3-object-oriented-programming/'}

If you use the with statement to handle your MongoDB client, then at the end of the with code block, the client’s .__exit__() method gets called, which at the same time closes the connection by calling .close() .

Using MongoDB With Python and MongoEngine

While PyMongo is a great and powerful Python driver for interfacing with MongoDB, it’s probably a bit too low-level for many of your projects. With PyMongo, you’ll have to write a lot of code to consistently insert, retrieve, update, and delete documents.

One library that provides a higher abstraction on top of PyMongo is MongoEngine. MongoEngine is an object-document mapper (ODM), which is roughly equivalent to an SQL-based object-relational mapper (ORM). MongoEngine provides a class-based abstraction, so all the models you create are classes.

Installing MongoEngine

There are a handful of Python libraries to help you work with MongoDB. MongoEngine, however, is a popular one that provides a nice set of features, flexibility, and community support. MongoEngine is available on PyPI. You can install it using the following pip Befehl:

$ pip install mongoengine==0.22.1

Once you’ve installed MongoEngine into your Python environment, you’re ready to start working with MongoDB databases using Python’s object-oriented features. The next step is to connect to your running MongoDB instance.

Establishing a Connection

To establish a connection with your database, you need to use mongoengine.connect() . This function takes several arguments. However, in this tutorial, you’ll use only three of them. Within your Python interactive session, type the following code:

>>> from mongoengine import connect
>>> connect(db="rptutorials", host="localhost", port=27017)
MongoClient(host=['localhost:27017'], ..., read_preference=Primary())

Here, you first set the database name db to "rptutorials" , which is the name of the database you want to work in. Then you provide a host and a port to connect to your current MongoDB instance. Since you’re using the default host and port , you can omit these two parameters and just use connect("rptutorials") .

Working With Collections and Documents

To create documents with MongoEngine, you first need to define what data you want the documents to have. In other words, you need to define a document schema. MongoEngine encourages you to define a document schema to help you reduce coding errors and to allow you to define utility or helper methods.

Similar to ORMs, ODMs like MongoEngine provide a base or model class for you to define a document schema. In ORMs, that class is equivalent to a table, and its instances are equivalent to rows. In MongoEngine, the class is equivalent to a collection, and its instances are equivalent to documents.

To create a model, you need to subclass Document and provide the required fields as class attributes. To continue with the blog example, here’s how you can create a model for your tutorials:

>>> from mongoengine import Document, ListField, StringField, URLField

>>> class Tutorial(Document):
...     title = StringField(required=True, max_length=70)
...     author = StringField(required=True, max_length=20)
...     contributors = ListField(StringField(max_length=20))
...     url = URLField(required=True)

With this model, you tell MongoEngine that you expect a tutorial document to have a .title , an .author , a list of .contributors , and a .url . The base class, Document , uses that information along with the field types to validate the input data for you.

Hinweis: One of the more difficult tasks with database models is data validation . How do you make sure that the input data conforms to your format requirements? That’s one of the reasons for you to have a coherent and uniform document schema.

MongoDB is said to be a schemaless database, but that doesn’t mean it’s schema free. Having documents with a different schema within the same collection can lead to processing errors and inconsistent behavior.

For example, if you try to save a tutorial object without a .title , then your model throws an exception and lets you know. You can take this even further and add more restrictions, such as the length of the .title , and so on.

There are a few general parameters that you can use to validate fields. Here are some of the more commonly used parameters:

• db_field specifies a different field name.
• required ensures that the field is provided.
• default provides a default value for a given field if no value is given.
• unique ensures that no other document in the collection has the same value for this field.

Each specific field type also has its own set of parameters. You can check the documentation for a complete guide to the available field types.

To save a document to your database, you need to call .save() on a document object. If the document already exists, then all the changes will be applied to the existing document. If the document doesn’t exist, then it’ll be created.

Here’s an example of creating and saving a tutorial into your sample tutorials database:

>>> tutorial1 = Tutorial(
...     title="Beautiful Soup: Build a Web Scraper With Python",
...     author="Martin",
...     contributors=["Aldren", "Geir Arne", "Jaya", "Joanna", "Mike"],
...     url="https://realpython.com/beautiful-soup-web-scraper-python/"
... )

>>> tutorial1.save()  # Insert the new tutorial
<Tutorial: Tutorial object>

By default, .save() inserts the new document into a collection named after the model class, tutorial , except using lowercase letters. In this case, the collection name is tutorial , which matches the collection you’ve been using to save your tutorials.

PyMongo performs data validation when you call .save() . This means that it checks the input data against the schema you declared in the tutorial model class. If the input data violates the schema or any of its constraints, then you get an exception, and the data isn’t saved into the database.

For example, here’s what happens if you try to save a tutorial without providing a .title :

>>> tutorial2 = Tutorial()
>>> tutorial2.author = "Alex"
>>> tutorial2.contributors = ["Aldren", "Jon", "Joanna"]
>>> tutorial2.url = "https://realpython.com/convert-python-string-to-int/"
>>> tutorial2.save()
Traceback (most recent call last):
  ...
mongoengine.errors.ValidationError: ... (Field is required: ['title'])

In this example, first note that you can also build a tutorial object by assigning values to its attributes. Second, since you don’t provide a .title for the new tutorial, .save() raises a ValidationError telling you that the .title field is required. Having automatic data validation is a great feature that will save you some headaches.

Each Document subclass has an .objects attribute that you can use to access the documents in the associated collection. For example, here’s how you can print the .title of all your current tutorials:

>>> for doc in Tutorial.objects:
...     print(doc.title)
...
Reading and Writing CSV Files in Python
How to Iterate Through a Dictionary in Python
Python 3's f-Strings: An Improved String Formatting Syntax (Guide)
Working With JSON Data in Python
Python's Requests Library (Guide)
Object-Oriented Programming (OOP) in Python 3
Beautiful Soup: Build a Web Scraper With Python

The for loop iterates over all your tutorials and prints their .title data to the screen. You can also use .objects to filter your documents. For example, say you want to retrieve the tutorials authored by Alex. In that case, you can do something like this:

>>> for doc in Tutorial.objects(author="Alex"):
...     print(doc.title)
...
Python's Requests Library (Guide)

MongoEngine is well suited to manage your MongoDB databases for just about any type of application. Its features make it ideal for creating efficient and scalable programs using a high-level approach. If you’re looking for more information about MongoEngine, be sure to check out its user guide.

Conclusion

If you need a robust, scalable, and flexible database solution, then MongoDB might be a good option for you. MongoDB is a mature and popular NoSQL database with great Python support. With a good understanding of how to access MongoDB with Python, you’ll be ready to create database applications that scale well and provide excellent performance.

With MongoDB, you also have the benefit of a human-readable and highly-flexible data model, so you can adapt to requirement changes quickly.

In this tutorial, you learned:

• What MongoDB and NoSQL databases are
• How to install and run MongoDB on your system
• How to create and work with MongoDB databases
• How to interface with MongoDB in Python using the PyMongo driver
• How to use the MongoEngine object-document mapper to work with MongoDB

The examples you coded in this tutorial are available for download. To get their source code, click the link below:

Get the Source Code: Click here to get the source code you’ll use to learn about using MongoDB with Python in this tutorial.