Python en MongoDB:verbinding maken met NoSQL-databases

MongoDB is een documentgeoriënteerde en NoSQL-databaseoplossing die grote schaalbaarheid en flexibiliteit biedt, samen met een krachtig querysysteem. Met MongoDB en Python kun je snel veel verschillende soorten database-applicaties ontwikkelen. Dus als uw Python-toepassing een database nodig heeft die net zo flexibel is als de taal zelf, dan is MongoDB iets voor u.

In deze tutorial leer je:

• Wat MongoDB is
• Hoe installeren en uitvoeren MongoDB
• Hoe te werken met MongoDB-databases
• Het gebruik van het PyMongo-stuurprogramma op laag niveau om te communiceren met MongoDB
• Hoe de MongoEngine object-document mapper (ODM) op hoog niveau te gebruiken

In deze tutorial zul je een aantal voorbeelden schrijven die de flexibiliteit en kracht van MongoDB en zijn geweldige Python-ondersteuning demonstreren. Klik op de onderstaande link om de broncode voor deze voorbeelden te downloaden:

Verkrijg de broncode: Klik hier voor de broncode die u in deze zelfstudie zult gebruiken om MongoDB met Python te leren gebruiken.

SQL versus NoSQL-databases gebruiken

Decennialang waren SQL-databases een van de weinige keuzes voor ontwikkelaars die grote en schaalbare databasesystemen wilden bouwen. De toenemende behoefte aan het opslaan van complexe datastructuren leidde echter tot de geboorte van NoSQL databanken. Met dit nieuwe soort databasesysteem kunnen ontwikkelaars heterogene en structuurloze gegevens efficiënt opslaan.

Over het algemeen slaan NoSQL-databasesystemen gegevens op een heel andere manier op en halen ze deze op dan SQL relationele databasebeheersystemen (RDBMS'en).

Als het gaat om het kiezen uit de momenteel beschikbare databasetechnologieën, moet u mogelijk kiezen tussen het gebruik van SQL- of NoSQL-systemen. Beide hebben specifieke kenmerken waarmee u rekening moet houden bij het kiezen van het een of het ander. Hier zijn enkele van hun meer substantiële verschillen:

Er zijn veel andere verschillen tussen de twee typen databases, maar de hierboven genoemde zijn enkele van de belangrijkste om te weten.

Bij het kiezen van een database moet u zorgvuldig rekening houden met de sterke en zwakke punten. U moet ook overwegen hoe de database past in uw specifieke scenario en de vereisten van uw toepassing. Soms is de juiste oplossing om een ​​combinatie van SQL- en NoSQL-databases te gebruiken om verschillende aspecten van een breder systeem af te handelen.

Enkele veelvoorkomende voorbeelden van SQL-databases zijn:

• SQLite
• MijnSQL
• Oracle
• PostgreSQL
• Microsoft SQL Server

Voorbeelden van NoSQL-databases zijn:

• DynamoDB
• Cassandra
• Opnieuw
• CouchDB
• RethinkDB
• RavenDB
• MongoDB

De afgelopen jaren zijn SQL- en NoSQL-databases zelfs begonnen te fuseren. Databasesystemen zoals PostgreSQL, MySQL en Microsoft SQL Server ondersteunen nu bijvoorbeeld het opslaan en opvragen van JSON-gegevens, net zoals NoSQL-databases. Hiermee kunt u nu met beide technologieën veel van dezelfde resultaten bereiken. Maar je krijgt nog steeds niet veel van de NoSQL-functies, zoals horizontaal schalen en de gebruiksvriendelijke interface.

Met deze korte achtergrond over SQL- en NoSQL-databases, kunt u zich concentreren op het hoofdonderwerp van deze tutorial:de MongoDB-database en hoe het te gebruiken in Python.

NoSQL-databases beheren met MongoDB

MongoDB is een document-georiënteerde database geclassificeerd als NoSQL. Het is de afgelopen jaren populair geworden in de hele branche en integreert buitengewoon goed met Python. In tegenstelling tot traditionele SQL RDBMS'en, gebruikt MongoDB verzamelingen van documenten in plaats van tafels van rijen om gegevens te ordenen en op te slaan.

MongoDB slaat gegevens op in schemaloze en flexibele JSON-achtige documenten. Hier, schemaloos betekent dat u documenten met een andere set velden in dezelfde verzameling kunt hebben, zonder dat u aan een rigide tabel schema hoeft te voldoen .

U kunt de structuur van uw documenten en gegevens in de loop van de tijd wijzigen, wat resulteert in een flexibel systeem waarmee u zich snel kunt aanpassen aan wijzigingen in de vereisten zonder dat er een complex proces van gegevensmigratie nodig is. De wisselwerking bij het wijzigen van de structuur van nieuwe documenten is echter dat uitgaande documenten inconsistent worden met het bijgewerkte schema. Dit is dus een onderwerp dat met zorg moet worden beheerd.

Opmerking: JSON staat voor JavaScript Object Notation . Het is een bestandsindeling met een door mensen leesbare structuur die bestaat uit sleutel-waardeparen die willekeurig diep kunnen worden genest.

MongoDB is geschreven in C++ en actief ontwikkeld door MongoDB Inc. Het draait op alle belangrijke platforms, zoals macOS, Windows, Solaris en de meeste Linux-distributies. Over het algemeen zijn er drie belangrijke ontwikkelingsdoelen achter de MongoDB-database:

1. Goed schalen
2. Rijke datastructuren opslaan
3. Zorg voor een geavanceerd zoekmechanisme

MongoDB is een gedistribueerde database, dus hoge beschikbaarheid, horizontale schaling en geografische distributie zijn in het systeem ingebouwd. Het slaat gegevens op in flexibele JSON-achtige documenten. U kunt deze documenten modelleren om de objecten in uw applicaties in kaart te brengen, waardoor u effectief met uw gegevens kunt werken.

MongoDB biedt een krachtige querytaal die ad-hocquery's, indexering, aggregatie, georuimtelijk zoeken, tekstzoeken en nog veel meer ondersteunt. Dit biedt u een krachtige toolkit om toegang te krijgen tot en te werken met uw gegevens. Ten slotte is MongoDB gratis beschikbaar en heeft het geweldige ondersteuning voor Python.

De functies van MongoDB bekijken

Tot nu toe heb je geleerd wat MongoDB is en wat de belangrijkste doelen zijn. In dit gedeelte leert u over enkele van de belangrijkste functies van MongoDB. Wat betreft het databasebeheer, MongoDB biedt de volgende functies:

• Ondersteuning voor zoekopdrachten: U kunt veel standaard zoektypen gebruiken, zoals overeenkomsten (== ), vergelijking (< , > ), en reguliere expressies.
• Gegevens accommodatie: U kunt vrijwel alle soorten gegevens opslaan, of het nu gestructureerd, gedeeltelijk gestructureerd of zelfs polymorf is.
• Schaalbaarheid: Het verwerkt meer vragen door gewoon meer machines aan het servercluster toe te voegen.
• Flexibiliteit en wendbaarheid: Je kunt er snel applicaties mee ontwikkelen.
• Documentoriëntatie en schemaloosheid: U kunt alle informatie over een datamodel in één document opslaan.
• Aanpasbaar schema: U kunt het schema van de database on-the-fly wijzigen, waardoor er minder tijd nodig is om nieuwe functies te bieden of bestaande problemen op te lossen.
• Relationele databasefunctionaliteiten: U kunt acties uitvoeren die gebruikelijk zijn voor relationele databases, zoals indexeren.

Wat de operationele kant betreft, biedt MongoDB een aantal tools en functies die u niet zult vinden in andere databasesystemen:

• Schaalbaarheid: Of u nu een stand-alone server of complete clusters van onafhankelijke servers nodig heeft, u kunt MongoDB schalen naar elke gewenste grootte.
• Ondersteuning voor taakverdeling: MongoDB zal automatisch gegevens over verschillende shards verplaatsen.
• Automatische failover-ondersteuning: Als uw primaire server uitvalt, wordt er automatisch een nieuwe primaire server actief.
• Managementtools: U kunt uw machines volgen met behulp van de cloudgebaseerde MongoDB Management Service (MMS).
• Geheugenefficiëntie: Dankzij de aan het geheugen toegewezen bestanden is MongoDB vaak efficiënter dan relationele databases.

Al deze functies zijn best handig. Als u bijvoorbeeld gebruikmaakt van de indexeringsfunctie, worden veel van uw gegevens in het geheugen bewaard zodat u ze snel kunt terugvinden. Zelfs zonder specifieke documentsleutels te indexeren, slaat MongoDB behoorlijk wat gegevens op in de cache met behulp van de minst recent gebruikte techniek.

MongoDB installeren en uitvoeren

Nu je bekend bent met MongoDB, is het tijd om je handen vuil te maken en het te gaan gebruiken. Maar eerst moet u het op uw computer installeren. De officiële site van MongoDB biedt twee edities van de databaseserver:

1. De community-editie biedt het flexibele documentmodel samen met ad-hocquery's, indexering en realtime aggregatie om krachtige manieren te bieden om toegang te krijgen tot uw gegevens en deze te analyseren. Deze editie is gratis beschikbaar.
2. De enterprise-editie biedt dezelfde functies als de community-editie, plus andere geavanceerde functies met betrekking tot beveiliging en monitoring. Dit is de commerciële editie, maar u kunt deze voor onbeperkte tijd gratis gebruiken voor evaluatie- en ontwikkelingsdoeleinden.

Als u Windows gebruikt, kunt u de installatiehandleiding doorlezen voor volledige instructies. Over het algemeen kunt u naar de downloadpagina gaan, het Windows-platform selecteren in het vak Beschikbare downloads, de .msi kiezen installatieprogramma dat bij uw huidige systeem past en klik op Download .

Voer het installatieprogramma uit en volg de instructies op het scherm van de installatiewizard. Deze pagina biedt ook informatie over het uitvoeren van MongoDB als een Windows-service.

Als u macOS gebruikt, kunt u Homebrew gebruiken om MongoDB op uw systeem te installeren. Zie de installatiehandleiding voor de volledige handleiding. Zorg er ook voor dat u de instructies volgt om MongoDB uit te voeren als een macOS-service.

Als u Linux gebruikt, is het installatieproces afhankelijk van uw specifieke distributie. Voor een gedetailleerde handleiding over het installeren van MongoDB op verschillende Linux-systemen, gaat u naar de installatie-tutorialpagina en selecteert u de tutorial die overeenkomt met uw huidige besturingssysteem. Zorg ervoor dat u de MongoDB-daemon uitvoert, mongod , aan het einde van de installatie.

Ten slotte kunt u MongoDB ook installeren met Docker. Dit is handig als u uw systeem niet wilt overladen met een andere installatie. Als u de voorkeur geeft aan deze installatieoptie, kunt u de officiële tutorial lezen en de aanwijzingen volgen. Houd er rekening mee dat in dit geval eerdere kennis over het gebruik van Docker vereist is.

Met de MongoDB-database geïnstalleerd en actief op uw systeem, kunt u met echte databases gaan werken met behulp van de mongo schelp.

MongoDB-databases maken met de mongo Schelpen

Als u de installatie- en uitvoeringsinstructies hebt gevolgd, zou er al een exemplaar van MongoDB op uw systeem moeten draaien. Nu kunt u beginnen met het maken en testen van uw eigen databases. In dit gedeelte leert u hoe u de mongo . gebruikt shell om documenten in een database aan te maken, te lezen, bij te werken en te verwijderen.

Het runnen van de mongo Schelpen

De mongo shell is een interactieve JavaScript-interface voor MongoDB. U kunt deze tool gebruiken om uw gegevens op te vragen en te manipuleren en om administratieve handelingen uit te voeren. Omdat het een JavaScript-interface is, zult u de bekende SQL-taal niet gebruiken om de database te doorzoeken. In plaats daarvan gebruikt u JavaScript-code.

Om de mongo te starten shell, open je terminal of opdrachtregel en voer het volgende commando uit:

$ mongo

Dit commando brengt je naar de mongo schelp. Op dit punt ziet u waarschijnlijk een heleboel berichten met informatie over de shell-versie en over het serveradres en de poort. Ten slotte krijgt u de shell-prompt te zien (> ) om zoekopdrachten en opdrachten in te voeren.

U kunt het databaseadres als argument doorgeven aan de mongo opdracht. U kunt ook verschillende opties gebruiken, zoals het specificeren van de host en poort voor toegang tot een externe database, enzovoort. Voor meer details over het gebruik van de mongo commando, kunt u mongo --help . uitvoeren .

Een verbinding tot stand brengen

Wanneer u de mongo . uitvoert commando zonder argumenten, het start de shell en maakt verbinding met de standaard lokale server die wordt geleverd door de mongod proces op mongod://127.0.0.1:27017 . Dit betekent dat je verbonden bent met de lokale host via poort 27017 .

Standaard is de mongo shell start de sessie door een verbinding tot stand te brengen met de test databank. U kunt toegang krijgen tot de huidige database via de db voorwerp:

> db
test
>

In dit geval db bevat een verwijzing naar test , wat de standaarddatabase is. Om van database te wisselen, geef je het commando use , met een databasenaam als argument.

Stel dat u een website wilt maken om Python-inhoud te publiceren en dat u van plan bent MongoDB te gebruiken om uw tutorials en artikelen op te slaan. In dat geval kunt u overschakelen naar de database van de site met het volgende commando:

> use rptutorials
switched to db rptutorials

Dit commando schakelt je verbinding naar de rptutorials databank. MongoDB maakt het fysieke databasebestand pas op het bestandssysteem als u echte gegevens in de database invoegt. Dus in dit geval, rptutorials wordt niet weergegeven in uw huidige databaselijst:

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

De mongo shell biedt veel functies en opties. Hiermee kunt u uw gegevens opvragen en manipuleren en ook de databaseserver zelf beheren.

In plaats van een gestandaardiseerde zoektaal zoals SQL te gebruiken, gebruikt de mongo shell gebruikt de programmeertaal JavaScript en een gebruiksvriendelijke API. Met deze API kun je met je gegevens spelen, wat het onderwerp is voor de volgende sectie.

Verzamelingen en documenten maken

Een MongoDB-database is een fysieke container voor verzamelingen documenten. Elke database krijgt zijn eigen set bestanden op het bestandssysteem. Deze bestanden worden beheerd door de MongoDB-server, die meerdere databases aankan.

In MongoDB, een verzameling is een groep van documenten . Verzamelingen zijn enigszins analoog aan tabellen in een traditioneel RDBMS, maar zonder een rigide schema op te leggen. In theorie kan elk document in een verzameling een compleet andere structuur of reeks velden hebben.

In de praktijk delen documenten in een verzameling gewoonlijk een vergelijkbare structuur om uniforme ophaal-, invoeg- en updateprocessen mogelijk te maken. U kunt een uniforme documentstructuur afdwingen door documentvalidatieregels te gebruiken tijdens updates en invoegingen.

Het toestaan ​​van verschillende documentstructuren is een belangrijk kenmerk van MongoDB-collecties. Deze functie biedt flexibiliteit en maakt het mogelijk nieuwe velden aan documenten toe te voegen zonder dat een formeel tabelschema hoeft te worden gewijzigd.

Een collectie maken met de mongo shell, moet je naar db . wijzen naar uw doeldatabase en maak vervolgens de collecties met behulp van de puntnotatie :

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

In dit voorbeeld gebruikt u de puntnotatie om tutorial . te maken als een verzameling in rptutorials , wat uw huidige database is. Het is belangrijk op te merken dat MongoDB databases en verzamelingen lui . maakt . Met andere woorden, ze worden pas fysiek gemaakt nadat u het eerste document hebt ingevoegd.

Als je eenmaal een database en een collectie hebt, kun je beginnen met het invoegen van documenten. Documenten zijn de opslageenheid in MongoDB. In een RDBMS zou dit equivalent zijn aan een tabelrij. De documenten van MongoDB zijn echter veel veelzijdiger dan rijen omdat ze complexe informatie kunnen opslaan, zoals arrays, ingesloten documenten en zelfs arrays van documenten.

MongoDB slaat documenten op in een formaat genaamd Binary JSON (BSON), een binaire weergave van JSON. De documenten van MongoDB zijn samengesteld uit veld-en-waardeparen en hebben de volgende structuur:

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

De waarde van een veld kan elk BSON-gegevenstype zijn, inclusief andere documenten, arrays en arrays van documenten. In de praktijk specificeert u uw documenten in het JSON-formaat.

Wanneer u een MongoDB-databasetoepassing bouwt, gaat waarschijnlijk uw belangrijkste beslissing over de structuur van documenten. Met andere woorden, u moet beslissen welke velden en waarden uw documenten zullen hebben.

In het geval van de tutorials voor uw Python-site, kunnen uw documenten als volgt gestructureerd zijn:

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

Een document is in wezen een verzameling eigenschapsnamen en hun waarden. De waarden kunnen eenvoudige gegevenstypen zijn, zoals tekenreeksen en getallen, maar het kunnen ook arrays zijn, zoals contributors in het bovenstaande voorbeeld.

Het documentgeoriënteerde gegevensmodel van MongoDB vertegenwoordigt van nature complexe gegevens als een enkel object. Hierdoor kunt u holistisch met gegevensobjecten werken, zonder dat u naar verschillende plaatsen of tabellen hoeft te kijken.

Als je een traditioneel RDBMS zou gebruiken om je tutorials op te slaan, dan zou je waarschijnlijk een tabel hebben om je tutorials op te slaan en een andere tabel om je bijdragers op te slaan. Dan moet je een relatie tussen beide tabellen instellen, zodat je de gegevens later kunt ophalen.

Werken met collecties en documenten

Tot nu toe kent u de basisprincipes van het uitvoeren en gebruiken van de mongo schelp. Je weet ook hoe je je eigen documenten kunt maken met behulp van het JSON-formaat. Nu is het tijd om te leren hoe u documenten in uw MongoDB-database kunt invoegen.

Een document in een database invoegen met de mongo shell, moet u eerst een verzameling kiezen en vervolgens .insertOne() . aanroepen op de collectie met uw document als argument:

> use rptutorials
switched to db rptutorials

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

Met het eerste commando schakel je naar de database die je wilt gebruiken. De tweede opdracht is een JavaScript-methodeaanroep die een eenvoudig document invoegt in de geselecteerde verzameling, tutorial . Zodra u op Enter . drukt , krijg je een bericht op je scherm dat je informeert over het nieuw ingevoegde document en zijn insertedId .

Net zoals relationele databases een primaire sleutel nodig hebben om elke rij in een tabel uniek te identificeren, moeten MongoDB-documenten een _id hebben veld dat het document uniek identificeert. Met MongoDB kunt u een aangepaste _id . invoeren zolang je de uniciteit ervan garandeert. Een algemeen aanvaarde praktijk is echter om MongoDB toe te staan ​​automatisch een _id . in te voegen voor jou.

Op dezelfde manier kunt u meerdere documenten in één keer toevoegen met .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")
    ]
}

Hier de aanroep van .insertMany() neemt een lijst met tutorials en voegt deze in de database in. Nogmaals, de shell-uitvoer toont informatie over de nieuw ingevoegde documenten en hun automatisch toegevoegde _id velden.

De mongo shell biedt ook methoden voor het uitvoeren van lees-, update- en verwijderbewerkingen op de database. U kunt bijvoorbeeld .find() . gebruiken om de documenten in een verzameling op te halen:

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

De eerste aanroep van .find() haalt alle documenten op in de tutorial verzameling. Aan de andere kant, de tweede aanroep van .find() haalt die tutorials op die zijn geschreven door Joanna.

Met deze achtergrondkennis over het gebruik van MongoDB via zijn mongo shell, bent u klaar om MongoDB met Python te gaan gebruiken. De volgende paragrafen zullen u door verschillende opties leiden voor het gebruik van MongoDB-databases in uw Python-toepassingen.

MongoDB gebruiken met Python en PyMongo

Nu u weet wat MongoDB is en hoe u databases maakt en beheert met de mongo shell, kunt u MongoDB gaan gebruiken, maar deze keer met Python. MongoDB biedt een officiële Python-driver genaamd PyMongo.

In dit gedeelte zult u enkele voorbeelden doornemen die u zullen helpen een idee te krijgen van hoe u PyMongo kunt gebruiken om uw eigen databasetoepassingen te maken met MongoDB en Python.

Elke module binnen PyMongo is verantwoordelijk voor een reeks bewerkingen op de database. Je hebt modules voor ten minste de volgende taken:

• Databaseverbindingen tot stand brengen
• Werken met databases
• Werken met collecties en documenten
• De cursor manipuleren
• Werken met gegevensversleuteling

Over het algemeen biedt PyMongo een uitgebreide set tools die u kunt gebruiken om te communiceren met een MongoDB-server. Het biedt functionaliteit voor het opvragen, ophalen van resultaten, schrijven en verwijderen van gegevens en het uitvoeren van databaseopdrachten.

PyMongo installeren

Om PyMongo te gaan gebruiken, moet je het eerst in je Python-omgeving installeren. U kunt een virtuele omgeving gebruiken, of u kunt uw systeembrede Python-installatie gebruiken, hoewel de eerste optie de voorkeur heeft. PyMongo is beschikbaar op PyPI, dus de snelste manier om het te installeren is met pip . Start uw terminal op en voer de volgende opdracht uit:

$ pip install pymongo==3.11.2

Na een paar downloads en andere gerelateerde stappen, installeert deze opdracht PyMongo op uw Python-omgeving. Merk op dat als je geen specifiek versienummer opgeeft, dan pip zal de nieuwste beschikbare versie installeren.

Opmerking: Raadpleeg de pagina Installeren/Upgraden van de officiële documentatie voor een complete handleiding over het installeren van PyMongo.

Als u klaar bent met de installatie, kunt u een interactieve Python-sessie starten en de volgende import uitvoeren:

>>> import pymongo

Als dit werkt zonder een uitzondering in de Python-shell op te roepen, dan werkt je installatie prima. Als dit niet het geval is, voert u de stappen opnieuw zorgvuldig uit.

Een verbinding tot stand brengen

Om een ​​verbinding met een database tot stand te brengen, moet u een MongoClient . maken voorbeeld. Deze klasse biedt een client voor een MongoDB-instantie of -server. Elk clientobject heeft een ingebouwde verbindingspool, die standaard tot honderd verbindingen met de server afhandelt.

Ga terug naar uw interactieve Python-sessie en importeer MongoClient van pymongo . Maak vervolgens een clientobject om te communiceren met uw huidige MongoDB-instantie:

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

De bovenstaande code brengt een verbinding tot stand met de standaardhost (localhost ) en poort (27017 ). MongoClient neemt een reeks argumenten waarmee u aangepaste host-, poort- en andere verbindingsparameters kunt opgeven. Als u bijvoorbeeld een aangepaste host en poort wilt opgeven, kunt u de volgende code gebruiken:

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

Dit is handig wanneer u een host moet opgeven en port die verschillen van de standaardconfiguratie van MongoDB. U kunt ook het MongoDB URI-formaat gebruiken:

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

Al deze exemplaren van MongoClient dezelfde clientconfiguratie bieden om uw huidige MongoDB-instantie te verbinden. Welke je moet gebruiken, hangt af van hoe expliciet je in je code wilt zijn.

Zodra u MongoClient heeft geïnstantieerd , kunt u zijn instantie gebruiken om naar die specifieke databaseverbinding te verwijzen, net zoals u deed met de mongo shell's db object in de bovenstaande sectie.

Werken met databases, verzamelingen en documenten

Zodra u een verbonden exemplaar van MongoClient heeft , hebt u toegang tot elke database die wordt beheerd door de opgegeven MongoDB-server. Om te definiëren welke database u wilt gebruiken, kunt u de puntnotatie gebruiken, net zoals u deed in de mongo schaal:

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

In dit geval, rptutorials is de naam van de database waarmee u gaat werken. Als de database niet bestaat, maakt MongoDB deze voor u aan, maar alleen wanneer u de eerste bewerking op de database uitvoert.

U kunt ook toegang in woordenboekstijl gebruiken als de naam van de database geen geldige Python-identificatie is:

>>> db = client["rptutorials"]

Deze verklaring is handig wanneer de naam van uw database geen geldige Python-identificatie is. Als uw database bijvoorbeeld rp-tutorials . heet , dan moet u toegang in woordenboekstijl gebruiken.

Opmerking: Wanneer u de mongo . gebruikt shell, heb je toegang tot de database via de db globaal voorwerp. Wanneer u PyMongo gebruikt, kunt u de database toewijzen aan een variabele met de naam db om soortgelijk gedrag te krijgen.

Het opslaan van gegevens in uw database met PyMongo is vergelijkbaar met wat u deed met de mongo shell in de bovenstaande secties. Maar eerst moet u uw documenten maken. In Python gebruik je woordenboeken om documenten te maken:

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

Nadat u het document als woordenboek hebt gemaakt, moet u aangeven welke verzameling u wilt gebruiken. Om dat te doen, kunt u de puntnotatie op het databaseobject gebruiken:

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

In dit geval tutorial is een instantie van Collection en vertegenwoordigt een fysieke verzameling documenten in uw database. U kunt documenten invoegen in tutorial door .insert_one() . te bellen erop met een document als argument:

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

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

Hier, .insert_one() duurt tutorial1 , voegt het toe aan de tutorial verzameling en retourneert een InsertOneResult voorwerp. Dit object geeft feedback op het ingevoegde document. Merk op dat aangezien MongoDB de ObjectId . genereert dynamisch komt uw uitvoer niet overeen met de ObjectId hierboven weergegeven.

Als u veel documenten aan de database wilt toevoegen, kunt u .insert_many() gebruiken om ze in één keer in te voegen:

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

Dit is sneller en eenvoudiger dan het aanroepen van .insert_one() meerdere keren. De aanroep van .insert_many() neemt een iteratie van documenten en voegt ze in de tutorial verzameling in uw rptutorials databank. De methode retourneert een instantie van InsertManyResult , die informatie geeft over de ingevoegde documenten.

Om documenten uit een verzameling op te halen, kunt u .find() . gebruiken . Zonder argumenten, .find() geeft een Cursor . terug object dat de documenten in de collectie op aanvraag oplevert:

>>> 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 uitspraak. 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 command:

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

Opmerking: 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:

Verkrijg de broncode: Click here to get the source code you’ll use to learn about using MongoDB with Python in this tutorial.