Python i MongoDB:łączenie się z bazami danych NoSQL

Jeśli chodzi o stronę operacyjną, MongoDB zapewnia kilka narzędzi i funkcji, których nie znajdziesz w innych systemach baz danych:

• Skalowalność: Niezależnie od tego, czy potrzebujesz autonomicznego serwera, czy kompletnych klastrów niezależnych serwerów, możesz skalować MongoDB do dowolnego rozmiaru.
• Obsługa równoważenia obciążenia: MongoDB automatycznie przeniesie dane między różnymi fragmentami.
• Obsługa automatycznego przełączania awaryjnego: Jeśli Twój główny serwer ulegnie awarii, nowy podstawowy zostanie uruchomiony automatycznie.
• Narzędzia do zarządzania: Możesz śledzić swoje maszyny za pomocą opartej na chmurze usługi zarządzania MongoDB (MMS).
• Wydajność pamięci: Dzięki plikom mapowanym w pamięci, MongoDB jest często wydajniejszy niż relacyjne bazy danych.

Wszystkie te funkcje są bardzo przydatne. Na przykład, jeśli skorzystasz z funkcji indeksowania, większość danych będzie przechowywana w pamięci w celu szybkiego odzyskania. Nawet bez indeksowania określonych kluczy dokumentów, MongoDB buforuje sporo danych przy użyciu najrzadziej używanej techniki.

Instalowanie i uruchamianie MongoDB

Teraz, gdy znasz MongoDB, nadszedł czas, aby ubrudzić sobie ręce i zacząć z niego korzystać. Ale najpierw musisz zainstalować go na swoim komputerze. Oficjalna strona MongoDB udostępnia dwie edycje serwera bazy danych:

1. Wersja Community oferuje elastyczny model dokumentów wraz z zapytaniami ad hoc, indeksowaniem i agregacją w czasie rzeczywistym, zapewniając zaawansowane sposoby uzyskiwania dostępu do danych i ich analizowania. Ta edycja jest dostępna bezpłatnie.
2. Wersja Enterprise oferuje te same funkcje, co wersja społecznościowa, a także inne zaawansowane funkcje związane z bezpieczeństwem i monitorowaniem. To jest wersja komercyjna, ale możesz jej używać bezpłatnie przez nieograniczony czas do celów ewaluacyjnych i programistycznych.

Jeśli korzystasz z systemu Windows, możesz przeczytać samouczek instalacji, aby uzyskać pełne instrukcje. Ogólnie rzecz biorąc, możesz przejść do strony pobierania, wybrać platformę Windows w polu Dostępne pliki do pobrania, wybrać .msi instalatora, który pasuje do Twojego obecnego systemu, i kliknij Pobierz .

Uruchom instalator i postępuj zgodnie z instrukcjami wyświetlanymi na ekranie kreatora instalacji. Ta strona zawiera również informacje o tym, jak uruchomić MongoDB jako usługę Windows.

Jeśli korzystasz z macOS, możesz użyć Homebrew, aby zainstalować MongoDB w swoim systemie. Zobacz samouczek instalacji, aby uzyskać pełny przewodnik. Upewnij się również, że postępujesz zgodnie z instrukcjami, aby uruchomić MongoDB jako usługę macOS.

Jeśli korzystasz z systemu Linux, proces instalacji będzie zależał od konkretnej dystrybucji. Aby uzyskać szczegółowy przewodnik dotyczący instalowania MongoDB w różnych systemach Linux, przejdź do strony samouczka instalacji i wybierz samouczek, który pasuje do bieżącego systemu operacyjnego. Upewnij się, że uruchomiłeś demona MongoDB, mongod , pod koniec instalacji.

Na koniec możesz również zainstalować MongoDB za pomocą Dockera. Jest to przydatne, jeśli nie chcesz zaśmiecać systemu inną instalacją. Jeśli wolisz tę opcję instalacji, możesz przeczytać oficjalny samouczek i postępować zgodnie z jego wskazówkami. Pamiętaj, że w tym przypadku wymagana byłaby wcześniejsza wiedza na temat korzystania z platformy Docker.

Po zainstalowaniu i uruchomieniu w systemie bazy danych MongoDB możesz rozpocząć pracę z prawdziwymi bazami danych za pomocą mongo powłoka.

Tworzenie baz danych MongoDB za pomocą mongo Powłoka

Jeśli postępowałeś zgodnie z instrukcjami instalacji i uruchamiania, powinieneś już mieć uruchomioną instancję MongoDB w swoim systemie. Teraz możesz zacząć tworzyć i testować własne bazy danych. W tej sekcji dowiesz się, jak używać mongo powłoka do tworzenia, czytania, aktualizowania i usuwania dokumentów w bazie danych.

Uruchamianie mongo Powłoka

mongo shell to interaktywny interfejs JavaScript do MongoDB. Możesz użyć tego narzędzia do tworzenia zapytań i manipulowania danymi, a także do wykonywania operacji administracyjnych. Ponieważ jest to interfejs JavaScript, nie będziesz używać znanego języka SQL do wysyłania zapytań do bazy danych. Zamiast tego użyjesz kodu JavaScript.

Aby uruchomić mongo powłoki, otwórz terminal lub wiersz poleceń i uruchom następujące polecenie:

$ mongo

To polecenie prowadzi do mongo powłoka. W tym momencie prawdopodobnie zobaczysz kilka wiadomości z informacjami o wersji powłoki oraz adresie i porcie serwera. Na koniec zostanie wyświetlony znak zachęty powłoki (> ) do wprowadzania zapytań i poleceń.

Możesz przekazać adres bazy danych jako argument do mongo Komenda. Możesz także użyć kilku opcji, takich jak określenie hosta i portu w celu uzyskania dostępu do zdalnej bazy danych i tak dalej. Aby uzyskać więcej informacji na temat korzystania z mongo polecenie, możesz uruchomić mongo --help .

Nawiązywanie połączenia

Po uruchomieniu mongo polecenie bez argumentów, uruchamia powłokę i łączy się z domyślnym serwerem lokalnym dostarczonym przez mongod proces w mongod://127.0.0.1:27017 . Oznacza to, że jesteś podłączony do lokalnego hosta przez port 27017 .

Domyślnie mongo powłoka uruchamia sesję przez nawiązanie połączenia z testem Baza danych. Możesz uzyskać dostęp do bieżącej bazy danych poprzez bazę obiekt:

> db
test
>

W tym przypadku db posiada odniesienie do test , która jest domyślną bazą danych. Aby przełączyć bazy danych, wydaj polecenie użyj , podając nazwę bazy danych jako argument.

Załóżmy na przykład, że chcesz utworzyć witrynę internetową do publikowania treści Pythona i planujesz używać MongoDB do przechowywania samouczków i artykułów. W takim przypadku możesz przełączyć się do bazy danych witryny za pomocą następującego polecenia:

> use rptutorials
switched to db rptutorials

To polecenie przełącza twoje połączenie do rptutorials Baza danych. MongoDB nie tworzy fizycznego pliku bazy danych w systemie plików, dopóki nie wstawisz do bazy danych rzeczywistych danych. W tym przypadku rptutorials nie pojawi się na Twojej aktualnej liście baz danych:

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

mongo powłoka zapewnia wiele funkcji i opcji. Pozwala na wykonywanie zapytań i manipulowanie danymi, a także na zarządzanie samym serwerem bazy danych.

Zamiast używać standardowego języka zapytań, takiego jak SQL, mongo shell wykorzystuje język programowania JavaScript i przyjazny dla użytkownika interfejs API. Ten interfejs API pozwala na zabawę z danymi, co jest tematem w następnej sekcji.

Tworzenie kolekcji i dokumentów

Baza danych MongoDB to fizyczny kontener na zbiory dokumentów. Każda baza danych otrzymuje swój własny zestaw plików w systemie plików. Pliki te są zarządzane przez serwer MongoDB, który może obsługiwać kilka baz danych.

W MongoDB kolekcja to grupa dokumentów . Kolekcje są nieco analogiczne do tabel w tradycyjnym RDBMS, ale bez narzucania sztywnego schematu. Teoretycznie każdy dokument w kolekcji może mieć zupełnie inną strukturę lub zestaw pól.

W praktyce dokumenty w kolekcji zwykle mają podobną strukturę, aby umożliwić jednolite procesy pobierania, wstawiania i aktualizowania. Możesz wymusić jednolitą strukturę dokumentu, używając reguł sprawdzania poprawności dokumentu podczas aktualizacji i wstawiania.

Zezwalanie na różne struktury dokumentów jest kluczową cechą kolekcji MongoDB. Ta funkcja zapewnia elastyczność i umożliwia dodawanie nowych pól do dokumentów bez konieczności modyfikowania formalnego schematu tabeli.

Tworzenie kolekcji za pomocą mongo powłoki, musisz wskazać db do docelowej bazy danych, a następnie utwórz kolekcje za pomocą notacji z kropkami :

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

W tym przykładzie użyjesz notacji z kropkami, aby utworzyć samouczek jako zbiór w rptutorials , czyli Twoja aktualna baza danych. Należy zauważyć, że MongoDB tworzy bazy danych i kolekcje leniwie . Innymi słowy, są one fizycznie tworzone dopiero po wstawieniu pierwszego dokumentu.

Gdy masz już bazę danych i kolekcję, możesz zacząć wstawiać dokumenty. Dokumenty są jednostką przechowywania w MongoDB. W RDBMS byłoby to równoważne wierszowi tabeli. Jednak dokumenty MongoDB są znacznie bardziej wszechstronne niż wiersze, ponieważ mogą przechowywać złożone informacje, takie jak tablice, dokumenty osadzone, a nawet tablice dokumentów.

MongoDB przechowuje dokumenty w formacie o nazwie Binary JSON (BSON), który jest binarną reprezentacją JSON. Dokumenty MongoDB składają się z par pole-wartość i mają następującą strukturę:

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

Wartością pola może być dowolny typ danych BSON, w tym inne dokumenty, tablice i tablice dokumentów. W praktyce określisz swoje dokumenty w formacie JSON.

Kiedy budujesz aplikację bazodanową MongoDB, prawdopodobnie najważniejsza decyzja dotyczy struktury dokumentów. Innymi słowy, musisz zdecydować, jakie pola i wartości będą miały Twoje dokumenty.

W przypadku samouczków dla Twojej witryny w Pythonie, Twoje dokumenty mogą mieć następującą strukturę:

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

Dokument jest zasadniczo zbiorem nazw właściwości i ich wartości. Wartości mogą być prostymi typami danych, takimi jak ciągi i liczby, ale mogą też być tablicami, takimi jak współtwórcy w powyższym przykładzie.

Zorientowany na dokumenty model danych MongoDB w naturalny sposób reprezentuje złożone dane jako pojedynczy obiekt. Pozwala to na holistyczną pracę z obiektami danych, bez konieczności zaglądania do kilku miejsc lub tabel.

Gdybyś używał tradycyjnego RDBMS do przechowywania samouczków, prawdopodobnie miałbyś tabelę do przechowywania samouczków i inną tabelę do przechowywania współtwórców. Następnie musiałbyś ustawić relację między obiema tabelami, aby móc później odzyskać dane.

Praca z kolekcjami i dokumentami

Jak dotąd znasz podstawy uruchamiania i używania mongo powłoka. Wiesz również, jak tworzyć własne dokumenty w formacie JSON. Teraz nadszedł czas, aby dowiedzieć się, jak wstawiać dokumenty do bazy danych MongoDB.

Aby wstawić dokument do bazy danych za pomocą mongo powłoki, najpierw musisz wybrać kolekcję, a następnie wywołać .insertOne() na kolekcji z twoim dokumentem jako argumentem:

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

Za pomocą pierwszego polecenia przełączasz się do bazy danych, której chcesz użyć. Drugie polecenie to wywołanie metody JavaScript, która wstawia prosty dokument do wybranej kolekcji, tutorial . Po naciśnięciu Enter , na ekranie pojawi się komunikat informujący o nowo wstawionym dokumencie i jego insertedId .

Tak jak relacyjne bazy danych potrzebują klucza podstawowego do jednoznacznej identyfikacji każdego wiersza w tabeli, dokumenty MongoDB muszą mieć _id pole, które jednoznacznie identyfikuje dokument. MongoDB umożliwia wprowadzenie niestandardowego _id o ile gwarantujesz jej wyjątkowość. Jednak powszechnie akceptowaną praktyką jest umożliwienie MongoDB automatycznego wstawiania _id dla Ciebie.

Podobnie możesz dodać kilka dokumentów za jednym razem, używając .insertMany() :

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

Tutaj wywołanie .insertMany() pobiera listę samouczków i wstawia je do bazy danych. Ponownie, wyjście powłoki pokazuje informacje o nowo wstawionych dokumentach i ich automatycznie dodanym _id pola.

mongo powłoka zapewnia również metody wykonywania operacji odczytu, aktualizacji i usuwania na bazie danych. Na przykład możesz użyć .find() aby pobrać dokumenty w kolekcji:

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

Pierwsze wywołanie .find() pobiera wszystkie dokumenty w samouczku kolekcja. Z drugiej strony drugie wywołanie .find() pobiera samouczki autorstwa Joanny.

Dzięki tej podstawowej wiedzy na temat korzystania z MongoDB za pośrednictwem jej mongo powłoki, możesz zacząć używać MongoDB z Pythonem. W następnych kilku sekcjach omówimy różne opcje korzystania z baz danych MongoDB w aplikacjach Pythona.

Korzystanie z MongoDB z Pythonem i PyMongo

Teraz, gdy wiesz, czym jest MongoDB i jak tworzyć i zarządzać bazami danych za pomocą mongo shell, możesz zacząć używać MongoDB, ale tym razem z Pythonem. MongoDB udostępnia oficjalny sterownik Pythona o nazwie PyMongo.

W tej sekcji przejdziesz przez kilka przykładów, które pomogą Ci zrozumieć, jak używać PyMongo do tworzenia własnych aplikacji bazodanowych za pomocą MongoDB i Pythona.

Każdy moduł w PyMongo odpowiada za zestaw operacji na bazie danych. Będziesz mieć moduły do ​​co najmniej następujących zadań:

• Nawiązywanie połączeń z bazą danych
• Praca z bazami danych
• Praca z kolekcjami i dokumentami
• Manipulowanie kursorem
• Praca z szyfrowaniem danych

Ogólnie rzecz biorąc, PyMongo zapewnia bogaty zestaw narzędzi, których można użyć do komunikacji z serwerem MongoDB. Zapewnia funkcjonalność zapytań, pobierania wyników, zapisywania i usuwania danych oraz uruchamiania poleceń bazy danych.

Instalowanie PyMongo

Aby zacząć korzystać z PyMongo, musisz najpierw zainstalować go w swoim środowisku Python. Możesz użyć środowiska wirtualnego lub możesz użyć ogólnosystemowej instalacji Pythona, chociaż preferowana jest pierwsza opcja. PyMongo jest dostępny na PyPI, więc najszybszym sposobem na jego instalację jest użycie pip . Uruchom terminal i uruchom następujące polecenie:

$ pip install pymongo==3.11.2

Po kilku pobraniach i innych powiązanych krokach to polecenie zainstaluje PyMongo w twoim środowisku Python. Pamiętaj, że jeśli nie podasz konkretnego numeru wersji, to pip zainstaluje najnowszą dostępną wersję.

Uwaga: Aby uzyskać pełny przewodnik na temat instalacji PyMongo, sprawdź stronę Instalacja/aktualizacja w jego oficjalnej dokumentacji.

Po zakończeniu instalacji możesz rozpocząć interaktywną sesję Pythona i uruchomić następujący import:

>>> import pymongo

Jeśli to działa bez zgłaszania wyjątku w powłoce Pythona, twoja instalacja działa dobrze. Jeśli nie, wykonaj te czynności ponownie.

Nawiązywanie połączenia

Aby nawiązać połączenie z bazą danych, musisz utworzyć MongoClient instancja. Ta klasa zapewnia klienta dla instancji lub serwera MongoDB. Każdy obiekt klienta ma wbudowaną pulę połączeń, która domyślnie obsługuje do stu połączeń z serwerem.

Wróć do sesji interaktywnej Pythona i zaimportuj MongoClient z pymongo . Następnie utwórz obiekt klienta, aby komunikować się z aktualnie uruchomioną instancją MongoDB:

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

Powyższy kod nawiązuje połączenie z domyślnym hostem (localhost ) i port (27017 ). MongoClient przyjmuje zestaw argumentów, który umożliwia określenie niestandardowego hosta, portu i innych parametrów połączenia. Na przykład, aby zapewnić niestandardowy host i port, możesz użyć następującego kodu:

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

Jest to przydatne, gdy musisz zapewnić host i port które różnią się od domyślnej konfiguracji MongoDB. Możesz także użyć formatu MongoDB URI:

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

Wszystkie te wystąpienia MongoClient podaj tę samą konfigurację klienta, aby połączyć się z bieżącą instancją MongoDB. Który z nich powinieneś użyć, zależy tylko od tego, jak wyraźny chcesz być w swoim kodzie.

Po utworzeniu instancji MongoClient , możesz użyć jego instancji, aby odnieść się do tego konkretnego połączenia z bazą danych, tak jak w przypadku mongo db powłoki obiekt w powyższej sekcji.

Praca z bazami danych, kolekcjami i dokumentami

Gdy masz już połączoną instancję MongoClient , możesz uzyskać dostęp do dowolnej bazy danych zarządzanej przez określony serwer MongoDB. Aby określić, której bazy danych chcesz użyć, możesz użyć notacji z kropkami, tak jak zrobiłeś to w mongo powłoka:

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

W tym przypadku rptutorials to nazwa bazy danych, z którą będziesz pracować. Jeśli baza danych nie istnieje, MongoDB utworzy ją za Ciebie, ale tylko wtedy, gdy wykonasz pierwszą operację na bazie danych.

Możesz również użyć dostępu w stylu słownikowym, jeśli nazwa bazy danych nie jest prawidłowym identyfikatorem Pythona:

>>> db = client["rptutorials"]

Ta instrukcja jest przydatna, gdy nazwa Twojej bazy danych nie jest prawidłowym identyfikatorem Pythona. Na przykład, jeśli Twoja baza danych nazywa się rp-tutorials , musisz użyć dostępu w stylu słownika.

Uwaga: Kiedy używasz mongo shell, masz dostęp do bazy danych przez db obiekt globalny. Kiedy używasz PyMongo, możesz przypisać bazę danych do zmiennej o nazwie db aby uzyskać podobne zachowanie.

Przechowywanie danych w bazie danych za pomocą PyMongo jest podobne do tego, co robiłeś z mongo powłoki w powyższych sekcjach. Ale najpierw musisz stworzyć swoje dokumenty. W Pythonie do tworzenia dokumentów używa się słowników:

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

Po utworzeniu dokumentu jako słownika musisz określić, której kolekcji chcesz użyć. Aby to zrobić, możesz użyć notacji kropkowej na obiekcie bazy danych:

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

W tym przypadku samouczek jest instancją Kolekcja i reprezentuje fizyczny zbiór dokumentów w Twojej bazie danych. Możesz wstawić dokumenty do samouczka wywołując .insert_one() na nim z dokumentem jako argumentem:

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

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

Tutaj, .insert_one() zajmuje samouczek1 , wstawia go do samouczka kolekcja i zwraca InsertOneResult obiekt. Ten obiekt dostarcza informacji zwrotnej na temat wstawionego dokumentu. Zauważ, że ponieważ MongoDB generuje ObjectId dynamicznie, wynik nie będzie pasował do ObjectId pokazane powyżej.

Jeśli masz wiele dokumentów do dodania do bazy danych, możesz użyć .insert_many() aby wstawić je za jednym razem:

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

Jest to szybsze i prostsze niż wywołanie .insert_one() wiele razy. Wywołanie .insert_many() pobiera iterację dokumentów i wstawia je do samouczka kolekcja w Twoich rtutorialach Baza danych. Metoda zwraca instancję InsertManyResult , który zawiera informacje o wstawionych dokumentach.

Aby pobrać dokumenty z kolekcji, możesz użyć .find() . Bez argumentów .find() zwraca Kursor obiekt udostępniający na żądanie dokumenty ze zbiorów:

>>> 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 oświadczenie. 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 polecenie:

$ 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.

Uwaga: 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.