Python e MongoDB:connessione ai database NoSQL

MongoDB è una soluzione di database NoSQL orientata ai documenti che offre grande scalabilità e flessibilità insieme a un potente sistema di query. Con MongoDB e Python, puoi sviluppare rapidamente molti tipi diversi di applicazioni di database. Quindi, se la tua applicazione Python ha bisogno di un database flessibile quanto il linguaggio stesso, MongoDB fa per te.

In questo tutorial imparerai:

• Cosa MongoDB è
• Come installare ed eseguire MongoDB
• Come lavorare con i database MongoDB
• Come utilizzare il driver PyMongo di basso livello per interfacciarsi con MongoDB
• Come utilizzare il mappatore di documenti oggetto (ODM) MongoEngine di alto livello

Durante questo tutorial, scriverai un paio di esempi che dimostreranno la flessibilità e la potenza di MongoDB e il suo ottimo supporto per Python. Per scaricare il codice sorgente di questi esempi, fai clic sul collegamento seguente:

Ottieni il codice sorgente: Fai clic qui per ottenere il codice sorgente che utilizzerai per imparare a usare MongoDB con Python in questo tutorial.

Utilizzo di database SQL e NoSQL

Per decenni, i database SQL sono stati una delle uniche scelte per gli sviluppatori che desideravano creare sistemi di database scalabili e di grandi dimensioni. Tuttavia, la crescente necessità di archiviare strutture di dati complesse ha portato alla nascita di NoSQL banche dati. Questo nuovo tipo di sistema di database consente agli sviluppatori di archiviare dati eterogenei e privi di struttura in modo efficiente.

In generale, i sistemi di database NoSQL archiviano e recuperano i dati in un modo molto diverso dai sistemi di gestione di database relazionali SQL (RDBMS).

Quando si tratta di scegliere tra le tecnologie di database attualmente disponibili, potrebbe essere necessario decidere se utilizzare i sistemi SQL o NoSQL. Entrambi hanno caratteristiche specifiche che dovresti considerare quando scegli l'una o l'altra. Ecco alcune delle loro differenze più sostanziali:

Esistono molte altre differenze tra i due tipi di database, ma quelli menzionati sopra sono tra i più importanti da conoscere.

Quando si sceglie un database, è necessario considerare attentamente i suoi punti di forza e di debolezza. Devi anche considerare come il database si adatta al tuo scenario specifico e ai requisiti della tua applicazione. A volte la soluzione giusta è utilizzare una combinazione di database SQL e NoSQL per gestire diversi aspetti di un sistema più ampio.

Alcuni esempi comuni di database SQL includono:

• SQLite
• MySQL
• Oracolo
• PostgreSQL
• Microsoft SQL Server

Esempi di database NoSQL includono:

• DynamoDB
• Cassandra
• Redis
• CouchDB
• RethinkDB
• RavenDB
• MongoDB

Negli ultimi anni, i database SQL e NoSQL hanno persino iniziato a fondersi. Ad esempio, i sistemi di database, come PostgreSQL, MySQL e Microsoft SQL Server, ora supportano l'archiviazione e l'esecuzione di query sui dati JSON, proprio come i database NoSQL. Con questo, ora puoi ottenere molti degli stessi risultati con entrambe le tecnologie. Ma non hai ancora molte delle funzionalità di NoSQL, come il ridimensionamento orizzontale e l'interfaccia intuitiva.

Con questo breve background sui database SQL e NoSQL, puoi concentrarti sull'argomento principale di questo tutorial:il database MongoDB e come usarlo in Python.

Gestire i database NoSQL con MongoDB

MongoDB è un orientato ai documenti database classificato come NoSQL. È diventato popolare in tutto il settore negli ultimi anni e si integra molto bene con Python. A differenza dei tradizionali RDBMS SQL, MongoDB utilizza raccolte di documenti invece di tabelle di righe per organizzare e archiviare i dati.

MongoDB archivia i dati in documenti simili a JSON senza schema e flessibili. Qui, senza schema significa che puoi avere documenti con un diverso insieme di campi nella stessa collezione, senza la necessità di soddisfare uno schema tabellare rigido .

Puoi modificare la struttura dei tuoi documenti e dati nel tempo, il che si traduce in un sistema flessibile che ti consente di adattarti rapidamente alle modifiche dei requisiti senza la necessità di un complesso processo di migrazione dei dati. Tuttavia, il compromesso nel modificare la struttura dei nuovi documenti è che i documenti in uscita diventano incoerenti con lo schema aggiornato. Quindi questo è un argomento che deve essere gestito con cura.

Nota: JSON sta per JavaScript Object Notation . È un formato di file con una struttura leggibile dall'uomo composta da coppie chiave-valore che possono essere annidate arbitrariamente in profondità.

MongoDB è scritto in C++ e sviluppato attivamente da MongoDB Inc. Funziona su tutte le principali piattaforme, come macOS, Windows, Solaris e la maggior parte delle distribuzioni Linux. In generale, ci sono tre obiettivi di sviluppo principali dietro il database MongoDB:

1. Ridimensiona bene
2. Memorizza strutture di dati avanzate
3. Fornire un sofisticato meccanismo di query

MongoDB è un distribuito database, quindi disponibilità elevata, ridimensionamento orizzontale e distribuzione geografica sono integrati nel sistema. Memorizza i dati in documenti flessibili simili a JSON. Puoi modellare questi documenti per mappare gli oggetti nelle tue applicazioni, il che rende possibile lavorare con i tuoi dati in modo efficace.

MongoDB fornisce un potente linguaggio di query che supporta query ad hoc, indicizzazione, aggregazione, ricerca geospaziale, ricerca di testo e molto altro. Questo ti presenta un potente kit di strumenti per accedere e lavorare con i tuoi dati. Infine, MongoDB è disponibile gratuitamente e ha un ottimo supporto per Python.

Revisione delle funzionalità di MongoDB

Finora, hai imparato cos'è MongoDB e quali sono i suoi obiettivi principali. In questa sezione imparerai alcune delle funzionalità più importanti di MongoDB. Per quanto riguarda la gestione del database, MongoDB offre le seguenti funzionalità:

• Supporto per le query: Puoi utilizzare molti tipi di query standard, come la corrispondenza (== ), confronto (< , > ), ed espressioni regolari.
• Inserimento dati: Puoi archiviare praticamente qualsiasi tipo di dato, strutturato, parzialmente strutturato o anche polimorfico.
• Scalabilità: Gestisce più query semplicemente aggiungendo più macchine al cluster di server.
• Flessibilità e agilità: Puoi sviluppare applicazioni con esso rapidamente.
• Orientamento del documento e assenza di schemi: Puoi archiviare tutte le informazioni relative a un modello di dati in un unico documento.
• Schema regolabile: Puoi modificare al volo lo schema del database, riducendo il tempo necessario per fornire nuove funzionalità o risolvere problemi esistenti.
• Funzionalità database relazionali: Puoi eseguire azioni comuni ai database relazionali, come l'indicizzazione.

Per quanto riguarda il lato operativo, MongoDB fornisce alcuni strumenti e funzionalità che non troverai in altri sistemi di database:

• Scalabilità: Sia che tu abbia bisogno di un server autonomo o di cluster completi di server indipendenti, puoi ridimensionare MongoDB a qualsiasi dimensione tu voglia.
• Supporto per il bilanciamento del carico: MongoDB sposterà automaticamente i dati tra vari shard.
• Supporto per il failover automatico: Se il tuo server primario non funziona, un nuovo server primario sarà attivo e funzionerà automaticamente.
• Strumenti di gestione: Puoi monitorare le tue macchine utilizzando il MongoDB Management Service (MMS) basato su cloud.
• Efficienza della memoria: Grazie ai file mappati in memoria, MongoDB è spesso più efficiente dei database relazionali.

Tutte queste funzionalità sono abbastanza utili. Ad esempio, se si sfrutta la funzione di indicizzazione, gran parte dei dati verranno conservati in memoria per un rapido recupero. Anche senza indicizzare chiavi di documenti specifiche, MongoDB memorizza nella cache un bel po' di dati usando la tecnica usata meno di recente.

Installazione ed esecuzione di MongoDB

Ora che hai familiarità con MongoDB, è ora di sporcarti le mani e iniziare a usarlo. Ma prima devi installarlo sulla tua macchina. Il sito ufficiale di MongoDB fornisce due edizioni del server di database:

1. L'edizione community offre il modello di documento flessibile insieme a query ad hoc, indicizzazione e aggregazione in tempo reale per fornire metodi efficaci per accedere e analizzare i dati. Questa edizione è disponibile gratuitamente.
2. L'edizione enterprise offre le stesse funzionalità dell'edizione community, oltre ad altre funzionalità avanzate relative alla sicurezza e al monitoraggio. Questa è l'edizione commerciale, ma puoi utilizzarla gratuitamente per un tempo illimitato per scopi di valutazione e sviluppo.

Se sei su Windows, puoi leggere il tutorial di installazione per le istruzioni complete. In generale, puoi andare alla pagina di download, selezionare la piattaforma Windows nella casella Download disponibili, scegliere il .msi programma di installazione adatto al tuo sistema attuale e fai clic su Download .

Esegui il programma di installazione e segui le istruzioni sullo schermo nella procedura guidata di installazione. Questa pagina fornisce anche informazioni su come eseguire MongoDB come servizio Windows.

Se sei su macOS, puoi utilizzare Homebrew per installare MongoDB sul tuo sistema. Consulta il tutorial di installazione per ottenere la guida completa. Inoltre, assicurati di seguire le istruzioni per eseguire MongoDB come servizio macOS.

Se sei su Linux, il processo di installazione dipenderà dalla tua distribuzione specifica. Per una guida dettagliata su come installare MongoDB su diversi sistemi Linux, vai alla pagina del tutorial di installazione e seleziona il tutorial che corrisponde al tuo attuale sistema operativo. Assicurati di eseguire il demone MongoDB, mongod , al termine dell'installazione.

Infine, puoi anche installare MongoDB usando Docker. Questo è utile se non vuoi ingombrare il tuo sistema con un'altra installazione. Se preferisci questa opzione di installazione, puoi leggere il tutorial ufficiale e seguirne le indicazioni. Tieni presente che in questo caso sarebbe richiesta una conoscenza precedente di come utilizzare Docker.

Con il database MongoDB installato e in esecuzione sul tuo sistema, puoi iniziare a lavorare con database reali usando il mongo guscio.

Creazione di database MongoDB con mongo Conchiglia

Se hai seguito le istruzioni di installazione ed esecuzione, dovresti già avere un'istanza di MongoDB in esecuzione sul tuo sistema. Ora puoi iniziare a creare e testare i tuoi database. In questa sezione imparerai come usare il mongo shell per creare, leggere, aggiornare ed eliminare documenti su un database.

Eseguire mongo Conchiglia

Il mongo shell è un'interfaccia JavaScript interattiva per MongoDB. Puoi utilizzare questo strumento per interrogare e manipolare i tuoi dati, nonché per eseguire operazioni amministrative. Poiché si tratta di un'interfaccia JavaScript, non utilizzerai il familiare linguaggio SQL per interrogare il database. Invece, utilizzerai il codice JavaScript.

Per avviare il mongo shell, apri il terminale o la riga di comando ed esegui il seguente comando:

$ mongo

Questo comando ti porta a mongo guscio. A questo punto, probabilmente vedrai un mucchio di messaggi con informazioni sulla versione della shell e sull'indirizzo e la porta del server. Infine, ti verrà presentato il prompt della shell (> ) per inserire query e comandi.

Puoi passare l'indirizzo del database come argomento a mongo comando. È inoltre possibile utilizzare diverse opzioni, come specificare l'host e la porta per accedere a un database remoto e così via. Per maggiori dettagli su come usare mongo comando, puoi eseguire mongo --help .

Stabilire una connessione

Quando esegui mongo comando senza argomenti, avvia la shell e si connette al server locale predefinito fornito da mongod procedi su mongod://127.0.0.1:27017 . Ciò significa che sei connesso all'host locale tramite la porta 27017 .

Per impostazione predefinita, il mongo shell avvia la sessione stabilendo una connessione al test Banca dati. Puoi accedere al database corrente tramite il db oggetto:

> db
test
>

In questo caso, db contiene un riferimento a test , che è il database predefinito. Per cambiare database, immetti il ​​comando use , fornendo un nome di database come argomento.

Ad esempio, supponiamo di voler creare un sito Web per pubblicare contenuti Python e di utilizzare MongoDB per archiviare tutorial e articoli. In tal caso, puoi passare al database del sito con il seguente comando:

> use rptutorials
switched to db rptutorials

Questo comando cambia la tua connessione a rptutorials Banca dati. MongoDB non crea il file di database fisico sul file system finché non inserisci dati reali nel database. Quindi, in questo caso, rptutorials non verrà visualizzato nell'elenco di database corrente:

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

Il mongo shell offre molte funzionalità e opzioni. Ti consente di interrogare e manipolare i tuoi dati e anche di gestire il server del database stesso.

Invece di utilizzare un linguaggio di query standardizzato come SQL, mongo shell utilizza il linguaggio di programmazione JavaScript e un'API intuitiva. Questa API ti consente di giocare con i tuoi dati, che è l'argomento della prossima sezione.

Creazione di raccolte e documenti

Un database MongoDB è un contenitore fisico per raccolte di documenti. Ogni database ottiene il proprio set di file sul file system. Questi file sono gestiti dal server MongoDB, che può gestire diversi database.

In MongoDB, una raccolta è un gruppo di documenti . Le raccolte sono in qualche modo analoghe alle tabelle in un RDBMS tradizionale, ma senza imporre uno schema rigido. In teoria, ogni documento in una raccolta può avere una struttura o un insieme di campi completamente diversi.

In pratica, i documenti in una raccolta condividono comunemente una struttura simile per consentire processi di recupero, inserimento e aggiornamento uniformi. Puoi applicare una struttura del documento uniforme utilizzando le regole di convalida del documento durante gli aggiornamenti e gli inserimenti.

Consentire diverse strutture di documenti è una caratteristica fondamentale delle raccolte MongoDB. Questa funzionalità offre flessibilità e consente di aggiungere nuovi campi ai documenti senza la necessità di modificare uno schema di tabella formale.

Per creare una collezione usando il mongo shell, devi puntare a db al database di destinazione e quindi creare le raccolte utilizzando la notazione punto :

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

In questo esempio, usi la notazione del punto per creare tutorial come raccolta in rptutorials , che è il tuo attuale database. È importante notare che MongoDB crea database e raccolte pigramente . In altre parole, vengono creati fisicamente solo dopo aver inserito il primo documento.

Una volta che hai un database e una collezione, puoi iniziare a inserire i documenti. I documenti sono l'unità di archiviazione in MongoDB. In un RDBMS, questo sarebbe equivalente a una riga di tabella. Tuttavia, i documenti di MongoDB sono molto più versatili delle righe perché possono archiviare informazioni complesse, come array, documenti incorporati e persino array di documenti.

MongoDB archivia i documenti in un formato chiamato JSON binario (BSON), che è una rappresentazione binaria di JSON. I documenti di MongoDB sono composti da coppie campo e valore e hanno la seguente struttura:

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

Il valore di un campo può essere qualsiasi tipo di dati BSON, inclusi altri documenti, matrici e matrici di documenti. In pratica, specificherai i tuoi documenti utilizzando il formato JSON.

Quando crei un'applicazione di database MongoDB, probabilmente la tua decisione più importante riguarda la struttura dei documenti. In altre parole, dovrai decidere quali campi e valori avranno i tuoi documenti.

Nel caso dei tutorial per il tuo sito Python, i tuoi documenti potrebbero essere strutturati in questo modo:

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

Un documento è essenzialmente un insieme di nomi di proprietà e dei relativi valori. I valori possono essere tipi di dati semplici, come stringhe e numeri, ma possono anche essere array come contributors nell'esempio sopra.

Il modello di dati orientato ai documenti di MongoDB rappresenta naturalmente i dati complessi come un singolo oggetto. Ciò ti consente di lavorare con gli oggetti dati in modo olistico, senza la necessità di guardare più posti o tabelle.

Se stavi utilizzando un RDBMS tradizionale per archiviare i tuoi tutorial, probabilmente avresti una tabella in cui archiviare i tuoi tutorial e un'altra tabella in cui archiviare i tuoi contributori. Quindi dovresti impostare una relazione tra entrambe le tabelle in modo da poter recuperare i dati in un secondo momento.

Lavorare con raccolte e documenti

Finora, conosci le basi su come eseguire e utilizzare mongo guscio. Sai anche come creare i tuoi documenti usando il formato JSON. Ora è il momento di imparare come inserire documenti nel tuo database MongoDB.

Per inserire un documento in un database usando il mongo shell, devi prima scegliere una collezione e poi chiamare .insertOne() sulla raccolta con il tuo documento come argomento:

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

Con il primo comando si passa al database che si desidera utilizzare. Il secondo comando è una chiamata al metodo JavaScript che inserisce un semplice documento nella raccolta selezionata, tutorial . Dopo aver premuto Invio , sullo schermo viene visualizzato un messaggio che ti informa sul documento appena inserito e sul suo insertedId .

Proprio come i database relazionali necessitano di una chiave primaria per identificare in modo univoco ogni riga di una tabella, i documenti MongoDB devono avere un _id campo che identifica univocamente il documento. MongoDB ti consente di inserire un _id personalizzato purché tu ne garantisca l'unicità. Tuttavia, una pratica ampiamente accettata è quella di consentire a MongoDB di inserire automaticamente un _id per te.

Allo stesso modo, puoi aggiungere più documenti in una volta usando .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")
    ]
}

Qui, la chiamata a .insertMany() prende un elenco di tutorial e li inserisce nel database. Anche in questo caso, l'output della shell mostra le informazioni sui documenti appena inseriti e sul loro _id aggiunto automaticamente campi.

Il mongo shell fornisce anche metodi per eseguire operazioni di lettura, aggiornamento ed eliminazione sul database. Ad esempio, puoi utilizzare .find() per recuperare i documenti in una collezione:

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

La prima chiamata a .find() recupera tutti i documenti nel tutorial collezione. D'altra parte, la seconda chiamata a .find() recupera i tutorial creati da Joanna.

Con questa conoscenza di base su come usare MongoDB attraverso il suo mongo shell, sei pronto per iniziare a usare MongoDB con Python. Le prossime sezioni ti guideranno attraverso diverse opzioni per l'utilizzo dei database MongoDB nelle tue applicazioni Python.

Utilizzo di MongoDB con Python e PyMongo

Ora che sai cos'è MongoDB e come creare e gestire database usando mongo shell, puoi iniziare a usare MongoDB, ma questa volta con Python. MongoDB fornisce un driver Python ufficiale chiamato PyMongo.

In questa sezione, esaminerai alcuni esempi che ti aiuteranno a farti un'idea di come utilizzare PyMongo per creare le tue applicazioni di database con MongoDB e Python.

Ogni modulo all'interno di PyMongo è responsabile di una serie di operazioni sul database. Avrai moduli per almeno le seguenti attività:

• Stabilire connessioni al database
• Lavorare con i database
• Lavorare con raccolte e documenti
• Manipolazione del cursore
• Lavorare con la crittografia dei dati

In generale, PyMongo fornisce un ricco set di strumenti che puoi utilizzare per comunicare con un server MongoDB. Fornisce funzionalità per interrogare, recuperare risultati, scrivere ed eliminare dati ed eseguire comandi di database.

Installazione di PyMongo

Per iniziare a usare PyMongo, devi prima installarlo nel tuo ambiente Python. È possibile utilizzare un ambiente virtuale oppure è possibile utilizzare l'installazione di Python a livello di sistema, sebbene sia preferibile la prima opzione. PyMongo è disponibile su PyPI, quindi il modo più rapido per installarlo è con pip . Accendi il terminale ed esegui il seguente comando:

$ pip install pymongo==3.11.2

Dopo alcuni download e altri passaggi correlati, questo comando installa PyMongo sul tuo ambiente Python. Tieni presente che se non fornisci un numero di versione specifico, pip installerà l'ultima versione disponibile.

Nota: Per una guida completa su come installare PyMongo, controlla la pagina Installazione/Aggiornamento della sua documentazione ufficiale.

Una volta terminata l'installazione, puoi avviare una sessione interattiva Python ed eseguire la seguente importazione:

>>> import pymongo

Se viene eseguito senza sollevare un'eccezione nella shell Python, l'installazione funziona perfettamente. In caso contrario, esegui nuovamente i passaggi con attenzione.

Stabilire una connessione

Per stabilire una connessione a un database, devi creare un MongoClient esempio. Questa classe fornisce un client per un'istanza o un server MongoDB. Ogni oggetto client ha un pool di connessioni integrato, che per impostazione predefinita gestisce fino a cento connessioni al server.

Torna alla tua sessione interattiva Python e importa MongoClient da pymongo . Quindi crea un oggetto client per comunicare con l'istanza MongoDB attualmente in esecuzione:

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

Il codice sopra stabilisce una connessione all'host predefinito (localhost ) e la porta (27017 ). MongoClient accetta una serie di argomenti che consentono di specificare host, porta e altri parametri di connessione personalizzati. Ad esempio, per fornire un host e una porta personalizzati, puoi utilizzare il codice seguente:

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

Questo è utile quando devi fornire un host e port che differiscono dalla configurazione predefinita di MongoDB. Puoi anche utilizzare il formato URI MongoDB:

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

Tutte queste istanze di MongoClient fornisci la stessa configurazione del client per connettere la tua attuale istanza MongoDB. Quale dovresti usare dipende solo da quanto vuoi essere esplicito nel tuo codice.

Dopo aver creato un'istanza di MongoClient , puoi usare la sua istanza per fare riferimento a quella specifica connessione al database, proprio come hai fatto con mongo db della shell oggetto nella sezione precedente.

Lavorare con database, raccolte e documenti

Dopo aver connesso un'istanza di MongoClient , puoi accedere a qualsiasi database gestito dal server MongoDB specificato. Per definire quale database vuoi usare, puoi usare la notazione del punto proprio come hai fatto in mongo guscio:

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

In questo caso, rptutorials è il nome del database con cui lavorerai. Se il database non esiste, MongoDB lo crea per te, ma solo quando esegui la prima operazione sul database.

Puoi anche utilizzare l'accesso in stile dizionario se il nome del database non è un identificatore Python valido:

>>> db = client["rptutorials"]

Questa istruzione è utile quando il nome del tuo database non è un identificatore Python valido. Ad esempio, se il tuo database si chiama rp-tutorials , quindi devi utilizzare l'accesso in stile dizionario.

Nota: Quando usi mongo shell, hai accesso al database tramite il db oggetto globale. Quando usi PyMongo, puoi assegnare il database a una variabile chiamata db per ottenere un comportamento simile.

La memorizzazione dei dati nel database utilizzando PyMongo è simile a quella che hai fatto con mongo shell nelle sezioni precedenti. Ma prima devi creare i tuoi documenti. In Python, usi i dizionari per creare documenti:

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

Dopo aver creato il documento come dizionario, devi specificare quale raccolta desideri utilizzare. Per fare ciò, puoi utilizzare la notazione del punto sull'oggetto database:

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

In questo caso, tutorial è un'istanza di Collection e rappresenta una raccolta fisica di documenti nel database. Puoi inserire documenti in tutorial chiamando .insert_one() su di esso con un documento come argomento:

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

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

Qui, .insert_one() accetta tutorial1 , lo inserisce nel tutorial raccolta e restituisce un InsertOneResult oggetto. Questo oggetto fornisce un feedback sul documento inserito. Nota che poiché MongoDB genera ObjectId dinamicamente, il tuo output non corrisponderà a ObjectId mostrato sopra.

Se hai molti documenti da aggiungere al database, puoi usare .insert_many() per inserirli in un colpo solo:

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

Questo è più veloce e più semplice che chiamare .insert_one() più volte. La chiamata a .insert_many() prende un iterabile di documenti e li inserisce nel tutorial raccolta nei tuoi rptutorials Banca dati. Il metodo restituisce un'istanza di InsertManyResult , che fornisce informazioni sui documenti inseriti.

Per recuperare documenti da una raccolta, puoi utilizzare .find() . Senza argomenti, .find() restituisce un Cursor oggetto che restituisce i documenti in collezione a richiesta:

>>> 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 dichiarazione. 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 comando:

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

Note: 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 il campo è obbligatiorio. 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.