Python och MongoDB:Ansluter till NoSQL-databaser

När det gäller driftsidan tillhandahåller MongoDB några verktyg och funktioner som du inte hittar i andra databassystem:

• Skalbarhet: Oavsett om du behöver en fristående server eller kompletta kluster av oberoende servrar, kan du skala MongoDB till vilken storlek du än behöver.
• Stöd för lastbalansering: MongoDB kommer automatiskt att flytta data över olika skärvor.
• Stöd för automatisk failover: Om din primära server går ner, kommer en ny primär att vara igång automatiskt.
• Hanteringsverktyg: Du kan spåra dina maskiner med den molnbaserade MongoDB Management Service (MMS).
• Minneseffektivitet: Tack vare de minneskartade filerna är MongoDB ofta mer effektiv än relationsdatabaser.

Alla dessa funktioner är ganska användbara. Om du till exempel utnyttjar indexeringsfunktionen kommer mycket av din data att lagras i minnet för snabb hämtning. Även utan att indexera specifika dokumentnycklar cachar MongoDB en hel del data med den minst nyligen använda tekniken.

Installera och köra MongoDB

Nu när du är bekant med MongoDB är det dags att smutsa ner händerna och börja använda det. Men först måste du installera det på din maskin. MongoDB:s officiella webbplats tillhandahåller två utgåvor av databasservern:

1. Community-utgåvan erbjuder den flexibla dokumentmodellen tillsammans med ad hoc-frågor, indexering och aggregering i realtid för att ge kraftfulla sätt att komma åt och analysera dina data. Den här utgåvan är fritt tillgänglig.
2. Enterprise-utgåvan erbjuder samma funktioner som community-utgåvan, plus andra avancerade funktioner relaterade till säkerhet och övervakning. Detta är den kommersiella utgåvan, men du kan använda den gratis under en obegränsad tid för utvärdering och utvecklingsändamål.

Om du använder Windows kan du läsa igenom installationshandledningen för fullständiga instruktioner. I allmänhet kan du gå till nedladdningssidan, välja Windows-plattformen i rutan Tillgängliga nedladdningar, välja .msi installationsprogram som passar ditt nuvarande system och klicka på Ladda ner .

Kör installationsprogrammet och följ instruktionerna på skärmen i installationsguiden. Den här sidan ger också information om hur man kör MongoDB som en Windows-tjänst.

Om du använder macOS kan du använda Homebrew för att installera MongoDB på ditt system. Se installationshandledningen för att få den kompletta guiden. Se också till att följa instruktionerna för att köra MongoDB som en macOS-tjänst.

Om du använder Linux kommer installationsprocessen att bero på din specifika distribution. För en detaljerad guide om hur du installerar MongoDB på olika Linux-system, gå till sidan för installationshandledning och välj den handledning som matchar ditt nuvarande operativsystem. Se till att du kör MongoDB-demonen, mongod , i slutet av installationen.

Slutligen kan du också installera MongoDB med Docker. Detta är praktiskt om du inte vill belamra ditt system med en annan installation. Om du föredrar det här installationsalternativet kan du läsa igenom den officiella handledningen och följa dess anvisningar. Observera att tidigare kunskaper om hur man använder Docker skulle krävas i detta fall.

Med MongoDB-databasen installerad och körd på ditt system kan du börja arbeta med riktiga databaser med hjälp av mongo skal.

Skapa MongoDB-databaser med mongo Skal

Om du har följt installations- och körinstruktionerna bör du redan ha en instans av MongoDB som körs på ditt system. Nu kan du börja skapa och testa dina egna databaser. I det här avsnittet kommer du att lära dig hur du använder mongo skal för att skapa, läsa, uppdatera och ta bort dokument i en databas.

Kör mongo Skal

mongo shell är ett interaktivt JavaScript-gränssnitt till MongoDB. Du kan använda det här verktyget för att fråga och manipulera dina data samt för att utföra administrativa åtgärder. Eftersom det är ett JavaScript-gränssnitt kommer du inte att använda det välbekanta SQL-språket för att fråga databasen. Istället använder du JavaScript-kod.

För att starta mongo shell, öppna din terminal eller kommandorad och kör följande kommando:

$ mongo

Detta kommando tar dig till mongo skal. Vid det här laget kommer du förmodligen att se ett gäng meddelanden med information om skalets version och om serveradressen och porten. Slutligen kommer du att presenteras med skalprompten (> ) för att ange frågor och kommandon.

Du kan skicka databasadressen som ett argument till mongo kommando. Du kan också använda flera alternativ, som att ange värden och porten för åtkomst till en fjärrdatabas och så vidare. För mer information om hur du använder mongo kommandot kan du köra mongo --help .

Etablera en anslutning

När du kör mongo kommando utan argument, startar det skalet och ansluter till den lokala standardservern som tillhandahålls av mongod process på mongod://127.0.0.1:27017 . Det betyder att du är ansluten till den lokala värden via port 27017 .

Som standard är mongo shell startar sessionen genom att upprätta en anslutning till testet databas. Du kan komma åt den aktuella databasen genom db objekt:

> db
test
>

I det här fallet, db innehåller en referens till test , som är standarddatabasen. För att byta databaser, utfärda kommandot use , ger ett databasnamn som ett argument.

Säg till exempel att du vill skapa en webbplats för att publicera Python-innehåll och att du planerar att använda MongoDB för att lagra dina handledningar och artiklar. I så fall kan du byta till webbplatsens databas med följande kommando:

> use rptutorials
switched to db rptutorials

Detta kommando växlar din anslutning till rptutorials databas. MongoDB skapar inte den fysiska databasfilen på filsystemet förrän du infogar riktig data i databasen. Så i det här fallet, rptutorials kommer inte att visas i din nuvarande databaslista:

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

mongo skalet ger många funktioner och alternativ. Det låter dig fråga och manipulera dina data och även hantera själva databasservern.

Istället för att använda ett standardiserat frågespråk som SQL, mongo shell använder programmeringsspråket JavaScript och ett användarvänligt API. Detta API låter dig leka med dina data, vilket är ämnet för nästa avsnitt.

Skapa samlingar och dokument

En MongoDB-databas är en fysisk behållare för samlingar av dokument. Varje databas får sin egen uppsättning filer i filsystemet. Dessa filer hanteras av MongoDB-servern, som kan hantera flera databaser.

I MongoDB, en samling är en grupp av dokument . Samlingar är något analoga med tabeller i ett traditionellt RDBMS, men utan att införa ett stelbent schema. I teorin kan varje dokument i en samling ha en helt annan struktur eller uppsättning fält.

I praktiken delar dokument i en samling vanligtvis en liknande struktur för att möjliggöra enhetliga hämtnings-, infognings- och uppdateringsprocesser. Du kan genomdriva en enhetlig dokumentstruktur genom att använda dokumentvalideringsregler under uppdateringar och infogningar.

Att tillåta olika dokumentstrukturer är en nyckelfunktion i MongoDB-samlingar. Den här funktionen ger flexibilitet och gör det möjligt att lägga till nya fält i dokument utan att behöva ändra ett formellt tabellschema.

För att skapa en samling med mongo skal, måste du peka på db till din måldatabas och skapa sedan samlingarna med punktnotationen :

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

I det här exemplet använder du punktnotationen för att skapa handledning som en samling i rptutorials , som är din nuvarande databas. Det är viktigt att notera att MongoDB skapar databaser och samlingar lätt . Med andra ord, de skapas fysiskt först efter att du infogat det första dokumentet.

När du har en databas och en samling kan du börja infoga dokument. Dokument är lagringsenheten i MongoDB. I ett RDBMS skulle detta motsvara en tabellrad. Men MongoDB:s dokument är mycket mer mångsidiga än rader eftersom de kan lagra komplex information, såsom arrayer, inbäddade dokument och till och med arrayer av dokument.

MongoDB lagrar dokument i ett format som kallas Binary JSON (BSON), som är en binär representation av JSON. MongoDB:s dokument är sammansatta av fält- och värdepar och har följande struktur:

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

Värdet på ett fält kan vara vilken BSON-datatyp som helst, inklusive andra dokument, arrayer och arrayer av dokument. I praktiken kommer du att specificera dina dokument med JSON-formatet.

När du bygger en MongoDB-databasapplikation är förmodligen ditt viktigaste beslut om strukturen på dokument. Med andra ord måste du bestämma vilka fält och värden dina dokument ska ha.

När det gäller handledningarna för din Python-webbplats kan dina dokument vara strukturerade så här:

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

Ett dokument är i huvudsak en uppsättning egendomsnamn och deras värden. Värdena kan vara enkla datatyper, som strängar och siffror, men de kan också vara matriser som bidragsgivare i exemplet ovan.

MongoDB:s dokumentorienterade datamodell representerar naturligtvis komplexa data som ett enda objekt. Detta gör att du kan arbeta med dataobjekt holistiskt, utan att behöva titta på flera platser eller tabeller.

Om du använde ett traditionellt RDBMS för att lagra dina handledningar, skulle du förmodligen ha en tabell för att lagra dina handledningar och en annan tabell för att lagra dina bidragsgivare. Sedan måste du skapa en relation mellan båda tabellerna så att du kan hämta data senare.

Arbeta med samlingar och dokument

Än så länge vet du grunderna för hur du kör och använder mongo skal. Du vet också hur du skapar dina egna dokument med JSON-formatet. Nu är det dags att lära sig hur du infogar dokument i din MongoDB-databas.

För att infoga ett dokument i en databas med mongo shell måste du först välja en samling och sedan anropa .insertOne() på samlingen med ditt dokument som argument:

> use rptutorials
switched to db rptutorials

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

Med det första kommandot byter du till den databas du vill använda. Det andra kommandot är ett JavaScript-metodanrop som infogar ett enkelt dokument i den valda samlingen, tutorial . När du trycker på Retur , får du ett meddelande på skärmen som informerar dig om det nyligen infogade dokumentet och dess insertedId .

Precis som relationsdatabaser behöver en primärnyckel för att unikt identifiera varje rad i en tabell, måste MongoDB-dokument ha en _id fält som unikt identifierar dokumentet. MongoDB låter dig ange ett anpassat _id så länge du garanterar dess unikhet. En allmänt accepterad praxis är dock att tillåta MongoDB att automatiskt infoga ett _id för dig.

På samma sätt kan du lägga till flera dokument på en gång med .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")
    ]
}

Här, anropet till .insertMany() tar en lista med tutorials och infogar dem i databasen. Återigen visar skalutdata information om de nyligen infogade dokumenten och deras automatiskt tillagda _id fält.

mongo shell tillhandahåller också metoder för att utföra läs-, uppdaterings- och raderingsoperationer på databasen. Du kan till exempel använda .find() för att hämta dokumenten i en samling:

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

Det första anropet till .find() hämtar alla dokument i självstudien samling. Å andra sidan, det andra anropet till .find() hämtar de tutorials som är författade av Joanna.

Med denna bakgrundskunskap om hur man använder MongoDB genom dess mongo shell, är du redo att börja använda MongoDB med Python. De kommande avsnitten kommer att gå igenom olika alternativ för att använda MongoDB-databaser i dina Python-applikationer.

Använda MongoDB med Python och PyMongo

Nu när du vet vad MongoDB är och hur man skapar och hanterar databaser med mongo shell, kan du börja använda MongoDB, men den här gången med Python. MongoDB tillhandahåller en officiell Python-drivrutin som heter PyMongo.

I det här avsnittet går du igenom några exempel som hjälper dig att få en känsla av hur du använder PyMongo för att skapa dina egna databasapplikationer med MongoDB och Python.

Varje modul inom PyMongo är ansvarig för en uppsättning operationer på databasen. Du kommer att ha moduler för åtminstone följande uppgifter:

• Etablera databasanslutningar
• Arbeta med databaser
• Arbeta med samlingar och dokument
• Manipulation av markören
• Arbeta med datakryptering

I allmänhet tillhandahåller PyMongo en rik uppsättning verktyg som du kan använda för att kommunicera med en MongoDB-server. Det ger funktionalitet för att fråga, hämta resultat, skriva och radera data och köra databaskommandon.

Installera PyMongo

För att börja använda PyMongo måste du först installera det i din Python-miljö. Du kan använda en virtuell miljö, eller så kan du använda din systemomfattande Python-installation, även om det första alternativet är att föredra. PyMongo är tillgängligt på PyPI, så det snabbaste sättet att installera det är med pip . Starta din terminal och kör följande kommando:

$ pip install pymongo==3.11.2

Efter några nedladdningar och andra relaterade steg installerar detta kommando PyMongo på din Python-miljö. Observera att om du inte anger ett specifikt versionsnummer, så pip kommer att installera den senaste tillgängliga versionen.

Obs! För en komplett guide om hur du installerar PyMongo, kolla in installations-/uppgraderingssidan i dess officiella dokumentation.

När du är klar med installationen kan du starta en interaktiv Python-session och köra följande import:

>>> import pymongo

Om detta körs utan att göra ett undantag i Python-skalet, fungerar din installation bra. Om inte, utför sedan försiktigt stegen igen.

Etablera en anslutning

För att upprätta en anslutning till en databas måste du skapa en MongoClient exempel. Den här klassen tillhandahåller en klient för en MongoDB-instans eller -server. Varje klientobjekt har en inbyggd anslutningspool, som som standard hanterar upp till hundra anslutningar till servern.

Gå tillbaka till din interaktiva Python-session och importera MongoClient från pymongo . Skapa sedan ett klientobjekt för att kommunicera med din MongoDB-instans som körs för närvarande:

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

Koden ovan upprättar en anslutning till standardvärden (localhost ) och port (27017 ). MongoClient tar en uppsättning argument som låter dig ange anpassade värd-, port- och andra anslutningsparametrar. Till exempel, för att tillhandahålla en anpassad värd och port kan du använda följande kod:

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

Detta är praktiskt när du behöver tillhandahålla en värd och port som skiljer sig från MongoDB:s standardinställning. Du kan också använda MongoDB URI-format:

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

Alla dessa instanser av MongoClient tillhandahålla samma klientinställning för att ansluta din nuvarande MongoDB-instans. Vilken du ska använda beror bara på hur explicit du vill vara i din kod.

När du har instansierat MongoClient , kan du använda dess instans för att referera till den specifika databasanslutningen, precis som du gjorde med mongo skalets db objekt i avsnittet ovan.

Arbeta med databaser, samlingar och dokument

När du har en ansluten instans av MongoClient , kan du komma åt vilken databas som helst som hanteras av den angivna MongoDB-servern. För att definiera vilken databas du vill använda kan du använda punktnotationen precis som du gjorde i mongo skal:

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

I det här fallet, rptutorials är namnet på databasen du kommer att arbeta med. Om databasen inte finns skapar MongoDB den åt dig, men bara när du utför den första operationen på databasen.

Du kan också använda åtkomst i ordboksstil om namnet på databasen inte är en giltig Python-identifierare:

>>> db = client["rptutorials"]

Det här uttalandet är praktiskt när namnet på din databas inte är en giltig Python-identifierare. Till exempel, om din databas heter rp-tutorials , då måste du använda ordboksliknande åtkomst.

Obs! När du använder mongo shell, har du tillgång till databasen genom db globala objekt. När du använder PyMongo kan du tilldela databasen till en variabel som heter db för att få liknande beteende.

Att lagra data i din databas med PyMongo liknar det du gjorde med mongo skal i ovanstående avsnitt. Men först måste du skapa dina dokument. I Python använder du ordböcker för att skapa dokument:

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

När du har skapat dokumentet som en ordbok måste du ange vilken samling du vill använda. För att göra det kan du använda punktnotationen på databasobjektet:

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

I det här fallet, självstudie är en instans av Collection och representerar en fysisk samling av dokument i din databas. Du kan infoga dokument i handledning genom att anropa .insert_one() på den med ett dokument som argument:

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

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

Här, .insert_one() tar tutorial1 , infogar den i självstudien samling och returnerar en InsertOneResult objekt. Detta objekt ger feedback på det infogade dokumentet. Observera att eftersom MongoDB genererar ObjectId dynamiskt kommer din utdata inte att matcha ObjectId visas ovan.

Om du har många dokument att lägga till i databasen kan du använda .insert_many() för att infoga dem på en gång:

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

Detta är snabbare och enklare än att anropa .insert_one() flera gånger. Anropet till .insert_many() tar en iterabel av dokument och infogar dem i självstudien samling i dina rptutorials databas. Metoden returnerar en instans av InsertManyResult , som ger information om de inlagda dokumenten.

För att hämta dokument från en samling kan du använda .find() . Utan argument, .find() returnerar en Markör objekt som ger dokumenten i samlingen på begäran:

>>> 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 statement. 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 kommando:

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

Obs! 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.