Wie man Daten in MongoDB mit Python abfragt: Ein Leitfaden für Anfänger

Einführung

MongoDB ist eine beliebte NoSQL-Datenbank und wird häufig zur Verarbeitung unstrukturierter Daten verwendet. Python-Entwickler können MongoDB effizient mit PyMongo abfragen, einem offiziellen MongoDB-Python-Treiber. Dieses Tutorial behandelt verschiedene MongoDB-Abfragetechniken in Python, einschließlich:

• Dokumente mit Filtern abrufen: Lernen Sie, wie Sie PyMongo verwenden, um Dokumente basierend auf spezifischen Bedingungen zu filtern, wie Gleichheit, Ungleichheit und logischen Operatoren.
• Abfragen von verschachtelten Feldern und Arrays: Sie werden lernen, wie man auf verschachtelte Felder und Arrays innerhalb von MongoDB-Dokumenten mit PyMongo zugreift und diese manipuliert.
• Verwendung von Aggregations-Pipelines: Verwenden Sie das Aggregations-Framework von MongoDB, um Daten in mehreren Phasen zu verarbeiten und zu transformieren, einschließlich Filtern, Gruppieren und Sortieren.
• Best Practices zur Optimierung von Abfragen: Verstehen Sie, wie Sie Ihre MongoDB-Abfragen für bessere Leistung optimieren können, einschließlich Indizierung, Begrenzung der Ergebnisse und Projektion spezifischer Felder.

Am Ende dieses Tutorials werden Sie in der Lage sein, MongoDB-Datenbanken effizient in Python abzufragen und die Leistungsoptimierung für große Datensätze zu bewältigen. Wir werden außerdem besprechen, wie Sie MongoDB Atlas, einen vollständig verwalteten Cloud-Datenbankdienst, nutzen können, um Ihre MongoDB-Datenbanken in der Cloud zu hosten.

Voraussetzungen

Bevor Sie MongoDB in Python abfragen, stellen Sie sicher, dass Sie Folgendes haben:

• Python 3 wurde auf Ihrem System heruntergeladen und installiert.

• MongoDB ist installiert und läuft. Sie können auf dieses Tutorial verweisen, um zu erfahren, wie man MongoDB installiert.

• Pymongo-Bibliothek installiert.

• Ein kostenloser MongoDB Atlas-Datenbankcluster, der zu Demonstrations- und Testzwecken bereitgestellt wird.

Schritt 1 - Installieren Sie MongoDB auf Ubuntu

Um MongoDB auf Ubuntu zu installieren, befolgen Sie diese Schritte:

1. Importieren Sie den MongoDB-Öffentlichen Schlüssel:

   sudo apt-get install gnupg curl
   curl -fsSL https://www.mongodb.org/static/pgp/server-8.0.asc | sudo gpg -o /usr/share/keyrings/mongodb-server-8.0.gpg --dearmor
   

2. Erstellen Sie die Listen-Datei:

   echo "deb [ arch=amd64,arm64 signed-by=/usr/share/keyrings/mongodb-server-8.0.gpg ] https://repo.mongodb.org/apt/ubuntu focal/mongodb-org/8.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-8.0.list
   

3. Aktualisiere die Paketdatenbank:

   sudo apt-get update
   

4. Installieren Sie die MongoDB Community Edition:

   sudo apt-get install -y mongodb-org
   

5. Starten Sie den MongoDB-Dienst:

   sudo systemctl start mongod
   

6. Überprüfen Sie die MongoDB-Installation:

   sudo systemctl status mongod
   

Nachdem Sie diese Schritte abgeschlossen haben, sollte MongoDB auf Ihrem Ubuntu-System installiert und ausgeführt werden.

Schritt 2 - PyMongo installieren

Erstelle ein Projektverzeichnis

Führe in deiner Shell den folgenden Befehl aus, um ein Verzeichnis namens pymongo-quickstart für dieses Projekt zu erstellen:

mkdir pymongo-quickstart

Führen Sie die folgenden Befehle aus, um eine quickstart.py Anwendungsdatei im Verzeichnis pymongo-quickstart zu erstellen:

cd pymongo-quickstart
touch quickstart.py

Lass uns eine virtuelle Umgebung erstellen und sie aktivieren:

python3 -m venv venv
source venv/bin/activate

Jetzt installieren wir PyMongo:

python3 -m pip install pymongo

Sie können auch die Schritte befolgen, die in dieser offiziellen Dokumentation von MongoDB angegeben sind, wie man pymongo herunterlädt und installiert.

Schritt 3 - Verbindung zu MongoDB Atlas in Python herstellen

Hier ist die Ordnerstruktur nach der Installation von pymongo:

root/              
├── pymongo-quickstart/  
│   └──     quickstart.py  
    └──     venv

In diesem Beispiel werden wir MongoDB Atlas verwenden, um einen kostenlosen MongoDB-Cluster zu Demonstrationszwecken bereitzustellen. MongoDB Atlas ist ein cloudbasierter MongoDB-Dienst, der es Benutzern ermöglicht, MongoDB-Cluster einfach in der Cloud bereitzustellen, zu verwalten und zu skalieren. Es bietet eine kostenlose Stufe, wodurch es eine ideale Wahl für Test- und Demonstrationszwecke ist.

Melden Sie sich bei MongoDB Cloud an und erstellen Sie einen kostenlosen MongoDB Atlas-Cluster aus der Atlas-Benutzeroberfläche.

pymongo.errors.ServerSelectionTimeoutError: SSL handshake failed: ac-r1katou-shard-00-01.1szm4t5.mongodb.net:27017: [SSL: TLSV1_ALERT_INTERNAL_ERROR] tlsv1 alert internal error (_ssl.c:1000) (configured timeouts: socketTimeoutMS: 20000.0ms, connectTimeoutMS: 20000.0ms),SSL handshake failed: ac-r1katou-shard-00-02.1szm4t5.mongodb.net:27017: [SSL: TLSV1_ALERT_INTERNAL_ERROR] tlsv1 alert internal error (_ssl.c:1000) (configured timeouts: socketTimeoutMS: 20000.0ms, connectTimeoutMS: 20000.0ms),SSL handshake failed: ac-r1katou-shard-00-00.1szm4t5.mongodb.net:27017: [SSL: TLSV1_ALERT_INTERNAL_ERROR] tlsv1 alert internal error (_ssl.c:1000) (configured timeouts: socketTimeoutMS: 20000.0ms, connectTimeoutMS: 20000.0ms), Timeout: 30s, Topology Description: <TopologyDescription id: 67e3a4be8b571dbdd9e11b91, topology_type: ReplicaSetNoPrimary, servers: [<ServerDescription ('ac-r1katou-shard-00-00.1szm4t5.mongodb.net', 27017) server_type: Unknown, rtt: None, error=AutoReconnect('SSL handshake failed: ac-r1katou-shard-00-00.1szm4t5.mongodb.net:27017: [SSL: TLSV1_ALERT_INTERNAL_ERROR] tlsv1 alert internal error (_ssl.c:1000) (configured timeouts: socketTimeoutMS: 20000.0ms, connectTimeoutMS: 20000.0ms)')>, <ServerDescription ('ac-r1katou-shard-00-01.1szm4t5.mongodb.net', 27017) server_type: Unknown, rtt: None, error=AutoReconnect('SSL handshake failed: ac-r1katou-shard-00-01.1szm4t5.mongodb.net:27017: [SSL: TLSV1_ALERT_INTERNAL_ERROR] tlsv1 alert internal error (_ssl.c:1000) (configured timeouts: socketTimeoutMS: 20000.0ms, connectTimeoutMS: 20000.0ms)')>, <ServerDescription ('ac-r1katou-shard-00-02.1szm4t5.mongodb.net', 27017) server_type: Unknown, rtt: None, error=AutoReconnect('SSL handshake failed: ac-r1katou-shard-00-02.1szm4t5.mongodb.net:27017: [SSL: TLSV1_ALERT_INTERNAL_ERROR] tlsv1 alert internal error (_ssl.c:1000) (configured timeouts: socketTimeoutMS: 20000.0ms, connectTimeoutMS: 20000.0ms)')>]

Um mit dem MongoDB Atlas-Cluster zu interagieren, stellen Sie eine Verbindung mit PyMongo her. Wir werden einen Beispiel-Datensatz verwenden, der von MongoDB Atlas bereitgestellt wird.

Sie können die Verbindungszeichenfolge des MongoDB Atlas-Clusters im Übersicht -> Verbinden -> Verbindungsanweisungen-Tab finden.

Fügen Sie die folgenden Codezeilen in die Datei /root/pymongo-quickstart/quickstart.py ein:

import pymongo
from pymongo import MongoClient

Attempt to connect to the MongoDB cluster using the provided URI
try:
    uri = "mongodb+srv://<db_username>:<db_password>@cluster0.1szm4t5.mongodb.net/?retryWrites=true&w=majority&appName=Cluster0"
    client = MongoClient(uri)
    
    # Select the database and collection to work with
    database = client["sample_mflix"]
    collection = database["movies"]
    
    # This section is intentionally left blank for future code examples
    # Example code can be added here to interact with the MongoDB collection
    
    # Close the MongoDB client connection
    client.close()
except Exception as e:
    # If any error occurs during the connection or interaction, raise an exception with the error details
    raise Exception(
        "The following error occurred: ", e)

Holen Sie sich ein Beispieldokument mit find_one()

Der folgende Befehl ruft ein einzelnes Filmdokument aus dem Datensatz ab.

print(collection.find_one())

Sie erhalten die folgende Ausgabe, nachdem Sie die Python-Datei ausgeführt haben:

python quickstart.py

{'_id': ObjectId('573a1390f29313caabcd42e8'), 'plot': 'A group of bandits stage a brazen train hold-up, only to find a determined posse hot on their heels.', 'genres': ['Short', 'Western'], 'runtime': 11, 'cast': ['A.C. Abadie', "Gilbert M. 'Broncho Billy' Anderson", 'George Barnes', 'Justus D. Barnes'], 'poster': 'https://m.media-amazon.com/images/M/MV5BMTU3NjE5NzYtYTYyNS00MDVmLWIwYjgtMmYwYWIxZDYyNzU2XkEyXkFqcGdeQXVyNzQzNzQxNzI@._V1_SY1000_SX677_AL_.jpg', 'title': 'The Great Train Robbery', 'fullplot': "Among the earliest existing films in American cinema - notable as the first film that presented a narrative story to tell - it depicts a group of cowboy outlaws who hold up a train and rob the passengers. They are then pursued by a Sheriff's posse. Several scenes have color included - all hand tinted.", 'languages': ['English'], 'released': datetime.datetime(1903, 12, 1, 0, 0), 'directors': ['Edwin S. Porter'], 'rated': 'TV-G', 'awards': {'wins': 1, 'nominations': 0, 'text': '1 win.'}, 'lastupdated': '2015-08-13 00:27:59.177000000', 'year': 1903, 'imdb': {'rating': 7.4, 'votes': 9847, 'id': 439}, 'countries': ['USA'], 'type': 'movie', 'tomatoes': {'viewer': {'rating': 3.7, 'numReviews': 2559, 'meter': 75}, 'fresh': 6, 'critic': {'rating': 7.6, 'numReviews': 6, 'meter': 100}, 'rotten': 0, 'lastUpdated': datetime.datetime(2015, 8, 8, 19, 16, 10)}, 'num_mflix_comments': 0}

Für mehr Informationen zu findOne(), besuchen Sie das MongoDB findOne() Beispiel-Tutorial.

Dokumente mit find() abrufen

Die find()-Methode ruft Dokumente ab, die einem bestimmten Filter entsprechen.

Innerhalb der quickstart.py Datei können Sie den folgenden Code hinzufügen, um die Daten abzufragen:

Get all movies
docs = collection.find().limit(5)
for movie in docs:
    print(movie)

Wenn Sie diese Python-Datei ausführen, erhalten Sie die folgende Ausgabe:

python quickstart.py

{'_id': ObjectId('573a1390f29313caabcd42e8'), 'plot': 'A group of bandits stage a brazen train hold-up, only to find a determined posse hot on their heels.', 'genres': ['Short', 'Western'], 'runtime': 11, 'cast': ['A.C. Abadie', "Gilbert M. 'Broncho Billy' Anderson", 'George Barnes', 'Justus D. Barnes'], 'poster': 'https://m.media-amazon.com/images/M/MV5BMTU3NjE5NzYtYTYyNS00MDVmLWIwYjgtMmYwYWIxZDYyNzU2XkEyXkFqcGdeQXVyNzQzNzQxNzI@._V1_SY1000_SX677_AL_.jpg', 'title': 'The Great Train Robbery', 'fullplot': "Among the earliest existing films in American cinema - notable as the first film that presented a narrative story to tell - it depicts a group of cowboy outlaws who hold up a train and rob the passengers. They are then pursued by a Sheriff's posse. Several scenes have color included - all hand tinted.", 'languages': ['English'], 'released': datetime.datetime(1903, 12, 1, 0, 0), 'directors': ['Edwin S. Porter'], 'rated': 'TV-G', 'awards': {'wins': 1, 'nominations': 0, 'text': '1 win.'}, 'lastupdated': '2015-08-13 00:27:59.177000000', 'year': 1903, 'imdb': {'rating': 7.4, 'votes': 9847, 'id': 439}, 'countries': ['USA'], 'type': 'movie', 'tomatoes': {'viewer': {'rating': 3.7, 'numReviews': 2559, 'meter': 75}, 'fresh': 6, 'critic': {'rating': 7.6, 'numReviews': 6, 'meter': 100}, 'rotten': 0, 'lastUpdated': datetime.datetime(2015, 8, 8, 19, 16, 10)}, 'num_mflix_comments': 0}
{'_id': ObjectId('573a1390f29313caabcd446f'), 'plot': "A greedy tycoon decides, on a whim, to corner the world market in wheat. This doubles the price of bread, forcing the grain's producers into charity lines and further into poverty. The film...", 'genres': ['Short', 'Drama'], 'runtime': 14, 'cast': ['Frank Powell', 'Grace Henderson', 'James Kirkwood', 'Linda Arvidson'], 'num_mflix_comments': 1, 'title': 'A Corner in Wheat', 'fullplot': "A greedy tycoon decides, on a whim, to corner the world market in wheat. This doubles the price of bread, forcing the grain's producers into charity lines and further into poverty. The film continues to contrast the ironic differences between the lives of those who work to grow the wheat and the life of the man who dabbles in its sale for profit.", 'languages': ['English'], 'released': datetime.datetime(1909, 12, 13, 0, 0), 'directors': ['D.W. Griffith'], 'rated': 'G', 'awards': {'wins': 1, 'nominations': 0, 'text': '1 win.'}, 'lastupdated': '2015-08-13 00:46:30.660000000', 'year': 1909, 'imdb': {'rating': 6.6, 'votes': 1375, 'id': 832}, 'countries': ['USA'], 'type': 'movie', 'tomatoes': {'viewer': {'rating': 3.6, 'numReviews': 109, 'meter': 73}, 'lastUpdated': datetime.datetime(2015, 5, 11, 18, 36, 53)}}
{'_id': ObjectId('573a1390f29313caabcd4803'), 'plot': 'Cartoon figures announce, via comic strip balloons, that they will move - and move they do, in a wildly exaggerated style.', 'genres': ['Animation', 'Short', 'Comedy'], 'runtime': 7, 'cast': ['Winsor McCay'], 'num_mflix_comments': 0, 'poster': 'https://m.media-amazon.com/images/M/MV5BYzg2NjNhNTctMjUxMi00ZWU4LWI3ZjYtNTI0NTQxNThjZTk2XkEyXkFqcGdeQXVyNzg5OTk2OA@@._V1_SY1000_SX677_AL_.jpg', 'title': 'Winsor McCay, the Famous Cartoonist of the N.Y. Herald and His Moving Comics', 'fullplot': 'Cartoonist Winsor McCay agrees to create a large set of drawings that will be photographed and made into a motion picture. The job requires plenty of drawing supplies, and the cartoonist must also overcome some mishaps caused by an assistant. Finally, the work is done, and everyone can see the resulting animated picture.', 'languages': ['English'], 'released': datetime.datetime(1911, 4, 8, 0, 0), 'directors': ['Winsor McCay', 'J. Stuart Blackton'], 'writers': ['Winsor McCay (comic strip "Little Nemo in Slumberland")', 'Winsor McCay (screenplay)'], 'awards': {'wins': 1, 'nominations': 0, 'text': '1 win.'}, 'lastupdated': '2015-08-29 01:09:03.030000000', 'year': 1911, 'imdb': {'rating': 7.3, 'votes': 1034, 'id': 1737}, 'countries': ['USA'], 'type': 'movie', 'tomatoes': {'viewer': {'rating': 3.4, 'numReviews': 89, 'meter': 47}, 'lastUpdated': datetime.datetime(2015, 8, 20, 18, 51, 24)}}
{'_id': ObjectId('573a1390f29313caabcd4eaf'), 'plot': 'A woman, with the aid of her police officer sweetheart, endeavors to uncover the prostitution ring that has kidnapped her sister, and the philanthropist who secretly runs it.', 'genres': ['Crime', 'Drama'], 'runtime': 88, 'cast': ['Jane Gail', 'Ethel Grandin', 'William H. Turner', 'Matt Moore'], 'num_mflix_comments': 1, 'poster': 'https://m.media-amazon.com/images/M/MV5BYzk0YWQzMGYtYTM5MC00NjM2LWE5YzYtMjgyNDVhZDg1N2YzXkEyXkFqcGdeQXVyMzE0MjY5ODA@._V1_SY1000_SX677_AL_.jpg', 'title': 'Traffic in Souls', 'lastupdated': '2015-09-15 02:07:14.247000000', 'languages': ['English'], 'released': datetime.datetime(1913, 11, 24, 0, 0), 'directors': ['George Loane Tucker'], 'rated': 'TV-PG', 'awards': {'wins': 1, 'nominations': 0, 'text': '1 win.'}, 'year': 1913, 'imdb': {'rating': 6.0, 'votes': 371, 'id': 3471}, 'countries': ['USA'], 'type': 'movie', 'tomatoes': {'viewer': {'rating': 3.0, 'numReviews': 85, 'meter': 57}, 'dvd': datetime.datetime(2008, 8, 26, 0, 0), 'lastUpdated': datetime.datetime(2015, 8, 10, 18, 33, 55)}}
{'_id': ObjectId('573a1390f29313caabcd50e5'), 'plot': 'The cartoonist, Winsor McCay, brings the Dinosaurus back to life in the figure of his latest creation, Gertie the Dinosaur.', 'genres': ['Animation', 'Short', 'Comedy'], 'runtime': 12, 'cast': ['Winsor McCay', 'George McManus', 'Roy L. McCardell'], 'num_mflix_comments': 0, 'poster': 'https://m.media-amazon.com/images/M/MV5BMTQxNzI4ODQ3NF5BMl5BanBnXkFtZTgwNzY5NzMwMjE@._V1_SY1000_SX677_AL_.jpg', 'title': 'Gertie the Dinosaur', 'fullplot': 'Winsor Z. McCay bets another cartoonist that he can animate a dinosaur. So he draws a big friendly herbivore called Gertie. Then he get into his own picture. Gertie walks through the picture, eats a tree, meets her creator, and takes him carefully on her back for a ride.', 'languages': ['English'], 'released': datetime.datetime(1914, 9, 15, 0, 0), 'directors': ['Winsor McCay'], 'writers': ['Winsor McCay'], 'awards': {'wins': 1, 'nominations': 0, 'text': '1 win.'}, 'lastupdated': '2015-08-18 01:03:15.313000000', 'year': 1914, 'imdb': {'rating': 7.3, 'votes': 1837, 'id': 4008}, 'countries': ['USA'], 'type': 'movie', 'tomatoes': {'viewer': {'rating': 3.7, 'numReviews': 29}, 'lastUpdated': datetime.datetime(2015, 8, 10, 19, 20, 3)}}

Filterabfragen

In der quickstart.py-Datei können wir den folgenden Code hinzufügen, um Filme zu finden, die nach dem Jahr 2000 veröffentlicht wurden.

Find movies released after 2000
query = {"year": {"$gt": 2000}}
for movie in collection.find(query).limit(2):
    print(movie)

Dies wird die folgende Ausgabe ergeben:

{'_id': ObjectId('573a1393f29313caabcdcb42'), 'plot': 'Kate and her actor brother live in N.Y. in the 21st Century. Her ex-boyfriend, Stuart, lives above her apartment. Stuart finds a space near the Brooklyn Bridge where there is a gap in time....', 'genres': ['Comedy', 'Fantasy', 'Romance'], 'runtime': 118, 'metacritic': 44, 'rated': 'PG-13', 'cast': ['Meg Ryan', 'Hugh Jackman', 'Liev Schreiber', 'Breckin Meyer'], 'poster': 'https://m.media-amazon.com/images/M/MV5BNmNlN2VlOTctYTdhMS00NzUxLTg0ZGMtYWE2ZTJmMThlMTk2XkEyXkFqcGdeQXVyMzI0NDc4ODY@._V1_SY1000_SX677_AL_.jpg', 'title': 'Kate & Leopold', 'fullplot': "Kate and her actor brother live in N.Y. in the 21st Century. Her ex-boyfriend, Stuart, lives above her apartment. Stuart finds a space near the Brooklyn Bridge where there is a gap in time. He goes back to the 19th Century and takes pictures of the place. Leopold -- a man living in the 1870s -- is puzzled by Stuart's tiny camera, follows him back through the gap, and they both ended up in the present day. Leopold is clueless about his new surroundings. He gets help and insight from Charlie who thinks that Leopold is an actor who is always in character. Leopold is a highly intelligent man and tries his best to learn and even improve the modern conveniences that he encounters.", 'languages': ['English', 'French'], 'released': datetime.datetime(2001, 12, 25, 0, 0), 'directors': ['James Mangold'], 'writers': ['Steven Rogers (story)', 'James Mangold (screenplay)', 'Steven Rogers (screenplay)'], 'awards': {'wins': 2, 'nominations': 4, 'text': 'Nominated for 1 Oscar. Another 1 win & 4 nominations.'}, 'lastupdated': '2015-08-31 00:19:09.717000000', 'year': 2001, 'imdb': {'rating': 6.3, 'votes': 59951, 'id': 35423}, 'countries': ['USA'], 'type': 'movie', 'tomatoes': {'website': 'http://www.kateandleopold-themovie.com', 'viewer': {'rating': 3.0, 'numReviews': 189426, 'meter': 62}, 'dvd': datetime.datetime(2002, 6, 11, 0, 0), 'critic': {'rating': 5.3, 'numReviews': 126, 'meter': 50}, 'boxOffice': '$47.1M', 'consensus': 'Though Jackman charms, Kate and Leopold is bland and predictable, and the time travel scenario lacks inner logic.', 'rotten': 63, 'production': 'Miramax Films', 'lastUpdated': datetime.datetime(2015, 8, 22, 18, 53, 25), 'fresh': 63}, 'num_mflix_comments': 0}
{'_id': ObjectId('573a1398f29313caabceb1fe'), 'plot': "A modern day adaptation of Dostoyevsky's classic novel about a young student who is forever haunted by the murder he has committed.", 'genres': ['Drama'], 'runtime': 126, 'cast': ['Crispin Glover', 'Vanessa Redgrave', 'John Hurt', 'Margot Kidder'], 'poster': 'https://m.media-amazon.com/images/M/MV5BMTI3MDQ2MzEyOV5BMl5BanBnXkFtZTcwNzEwODUzMQ@@._V1_SY1000_SX677_AL_.jpg', 'title': 'Crime and Punishment', 'fullplot': "A modern day adaptation of Dostoyevsky's classic novel about a young student who is forever haunted by the murder he has committed.", 'languages': ['English', 'Polish'], 'released': datetime.datetime(2002, 6, 1, 0, 0), 'directors': ['Menahem Golan'], 'writers': ['Fyodor Dostoevsky (novel)', 'Menahem Golan (adaptation)', 'Menahem Golan (screenplay)'], 'awards': {'wins': 2, 'nominations': 0, 'text': '2 wins.'}, 'lastupdated': '2015-08-13 00:34:02.303000000', 'year': 2002, 'imdb': {'rating': 6.4, 'votes': 463, 'id': 96056}, 'countries': ['USA', 'Poland', 'Russia'], 'type': 'movie', 'tomatoes': {'viewer': {'rating': 0.0, 'numReviews': 0}, 'lastUpdated': datetime.datetime(2015, 7, 22, 18, 45, 10)}, 'num_mflix_comments': 0}

Bestimmte Spalten filtern

In der quickstart.py-Datei können wir den folgenden Code hinzufügen, um Filme zu finden, die nach 2000 veröffentlicht wurden, und nur den Titel und die IMDb-Bewertung anzuzeigen.

Find movies released after 2000 and only display the title and IMDb rating
query = {"year": {"$gt": 2000}}  # This query filters movies released after the year 2000
projection = {"_id": 0, "title": 1, "imdb.rating": 1}  # This projection specifies which fields to include in the result
The "_id": 0 excludes the default "_id" field from the result, while "title": 1 and "imdb.rating": 1 include the title and IMDb rating respectively
for movie in collection.find(query, projection).limit(10):  # This loop iterates over the results of the query, limited to the first 10 matches
    print(movie)  # Each movie document is printed, showing only the title and IMDb rating as specified in the projection

In diesem Codeblock verwenden wir den projection-Parameter in der find()-Methode, um festzulegen, welche Felder im Ergebnis einbezogen werden sollen. Das _id-Feld wird mit "_id": 0 vom Ergebnis ausgeschlossen, und die Felder title und imdb.rating werden mit 1 einbezogen. Die limit(10)-Methode wird verwendet, um die Anzahl der Ergebnisse auf 10 zu beschränken.

Sie können mehr über Projektionen in MongoDB erfahren.

Hier ist die Ausgabe:

{'title': 'Kate & Leopold', 'imdb': {'rating': 6.3}}
{'title': 'Crime and Punishment', 'imdb': {'rating': 6.4}}
{'imdb': {'rating': 2.1}, 'title': 'Glitter'}
{'imdb': {'rating': 5.5}, 'title': 'The Manson Family'}
{'title': 'The Dancer Upstairs', 'imdb': {'rating': 7.0}}
{'imdb': {'rating': 5.7}, 'title': 'Fantastic Four'}
{'imdb': {'rating': 7.4}, 'title': 'Frida'}
{'imdb': {'rating': 6.8}, 'title': 'From Hell'}
{'imdb': {'rating': 6.3}, 'title': 'Kate & Leopold'}
{'imdb': {'rating': 8.8}, 'title': 'The Lord of the Rings: The Fellowship of the Ring'}

Abfragen von verschachtelten Feldern und Arrays

Zugriff auf verschachtelte Felder

Im folgenden Code fragen wir die Datenbank ab, um Filme mit einer IMDb-Bewertung von 8 oder höher zu finden.

query = {"imdb.rating": {"$gte": 8}}
projection = {"_id": 0, "title": 1, "imdb.rating": 1}
for movie in collection.find(query, projection).limit(5):
    print(movie)

Dieser Codeblock fragt die Datenbank ab, um Filme mit einer IMDb-Bewertung von 8 oder höher zu finden. Er projiziert dann nur den Titel und die IMDb-Bewertung der Filme. Das Limit ist auf 5 festgelegt, sodass nur die ersten 5 Filme zurückgegeben werden, die der Abfrage entsprechen.

Hier ist die Ausgabe

{'title': 'One Week', 'imdb': {'rating': 8.3}}
{'title': "Tol'able David", 'imdb': {'rating': 8.1}}
{'title': 'Ella Cinders', 'imdb': {'rating': 8.1}}
{'title': 'City Lights', 'imdb': {'rating': 8.6}}
{'title': 'The Music Box', 'imdb': {'rating': 8.1}}

Arrays filtern

In diesem Codeausschnitt filtern wir die Filme, die zum Action-Genre gehören, und projizieren nur den Titel und die IMDb-Bewertung der Filme.

query = {"genres": "Action"}  # Finds movies that belong to the Action genre
projection = {"_id": 0, "title": 1, "imdb.rating": 1}
for movie in collection.find(query, projection).limit(10):
    print(movie)

{'title': 'The Perils of Pauline', 'imdb': {'rating': 7.6}}
{'title': 'From Hand to Mouth', 'imdb': {'rating': 7.0}}
{'title': 'Beau Geste', 'imdb': {'rating': 6.9}}
{'title': 'The Black Pirate', 'imdb': {'rating': 7.2}}
{'title': "For Heaven's Sake", 'imdb': {'rating': 7.6}}
{'title': 'Men Without Women', 'imdb': {'rating': 5.8}}
{'title': 'The Crowd Roars', 'imdb': {'rating': 6.4}}
{'title': 'Scarface', 'imdb': {'rating': 7.8}}
{'title': 'Tarzan the Ape Man', 'imdb': {'rating': 7.2}}
{'title': 'China Seas', 'imdb': {'rating': 7.0}}

Verwendung von Aggregationspipelines für komplexe Abfragen

Aggregation-Pipelines in MongoDB sind eine Möglichkeit, Daten in einer Reihe von Phasen zu verarbeiten. Jede Phase transformiert die Dokumente, während sie durch die Pipeline fließen. Dies ermöglicht komplexere und leistungsstärkere Abfragen als einfache Find-Operationen.

This code block uses MongoDB's aggregation pipeline to process data in a series of stages.
The pipeline consists of two stages:
1. The "$match" stage filters the documents to only include those where the "year" field is greater than or equal to 2010.
2. The "$group" stage groups the filtered documents by their "genres" field and calculates the average "imdb.rating" for each group.
pipeline = [
    {"$match": {"year": {"$gte": 2010}}},
    {"$group": {"_id": "$genres", "averageIMDB": {"$avg": "$imdb.rating"}}}
]
The result of the aggregation pipeline is stored in the "result" variable.
result = collection.aggregate(pipeline)
Finally, the code iterates over the "result" and prints each document, which represents the average IMDb rating for each genre of movies released in or after 2010.
for doc in result:
    print(doc)

Dieser Codeblock verwendet die Aggregationspipeline von MongoDB, um Daten in einer Reihe von Stufen zu verarbeiten.

Die Pipeline besteht aus zwei Phasen:

1. Die „$match“-Phase filtert die Dokumente, um nur diejenigen einzuschließen, bei denen das „Jahr“-Feld größer oder gleich 2010 ist.
2. Die „$group“-Anweisung gruppiert die gefilterten Dokumente nach ihrem „genres“-Feld und berechnet den Durchschnitt der „imdb.rating“ für jede Gruppe.

Das Ergebnis des Aggregationspipelines wird in der “result ” Variable gespeichert.

Schließlich durchläuft der Code das „Ergebnis“ und druckt jedes Dokument aus, das die durchschnittliche IMDb-Bewertung für jedes Genre von Filmen darstellt, die 2010 oder später veröffentlicht wurden.

Hier ist die Ausgabe, wenn diese Abfrage ausgeführt wird:

{'_id': ['Comedy', 'Fantasy', 'Thriller'], 'averageIMDB': 6.4}
{'_id': ['Fantasy', 'Mystery', 'Thriller'], 'averageIMDB': 7.1}
{'_id': ['Comedy', 'Romance'], 'averageIMDB': 6.198165137614679}
{'_id': ['Animation', 'Short', 'Action'], 'averageIMDB': 7.1499999999999995}
{'_id': ['Action', 'Comedy', 'Fantasy'], 'averageIMDB': 6.2}
{'_id': ['Drama', 'War'], 'averageIMDB': 6.872413793103449}
{'_id': ['Horror', 'Sci-Fi', 'Thriller'], 'averageIMDB': 4.941666666666666}
{'_id': ['Documentary', 'Crime'], 'averageIMDB': 7.071428571428571}
{'_id': ['Animation', 'Short', 'Crime'], 'averageIMDB': 7.2}
{'_id': ['Documentary', 'History', 'News'], 'averageIMDB': 7.1000000000000005}
{'_id': ['Comedy', 'Crime', 'Thriller'], 'averageIMDB': 7.140000000000001}
{'_id': ['Comedy', 'Family', 'Romance'], 'averageIMDB': 6.24}
{'_id': ['Crime', 'Drama', 'Horror'], 'averageIMDB': 6.225}
{'_id': ['Comedy', 'Horror', 'Thriller'], 'averageIMDB': 5.642857142857143}
{'_id': ['Documentary', 'Animation', 'News'], 'averageIMDB': 7.2}
{'_id': ['Biography', 'Drama', 'War'], 'averageIMDB': 6.2}
{'_id': ['Fantasy', 'Thriller'], 'averageIMDB': 6.3}
{'_id': ['Drama', 'Horror', 'Mystery'], 'averageIMDB': 6.218181818181819}
{'_id': ['Adventure', 'Drama', 'Sci-Fi'], 'averageIMDB': 8.7}
{'_id': ['Comedy', 'Music'], 'averageIMDB': 6.359999999999999}
{'_id': ['Action', 'Comedy', 'Sport'], 'averageIMDB': 6.5}
{'_id': ['Drama', 'Family', 'Sci-Fi'], 'averageIMDB': 6.3}
{'_id': ['Action', 'Drama', 'Fantasy'], 'averageIMDB': 5.824999999999999}
{'_id': ['Drama', 'Music', 'Musical'], 'averageIMDB': 4.9}

Unterschiede zwischen den Methoden find() und aggregate()

db.collection.find({}) vs db.collection.aggregate([{ $match: {} }])

db.collection.find({ year: { $gte: 2010 } }) vs db.collection.aggregate([{ $match: { year: { $gte: 2010 } } }, { $group: { _id: "$genres", averageIMDB: { $avg: "$imdb.rating" } } }])

db.collection.find({ genres: "Comedy" }) vs db.collection.aggregate([{ $match: { genres: "Comedy" } }, { $group: { _id: "$genres", count: { $sum: 1 } } }])

Die find() Methode ist eine unkomplizierte Möglichkeit, Daten aus einer MongoDB-Sammlung abzurufen. Sie ist ideal für einfache Abfragen, die das Filtern und Abrufen von Daten basierend auf bestimmten Bedingungen erfordern. Sie hat jedoch Einschränkungen, wenn es um komplexe Datenveränderungen und Berechnungen geht.

Auf der anderen Seite ist die aggregate()-Methode ein leistungsstarkes Werkzeug zur Verarbeitung von Daten in einer Reihe von Phasen. Sie ist dafür ausgelegt, komplexe Datenumwandlungen, Aggregationen und Berechnungen zu handhaben. Während sie komplizierter zu verwenden sein kann als find(), bietet sie eine breite Palette von Operatoren und Phasen, die kombiniert werden können, um anspruchsvolle Datenverarbeitungsaufgaben durchzuführen.

Bei der Entscheidung zwischen find() und aggregate() sollten Sie die Komplexität Ihrer Abfrage und die Art der erforderlichen Datenverarbeitung berücksichtigen. Wenn Sie einfache Filterung und Abfrage durchführen müssen, könnte find() die bessere Wahl sein. Wenn Sie jedoch Datenumwandlungen, Aggregationen oder Berechnungen durchführen müssen, ist aggregate() wahrscheinlich die bessere Option.

Optimierung von MongoDB-Abfragen für die Leistung

Verwenden Sie Indizes

Die Erstellung eines Index auf einem Feld kann die Abfrageleistung erheblich verbessern, insbesondere bei Feldern, die in Abfragefiltern oder Sortierungen verwendet werden. In diesem Beispiel erstellen wir einen Index auf dem Feld "Jahr", um Abfragen zu optimieren, die Filme nach Veröffentlichungsjahr filtern.

collection.create_index("year")

Ergebnisse einschränken

Die Begrenzung der Anzahl der durch eine Abfrage zurückgegebenen Ergebnisse kann die Menge der übertragenen und verarbeiteten Daten reduzieren, was zu einer verbesserten Leistung führt. Dies ist besonders nützlich, wenn Sie nur einen Teil der Daten benötigen oder die Paginierung implementieren möchten. Hier begrenzen wir die Ergebnisse auf die ersten 10 gefundenen Filme.

for movie in collection.find().limit(10):
    print(movie)

Projekt spezifische Felder

Die Projektion spezifischer Felder in einer Abfrage ermöglicht es Ihnen, nur die Daten abzurufen, die Sie benötigen, wodurch die Menge der übertragenen und verarbeiteten Daten verringert wird. Dies kann die Leistung verbessern und die Netzwerküberlastung reduzieren. In diesem Beispiel projizieren wir nur das Feld "Titel" und schließen das Feld "_id" aus, um nur die Titel der Filme anzuzeigen.

for movie in collection.find({}, {"title": 1, "_id": 0}):
    print(movie)

Häufig gestellte Fragen

1. Wie frage ich Daten in MongoDB mit Python ab?

Beim Abfragen von Daten in MongoDB mit Python stehen Ihnen zwei Hauptmethoden zur Verfügung: find() und aggregate(). Die Wahl zwischen diesen Methoden hängt von der Komplexität Ihrer Abfrage und der Art der erforderlichen Datenverarbeitung ab.

Basisabfragen mit find()

Die find()-Methode eignet sich für einfache Abfragen, die das Filtern und Abrufen von Daten basierend auf bestimmten Bedingungen erfordern. Sie ist ideal für Aufgaben wie:

• Alle Dokumente in einer Sammlung abrufen: db.collection.find()
• Filterung von Dokumenten basierend auf einer Bedingung: db.collection.find({"jahr": 2010})
• Abrufen spezifischer Felder: db.collection.find({}, {"title": 1, "_id": 0})

Hier ist ein Beispiel für die Verwendung von find(), um alle Filme abzurufen, die im Jahr 2010 veröffentlicht wurden:

for movie in db.movies.find({"year": 2010}):
    print(movie)

Erweiterte Abfragen mit aggregate()

Die aggregate()-Methode ist für komplexe Datenumwandlungen, Aggregationen und Berechnungen konzipiert. Sie eignet sich ideal für Aufgaben wie:

• Dokumente basierend auf einem Feld gruppieren und einen Durchschnitt berechnen: db.collection.aggregate([{ $group: { _id: "$genres", averageIMDB: { $avg: "$imdb.rating" } } }])
• Dokumente basierend auf einer Bedingung filtern und dann gruppieren: db.collection.aggregate([{ $match: { Jahr: 2010 } }, { $group: { _id: "$genres", anzahl: { $sum: 1 } } }])

Hier ist ein Beispiel für die Verwendung von aggregate(), um die durchschnittliche IMDB-Bewertung für Filme in jedem Genre zu berechnen:

for result in db.movies.aggregate([{ $group: { _id: "$genres", averageIMDB: { $avg: "$imdb.rating" } } }]):
    print(result)

Zusammenfassend lässt sich sagen, dass Sie find() für grundlegende Abfragen verwenden sollten, die einfache Filterung und Abruf erfordern, und aggregate() für erweiterte Abfragen, die komplexe Datenumwandlungen und Berechnungen erfordern.

2. Was ist der Unterschied zwischen find() und aggregate()?

Die find() Methode ist eine unkomplizierte Möglichkeit, Daten aus einer MongoDB-Sammlung abzurufen. Sie ist ideal für einfache Abfragen, die das Filtern und Abrufen von Daten basierend auf bestimmten Bedingungen erfordern. Sie hat jedoch Einschränkungen, wenn es um komplexe Datenveränderungen und Berechnungen geht.

Auf der anderen Seite ist die aggregate()-Methode ein leistungsstarkes Werkzeug zur Verarbeitung von Daten in einer Reihe von Phasen. Sie ist dafür ausgelegt, komplexe Datenumwandlungen, Aggregationen und Berechnungen zu handhaben. Während sie komplizierter zu verwenden sein kann als find(), bietet sie eine breite Palette von Operatoren und Phasen, die kombiniert werden können, um anspruchsvolle Datenverarbeitungsaufgaben durchzuführen.

3. Wie filtere ich Daten in MongoDB mit Python?

Um Daten in MongoDB mit Python zu filtern, können Sie die { "field": { "$operator": value } } Syntax verwenden. Diese Syntax ermöglicht es Ihnen, ein Feld, einen Operator und einen Wert anzugeben, um die Daten zu filtern. Hier ist ein Beispielcode, der demonstriert, wie man Dokumente filtert, bei denen das Feld “jahr” gleich 2020 ist:

for movie in db.movies.find({"year": { "$eq": 2020 }}):
    print(movie)

4. Kann ich verschachtelte Dokumente in MongoDB abfragen?

Ja, Sie können in MongoDB verschachtelte Dokumente mit Punktnotation abfragen. Die Punktnotation ermöglicht es Ihnen, auf Felder innerhalb verschachtelter Dokumente zuzugreifen. Die Syntax für die Punktnotation lautet { "nested.field": value }.

Zum Beispiel, wenn Sie eine Dokumentstruktur wie diese haben:

{
  "name": "John Doe",
  "address": {
    "street": "123 Main St",
    "city": "Anytown",
    "state": "CA",
    "zip": "12345"
  }
}

Sie können Dokumente abfragen, in denen das Feld „Stadt“ im geschachtelten Dokument „Adresse“ „Anytown“ ist, indem Sie den folgenden Code verwenden:

for document in db.collection.find({"address.city": "Anytown"}):
    print(document)

Dies gibt alle Dokumente zurück, bei denen das “city ”-Feld im “address ”-verschachtelten Dokument mit “Anytown ” übereinstimmt.

5. Wie optimiere ich MongoDB-Abfragen für große Datensätze?

Sie können Techniken wie Indizierung, Projektion und Ergebnisbegrenzung verwenden, um die Leistung zu verbessern, wie in den oben genannten Abschnitten besprochen.

6. Was sind die besten Bibliotheken für MongoDB-Abfragen in Python?

• pymongo (offizieller MongoDB-Treiber)

• mongoengine (Objekt-Dokumenten-Mapper)

Für weitere Tutorials zur Verwaltung von MongoDB schauen Sie sich unsere Tutorialreihe zum Thema Datenmanagement mit MongoDB an.

Schlussfolgerung

Zusammenfassend lässt sich sagen, dass das Abfragen von MongoDB in Python eine entscheidende Fähigkeit für jeden Entwickler ist, der mit großen Datensätzen arbeitet. Dieses Tutorial hat verschiedene Techniken zum Abfragen von MongoDB in Python behandelt, einschließlich des Abrufens von Dokumenten mit Filtern, dem Abfragen von geschachtelten Feldern und Arrays, der Verwendung von Aggregations-Pipelines und bewährten Methoden zur Optimierung von Abfragen.

In diesem Tutorial haben Sie gelernt:

• Erstellen grundlegender Abfragen mit der find()-Methode, um bestimmte Dokumente abzurufen
• Filterung von verschachtelten Feldern und Arrays, um spezifische Daten zu zielen und die Menge der abgerufenen Daten zu reduzieren.
• Nutzung von Aggregationspipelines mit aggregate() für komplexe Datenverarbeitung, wie Datenumwandlung, Gruppierung und Sortierung.
• Abfrageoptimierung für die Leistung bei großen Datensätzen durch die Verwendung von Indizes, Projektionen und Limits, um die Belastung der Datenbank zu reduzieren und die Abfrageeffizienz zu verbessern.

Durch das Beherrschen dieser Techniken werden Sie in der Lage sein, Daten in Ihren MongoDB-Sammlungen effizient abzurufen und zu bearbeiten, was Sie zu einem effektiveren Entwickler im Umgang mit großen Datensätzen macht.

Für weiterführende Lektüre, erkunden Sie:

• Wie man Abfragen in der MongoDB-Tutorialreihe erstellt.

• Wie man Abfragen in MongoDB erstellt.