AnkündigungWir stellen MongoDB 8.0 vor, das schnellste MongoDB aller Zeiten! Mehr erfahren >

AnkündigungVoyage AI und MongoDB unterstützen ab sofort gemeinsam genauere und vertrauenswürdigere KI-Anwendungen auf Atlas. Mehr erfahren >

Was ist PyMongo? Erste Schritte mit Python und MongoDB

Probieren Sie Atlas noch heute aus

PyMongo ist der offizielle MongoDB-Treiber für synchrone Python-Anwendungen. Wenn Sie lernen möchten, wie Sie MongoDB mit Ihrer Python-Anwendung verbinden und nutzen, sind Sie hier genau richtig. In diesem PyMongo-Tutorial werden wir eine einfache CRUD-Anwendung (Create, Read, Update, Delete) mit FastAPI und MongoDB Atlas entwickeln. Die Anwendung kann Dokumente in einer MongoDB-Datenbank erstellen, lesen, aktualisieren und löschen und stellt die Funktionalität über eine REST-API bereit. Die fertige Anwendung finden Sie auf Github.

Was ist PyMongo? Erste Schritte mit Python und MongoDB

CRUD-Anwendung zur Buchverwaltung
Anforderungen
Projekteinrichtung und Konfiguration
Verbinden Sie sich mit Ihrem MongoDB Atlas Cluster
Modelle für API-Anfragen und -Antworten erstellen
Implementieren Sie die REST-API-Endpunkte
Erkunden Sie die API-Dokumentationsseite und testen Sie die API-Endpunkte
Fazit

CRUD-Anwendung für die Verwaltung von Büchern

Meine bevorzugte Methode, um neue Technologien zu erlernen, besteht darin, etwas zu entwickeln. Deshalb programmieren wir die trivialste, aber nützlichste Backend-Anwendung — eine CRUD-App zur Verwaltung von Büchern. Die CRUD-Operationen werden über eine REST-API bereitgestellt. Die API wird fünf Endpunkte haben:

Code SnippetGET /book: to list all books
GET /book/<id>: to get a book by its ID
POST /book: to create a new book
PUT /book/<id>: to update a book by its ID
DELETE /book/<id>: to delete a book by its ID

Zum Aufbau der API verwenden wir das FastAPI-Framework. Es ist ein schlankes, modernes und benutzerfreundliches Framework für die Erstellung von APIs. Es generiert auch eine Swagger-API-Dokumentation, die wir beim Testen der Anwendung verwenden werden.

Wir werden die Bücher in einem MongoDB Atlas Cluster speichern. MongoDB Atlas ist die Datenbank-as-a-Service-Plattform von MongoDB. Es ist Cloud-basiert und Sie können in wenigen Minuten ein kostenloses Konto und ein Cluster erstellen, ohne etwas auf Ihrem Computer zu installieren. Wir werden PyMongo verwenden, um uns mit dem Cluster zu verbinden und Daten abzufragen.

Anforderungen

Das fertige Projekt ist auf Github verfügbar. Sie können auch die Schritt-für-Schritt-Anweisungen befolgen, um das Projekt von Grund auf neu zu erstellen. Dazu benötigen Sie Folgendes:

Python 3.6+ – Sie können es über die Python-Website installieren.
Einen MongoDB Atlas Cluster – Sie können einen dauerhaft kostenlosen Cluster erstellen, indem Sie die Anleitung „Erste Schritte mit Atlas“ befolgen. Führen Sie die Schritte in der Anleitung aus und suchen Sie die Verbindungszeichenfolge, die Sie für die Verbindung mit der Datenbank von der Anwendung aus benötigen.

Projekteinrichtung und Konfiguration

Bevor wir beginnen, werden wir eine virtuelle Python-Umgebung erstellen, um das Projekt von den restlichen global installierten Python-Paketen zu isolieren. Wir verwenden das Paket „venv“, das mit Ihrer Python-Installation geliefert wird. Führen Sie den folgenden Befehl im Terminal aus:

Code Snippetpython3 -m venv env-pymongo-fastapi-crud
source env-pymongo-fastapi-crud/bin/activate

Hinweis: Möglicherweise müssen Sie diesen Befehl mit python 3.exe ausführen. Dies liegt daran, dass auf manchen Betriebssystemen sowohl Python 2 als auch 3 installiert sind. Sobald Sie sich in Ihrer virtuellen Umgebung angemeldet haben, verwendet python.exe automatisch Version 3.

Da wir jetzt eine virtuelle Umgebung haben, können wir die erforderlichen Pakete installieren. Wir verwenden pip – das Paketinstallationsprogramm für Python, das auch in Ihrer Python-Installation enthalten ist:

Code Snippet

Als Nächstes erstellen wir ein Verzeichnis für unser Projekt, navigieren dorthin und generieren die für das Projekt benötigten Dateien.

Code Snippetmkdir pymongo-fastapi-crud
cd pymongo-fastapi-crud
touch main.py routes.py models.py .env

Hinweis: Wir verwenden Shell-Befehle, um Dateien und Verzeichnisse zu erstellen und durch diese zu navigieren. Wenn Sie möchten, können Sie stattdessen einen grafischen Datei-Explorer verwenden.

Beginnen wir mit der Implementierung eines einfachen Root-Endpunkts, der eine Willkommensnachricht zurückgibt. Öffnen Sie die Datei main.py in Ihrem bevorzugten Code-Editor und fügen Sie Folgendes hinzu:

pymongo-fastapi-crud/main.py

Code Snippetfrom fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def root():
    return {"message": "Welcome to the PyMongo tutorial!"}

Speichern Sie die Datei und führen Sie die Anwendung mit dem „uvicorn“-Paket aus, das zusammen mit dem „fastapi“-Paket installiert wurde.

Code Snippet

Sie sollten folgende Antwort sehen:

Code SnippetINFO:     Will watch for changes in these directories: ['/Users/you/pymongo-fastapi-crud']
INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO:     Started reloader process [2465] using watchgod
INFO:     Started server process [2467]
INFO:     Waiting for application startup.
INFO:     Application startup complete.

Öffnen Sie http://127.0.0.1:8000 in Ihrem Browser. Sie sollten die Willkommensnachricht sehen.

Gut gemacht! Es läuft aktuell ein Server. Im folgenden Abschnitt werden wir eine Verbindung zu unserem MongoDB Atlas Cluster herstellen.

Stellen Sie eine Verbindung zu Ihrem MongoDB Atlas Cluster her

Als Nächstes müssen wir uns mit dem MongoDB Atlas Cluster verbinden, den wir zuvor erstellt haben. Suchen Sie Ihren Verbindungsstring und fügen ihn der .env-Datei hinzu. Ersetzen Sie den Benutzernamen und das Passwort durch Ihre Anmeldedaten.

pymongo-fastapi-crud/.env

Code SnippetATLAS_URI=mongodb+srv://<username>:<password>@sandbox.lqlql.mongodb.net/?retryWrites=true&w=majority
DB_NAME=pymongo_tutorial

Wir werden das Paket python-dotenv verwenden, um die Umgebungsvariablen ATLAS_URI und DB_NAME aus der .env-Datei zu laden. Dann werden wir das Paket pymongo verwenden, um eine Verbindung zum Atlas-Cluster herzustellen, wenn die Anwendung startet. Wir werden einen weiteren Ereignishandler hinzufügen, um die Verbindung zu schließen, wenn die Anwendung stoppt. Öffnen Sie die Datei main.py erneut und ersetzen Sie ihren Inhalt durch Folgendes:

Code Snippetfrom fastapi import FastAPI
from dotenv import dotenv_values
from pymongo import MongoClient

config = dotenv_values(".env")

app = FastAPI()

@app.on_event("startup")
def startup_db_client():
    app.mongodb_client = MongoClient(config["ATLAS_URI"])
    app.database = app.mongodb_client[config["DB_NAME"]]
    print("Connected to the MongoDB database!")

@app.on_event("shutdown")
def shutdown_db_client():
    app.mongodb_client.close()

Der uvicorn-Prozess wird die Dateiänderung erkennen und den Server neu starten. Sie sollten die Meldung „Verbunden mit der MongoDB-Datenbank!“ im Terminal sehen.

Erstellen Sie Modelle für API-Anfragen und -Antworten

MongoDB hat ein flexibles Schemamodell, das es erlaubt, Dokumente mit unterschiedlicher Struktur innerhalb derselben Collection zu speichern. In der Praxis haben die Dokumente in einer Collection normalerweise die gleiche Struktur. Bei Bedarf können Sie sogar Validierungsregeln pro Collection durchsetzen. In unserem PyMongo-Tutorial werden wir die Datenbankvalidierung nicht behandeln. Stattdessen stellen wir sicher, dass die Daten, die durch die REST-API geleitet werden, gültig sind, bevor wir sie in der Datenbank speichern.

Wir werden ein paar Modelle für die API-Anfragen und -Antworten erstellen und FastAPI die schwere Arbeit für uns erledigen lassen. Das Framework übernimmt die Validierung, die Umwandlung in die korrekten Datentypen und sogar die Generierung der API-Dokumentation. Öffnen Sie die Datei models.py und fügen Sie Folgendes hinzu:

pymongo-fastapi-crud/models.py

Code Snippetimport uuid
from typing import Optional
from pydantic import BaseModel, Field

class Book(BaseModel):
    id: str = Field(default_factory=uuid.uuid4, alias="_id")
    title: str = Field(...)
    author: str = Field(...)
    synopsis: str = Field(...)

    class Config:
        allow_population_by_field_name = True
        schema_extra = {
            "example": {
                "_id": "066de609-b04a-4b30-b46c-32537c7f1f6e",
                "title": "Don Quixote",
                "author": "Miguel de Cervantes",
                "synopsis": "..."
            }
        }

class BookUpdate(BaseModel):
    title: Optional[str]
    author: Optional[str]
    synopsis: Optional[str]

    class Config:
        schema_extra = {
            "example": {
                "title": "Don Quixote",
                "author": "Miguel de Cervantes",
                "synopsis": "Don Quixote is a Spanish novel by Miguel de Cervantes..."
            }
        }

Wir erweitern das BaseModel aus dem pydantic-Paket und fügen die Felder für unsere Modelle hinzu. Für das Buchmodell gibt es vier Pflichtfelder: id, title, author und synopsis. Das ID-Feld wird automatisch mit einer UUID (universell eindeutiger Bezeichner) gefüllt. Wir haben auch ein Beispiel für das „Book"-Modell, das in der API-Dokumentation angezeigt wird.

Die Felder im Modell „BookUpdate“ sind optional. Das wird es uns ermöglichen, teilweise Aktualisierungen durchzuführen. Wir haben kein „ID“-Feld im „BookUpdate“-Modell, weil wir dem Benutzer nicht erlauben möchten, die „ID“ zu aktualisieren.

Nachdem wir unsere Modelle definiert haben, implementieren wir die REST-API-Endpunkte und nutzen die Modelle zur Validierung der Daten.

Implementieren Sie die REST-API-Endpunkte

Jetzt kommt der spannende Teil! Lassen Sie uns die REST-API-Endpunkte für unsere Bücher entwickeln! Wir fügen die Endpunktimplementierung in die Datei routes.py ein und laden die Routen in die Datei main.py. Wir beginnen mit der Initialisierung eines APIRouter-Objekts in routes.py:

pymongo-fastapi-crud/routes.py

Code Snippetfrom fastapi import APIRouter, Body, Request, Response, HTTPException, status
from fastapi.encoders import jsonable_encoder
from typing import List

from models import Book, BookUpdate

router = APIRouter()

Wie Sie sehen, importieren wir „APIRouter“ aus dem fastapi-Paket. Wir verwenden dieses Objekt, um die Endpunkte für unsere REST-API zu definieren. Wir importieren außerdem die Modelle „Book“ und „BookUpdate“, die wir zuvor definiert haben.

POST /book

Der erste Endpunkt, den wir implementieren werden, ist der Endpunkt POST /books zum Erstellen eines neuen Buches. Fügen Sie nach der Zeile router = APIRouter() Folgendes hinzu:

pymongo-fastapi-crud/routes.py

Code Snippet@router.post("/", response_description="Create a new book", status_code=status.HTTP_201_CREATED, response_model=Book)
def create_book(request: Request, book: Book = Body(...)):
    book = jsonable_encoder(book)
    new_book = request.app.database["books"].insert_one(book)
    created_book = request.app.database["books"].find_one(
        {"_id": new_book.inserted_id}
    )

    return created_book

Die Route ist „/“, weil wir allen Endpunkten der Bücher „/books“ voranstellen werden. Die „response_description“ wird in der API-Dokumentation angezeigt. Der „status_code“ ist der HTTP-Statuscode, der ausgegeben wird, wenn die Anfrage erfolgreich ist. Wir verwenden das Book-Modell, um sowohl die im Anforderungstext übergebenen Daten als auch die von uns zurückgesendete Antwort zu validieren. FastAPI übernimmt die Validierung für uns. Im Hauptteil der Funktion verwenden wir die Methode „insert_one()“ von PyMongo, um das neue Buch zur Buch-Collection hinzuzufügen. Wir verwenden die Methode „find_one()“, um das neu erstellte Buch aus der Datenbank abzurufen. Mehr über die Methoden „insert_one()“ und „find_one()“ finden Sie im PyMongo-Dokumentationsartikel für Operationen auf Collection-Ebene.

Zum Schluss rufen wir das erstellte Buch ab.

GET /book

Als Nächstes implementieren wir den Endpunkt „GET /book“, um eine Liste mit allen Dokumenten in der Buch-Collection auszugeben. Fügen Sie Folgendes am Ende der routes.py-Datei hinzu:

pymongo-fastapi-crud/routes.py

Code Snippet@router.get("/", response_description="List all books", response_model=List[Book])
def list_books(request: Request):
    books = list(request.app.database["books"].find(limit=100))
    return books

Für das Antwortmodell verwenden wir den Typ List[Book]. Dies bedeutet, dass die Antwort eine Liste von „Book“-Objekten sein wird. Wir verwenden auch die Methode „find()“, um nicht mehr als 100 Bücher aus der Datenbank abzurufen. Um mehr über „limit“ und die anderen Parameter der find()-Methode zu erfahren, besuchen Sie die entsprechende PyMongo-Dokumentationsseite.

GET /book/{id}

Erstellen wir einen weiteren GET-Endpunkt, um ein einzelnes Buch anhand seiner ID abzurufen. Fügen Sie Folgendes am Ende der routes.py-Datei hinzu:

pymongo-fastapi-crud/routes.py

Code Snippet@router.get("/{id}", response_description="Get a single book by id", response_model=Book)
def find_book(id: str, request: Request):
    if (book := request.app.database["books"].find_one({"_id": id})) is not None:
        return book
    raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Book with ID {id} not found")

Hier verwenden wir die Methode „find_one()“, um ein einzelnes Buch aus der Datenbank abzurufen. Falls das Buch gefunden wird, geben wir es aus. Falls das Buch nicht gefunden wird, lösen wir eine „HTTPException“ mit dem Statuscode „404 Not Found“ und einer passenden Nachricht aus.

PUT /book/{id}

Der wohl wichtigste Endpunkt unserer REST-API ist der Endpunkt PUT /book/{id}. Dieser Endpunkt ermöglicht es uns, ein einzelnes Buch zu aktualisieren. Fügen Sie die Implementierung ans Ende der Datei routes.py hinzu:

pymongo-fastapi-crud/routes.py

Code Snippet@router.put("/{id}", response_description="Update a book", response_model=Book)
def update_book(id: str, request: Request, book: BookUpdate = Body(...)):
    book = {k: v for k, v in book.dict().items() if v is not None}
    if len(book) >= 1:
        update_result = request.app.database["books"].update_one(
            {"_id": id}, {"$set": book}
        )

        if update_result.modified_count == 0:
            raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Book with ID {id} not found")

    if (
        existing_book := request.app.database["books"].find_one({"_id": id})
    ) is not None:
        return existing_book

    raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Book with ID {id} not found")

Lassen Sie uns den Code durchgehen. Zuerst erstellen wir ein Objekt, das wir verwenden werden, um das Buch zu aktualisieren. Wenn das „Buch“-Objekt dann Felder enthält, verwenden wir die Methode „update_one()“, um das Buch in der Datenbank zu aktualisieren. Es ist wichtig zu beachten, dass wir den Update-Operator „$set“ verwenden, um sicherzustellen, dass nur die angegebenen Felder aktualisiert werden, anstatt das gesamte Dokument neu zu schreiben.

Anschließend überprüfen wir das Attribut „modified_count“ des „update_result“, um sicherzustellen, dass das Buch aktualisiert wurde. Wenn dies der Fall ist, verwenden wir die Methode „find_one()“, um das aktualisierte Buch aus der Datenbank abzurufen und auszugeben.

Wenn das Buchobjekt keine Felder enthält, geben wir einfach das vorhandene Buch aus. Wenn das Buch jedoch nicht gefunden wird, lösen wir eine „HTTPException“ mit dem Statuscode „404 Not Found“ aus.

DELETE /book/{id}

Der letzte Endpunkt, den wir implementieren werden, ist DELETE /book/{id} zum Löschen eines einzelnen Buches anhand seiner ID. Fügen Sie Folgendes am Ende der routes.py-Datei hinzu:

pymongo-fastapi-crud/routes.py

Code Snippet@router.delete("/{id}", response_description="Delete a book")
def delete_book(id: str, request: Request, response: Response):
    delete_result = request.app.database["books"].delete_one({"_id": id})

    if delete_result.deleted_count == 1:
        response.status_code = status.HTTP_204_NO_CONTENT
        return response

    raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Book with ID {id} not found")

Das einzig Bemerkenswerte hier ist, dass wir, wenn das Buch gelöscht wurde, einen Statuscode „204 No Content“ ausgeben. Dies ist ein Erfolgsstatuscode, der anzeigt, dass die Anfrage erfolgreich war und es keinen Inhalt gibt, der im Antworttext gesendet werden muss.

Registrieren Sie die Endpunkte

Zum Schluss müssen wir noch die /book-Endpunkte registrieren. Öffnen Sie die Datei main.py, importieren Sie das Modul routes und registrieren Sie den Buchrouter. Die endgültige Version der Datei main.py sollte wie folgt aussehen:

pymongo-fastapi-crud/main.py

Code Snippetfrom fastapi import FastAPI
from dotenv import dotenv_values
from pymongo import MongoClient
from routes import router as book_router

config = dotenv_values(".env")

app = FastAPI()

@app.on_event("startup")
def startup_db_client():
    app.mongodb_client = MongoClient(config["ATLAS_URI"])
    app.database = app.mongodb_client[config["DB_NAME"]]

@app.on_event("shutdown")
def shutdown_db_client():
    app.mongodb_client.close()

app.include_router(book_router, tags=["books"], prefix="/book")

Erkunden Sie die API-Dokumentationsseite und testen Sie die Endpunkte.

Stellen Sie sicher, dass Ihr uvicorn-Prozess noch läuft, bevor Sie fortfahren. Falls dies nicht der Fall ist, können Sie mit demselben Befehl im Terminal starten:

Code Snippet

Navigieren Sie zur URL http://localhost:8000/docs in Ihrem Browser. Dies ist die API-Dokumentationsseite, die FastAPI und Swagger für uns generiert haben.

Wir sehen alle Endpunkte, die wir erstellt haben, und können sogar direkt von dieser Seite aus Anfragen senden. Öffnen Sie die Registerkarte „POST“ und klicken Sie auf die Schaltfläche „Try it out“. Sie sollten einen Anforderungstext sehen, der mit unserem Beispielbuch vorausgefüllt ist. Klicken Sie auf „Ausführen“, um die Anfrage zu senden. Sie sollten eine erfolgreiche Antwort mit dem von uns erstellten Buch sehen. Sie können die ID des Buches aus der Antwort entnehmen und sie in einem der anderen Endpunkte verwenden – GET /book/{id}, PUT /book/{id} oder DELETE /book/{id}.

Aber was wäre, wenn wir versuchen, dasselbe Buch zweimal zu erstellen? Wir erhalten die Fehlermeldung „500 Internal Server Error“. Wenn wir das Terminal überprüfen, auf dem der Serverprozess läuft, sollten wir eine Fehlermeldung mit folgendem Inhalt sehen:

Code Snippetpymongo.errors.DuplicateKeyError: E11000 duplicate key error collection: pymongo_tutorial.books index: _id

Wir haben einen DuplicateKeyError erhalten, weil wir versucht haben, ein Buch mit demselben „_id“-Feld zweimal einzufügen. Das Feld _id ist ein eindeutiger Index, den MongoDB für jede Kollektion erstellt. Es kann nicht zwei Bücher mit der gleichen „_id“ geben. Das eigentliche Problem hier ist, dass wir diesen Fehler in unserem Code nicht behandeln. Der Fehler wird weitergegeben und der Server antwortet mit einem „500 Internal Server Error“. Als Übung können Sie sich eine geeignete Antwort überlegen, die Sie an den Client zurücksenden, um diesen Fehler zu beheben.

Sie können auch die von uns erstellten Validierungsregeln testen. Versuchen Sie zum Beispiel, das erforderliche Feld „title“ aus dem Anforderungstext zu entfernen und auf „Ausführen“ zu klicken. Sie sollten eine Fehlermeldung sehen, die besagt, dass das Feld „title“ erforderlich ist.

Die generierte API-Dokumentationsseite ist sehr nützlich, um verschiedene Szenarien auszuprobieren und zu beobachten, wie die API reagiert. Viel Spaß beim Erkunden der von uns entwickelten API!

Fazit

In diesem Tutorial haben wir gelernt, wie man eine einfache CRUD-Anwendung mit FastAPI und PyMongo erstellt, dem offiziellen MongoDB-Treiber für synchrone Python-Anwendungen. Wir haben auch gesehen, wie wir schnell einen kostenlosen MongoDB Atlas Cluster einrichten und eine Verbindung dazu herstellen können. MongoDB Atlas ist weit mehr als nur eine MongoDB-Cloud-Datenbank. Zum Beispiel können Sie Ihre API problemlos erweitern, um eine Volltextsuche mit Atlas Search bereitzustellen. Alle diese Dienste sind in MongoDB Atlas verfügbar. Wenn Sie es ausprobieren möchten, erstellen Sie ein kostenloses Konto.

FAQ

PyMongo ist der offizielle MongoDB-Treiber für synchrone Python-Anwendungen. Sie können eine Verbindung zu einer MongoDB-Instanz herstellen und Daten abfragen. Es ist ein hervorragendes Werkzeug zum Entwickeln von Anwendungen, die mit MongoDB interagieren.

PyMongo ist ein Python-Paket. Sie können es mit `pip` installieren: `python -m pip install pymongo[srv]`.

Sobald Sie PyMongo installiert haben, können Sie es in Ihre Anwendung importieren, eine Verbindung zu einer MongoDB-Instanz herstellen und mit der Abfrage von Daten beginnen.

PyMongo ist der offizielle Python-Treiber für MongoDB, während MongoEngine ein ORM (Object-Relational-Mapper) ist, das PyMongo intern verwendet. PyMongo wird offiziell von MongoDB unterstützt und empfohlen. Erfahren Sie mehr über die Unterschiede zwischen den beiden in dem dedizierten Artikel

Profitieren Sie noch heute von Atlas

Sie sind in Sekundenschnelle startbereit. Unsere kostenlosen Cluster bieten über 512 MB Speicherplatz, sodass Sie die Möglichkeiten unserer Plattform anhand von Beispieldaten kennenlernen können.

Kostenlos testenKontakt zum Vertrieb

IHR EINSTIEG MIT FOLGENDEN VORTEILEN:

Mehr als 125 Regionen weltweit
Beispieldatensätze
Lückenlose Authentifizierung
Lückenlose Verschlüsselung

Kommandozeilen-Tools

Was ist PyMongo? Erste Schritte mit Python und MongoDB

CRUD-Anwendung für die Verwaltung von Büchern

Anforderungen

Projekteinrichtung und Konfiguration

Stellen Sie eine Verbindung zu Ihrem MongoDB Atlas Cluster her

Erstellen Sie Modelle für API-Anfragen und -Antworten

Implementieren Sie die REST-API-Endpunkte

POST /book

GET /book

GET /book/{id}

PUT /book/{id}

DELETE /book/{id}

Registrieren Sie die Endpunkte

Erkunden Sie die API-Dokumentationsseite und testen Sie die Endpunkte.

Fazit

FAQ

Was können Sie mit PyMongo machen?

Wie lade ich PyMongo herunter und installiere es?

Wie verwendet man PyMongo?

Sollte ich PyMongo oder MongoEngine verwenden?

Profitieren Sie noch heute von Atlas