Tutto quello che c'è da sapere su Python e sulle mappe relazionali a oggetti

Tutto quello che c'è da sapere su Python e sulle mappe relazionali a oggetti

Potresti aver sentito parlare di mappatura relazionale a oggetti (ORM). Potresti anche averne usato uno, ma cosa sono esattamente? E come li usi in Python?





Ecco tutto ciò che devi sapere su ORM e Python.



Che cos'è un ORM?

La mappatura relazionale a oggetti (ORM) è una tecnica di programmazione utilizzata per accedere a un database. Espone il tuo database in una serie di oggetti. Non è necessario scrivere comandi SQL per inserire o recuperare dati, si utilizzano una serie di attributi e metodi associati agli oggetti.





Può sembrare complesso e non necessario, ma possono farti risparmiare molto tempo e aiutarti a controllare l'accesso al tuo database.

Ecco un esempio. Supponiamo che ogni volta che inserisci una password nel tuo database desideri eseguirne l'hash, come spiegato in Sicurezza della password del sito web . Questo non è un problema per i casi d'uso semplici --- fai il calcolo prima di inserire. Ma cosa succede se è necessario inserire un record in più punti del codice? Cosa succede se un altro programmatore si inserisce nella tua tabella e non lo sai?



Utilizzando un ORM, puoi scrivere codice per assicurarti che ogni volta che e ovunque si accede a qualsiasi riga o campo nel database, l'altro codice personalizzato venga eseguito per primo.

Questo agisce anche come 'unica fonte di verità'. Se vuoi modificare un calcolo personalizzato, devi solo modificarlo in un punto, non in diversi. È possibile eseguire molti di questi principi con programmazione orientata agli oggetti (OOP) in Python , ma gli ORM lavorano in tandem con i principi OOP per controllare l'accesso a un database.



Ci sono alcune cose a cui prestare attenzione quando si utilizza un ORM e ci sono circostanze in cui potresti non volerne usare uno, ma sono generalmente considerate una buona cosa da avere, specialmente in una grande base di codice.

ORM in Python usando SQLAlchemy

Come molte attività in Python, è più veloce e più facile importare un modulo che scriverne uno proprio. Certo, è possibile scrivere il proprio ORM, ma perché reinventare la ruota?



I seguenti esempi usano tutti SQLAlchemy , un popolare ORM Python, ma molti dei principi si applicano indipendentemente dall'implementazione.

Configurazione di Python per SQLAlchemy

Prima di iniziare, dovrai configurare la tua macchina per lo sviluppo di Python con SQLAlchemy.

Dovrai usare Python 3.6 per seguire questi esempi. Anche se le versioni precedenti funzioneranno, il codice seguente richiederà alcune modifiche prima di essere eseguito. Non sei sicuro delle differenze? Le nostre FAQ su Python coprono tutte le differenze.

Prima di codificare, dovresti impostare un ambiente Python, che eviterà problemi con altri pacchetti Python importati.

Assicurati di avere PIP, il gestore di pacchetti Python installato, che viene fornito con la maggior parte delle versioni moderne di Python.

Una volta che sei pronto, puoi iniziare preparando SQLAlchemy. Dall'interno del tuo ambiente Python nella riga di comando, installa SQLAlchemy con il pip install comando:

pip install SQLAlchemy-1.2.9

Il 1.2.9 è il numero di versione. Puoi lasciarlo disattivato per ottenere l'ultimo pacchetto, ma è buona norma essere specifici. Non sai quando una nuova versione potrebbe violare il tuo codice attuale.

Ora sei pronto per iniziare a programmare. Potrebbe essere necessario preparare il database per accettare una connessione Python, ma i seguenti esempi utilizzano tutti an SQLite database creato in memoria di seguito.

Modelli in SQLAlchemy

Uno dei componenti chiave di un ORM è a modello . Questa è una classe Python che delinea come dovrebbe apparire una tabella e come dovrebbe funzionare. È la versione ORM del CREA TABELLA dichiarazione in SQL. Hai bisogno di un modello per ogni tabella nel tuo database.

Apri il tuo editor di testo o IDE preferito e crea un nuovo file chiamato test.py . Inserisci questo codice di avvio, salva il file ed eseguilo:

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
Base = declarative_base()
engine = create_engine('sqlite://') # Create the database in memory
Base.metadata.create_all(engine) # Create all the tables in the database

Questo codice fa diverse cose. Le importazioni sono necessarie affinché Python capisca dove trovare i moduli SQLAlchemy di cui ha bisogno. I tuoi modelli utilizzeranno il base_dichiarativa in seguito e configura tutti i nuovi modelli in modo che funzionino come previsto.

Il creare_motore Il metodo crea una nuova connessione al database. Se hai già un database, dovrai cambiarlo sqlite:// all'URI del tuo database. Così com'è, questo codice creerà un nuovo database solo in memoria. Il database viene distrutto una volta terminata l'esecuzione del codice.

Infine, il create_all Il metodo crea tutte le tabelle definite nelle tue modalità nel tuo database. Poiché non hai ancora definito alcun modello, non accadrà nulla. Vai avanti ed esegui questo codice, per assicurarti di non avere problemi o errori di battitura.

Facciamo un modello. Aggiungi un'altra importazione all'inizio del tuo file:

from sqlalchemy import Column, Integer, String

Questo importa il Colonna , Numero intero , e Corda moduli da SQLAlchemy. Definiscono come funzionano le tabelle, i campi, le colonne e i tipi di dati del database.

sotto il base_dichiarativa , crea la tua classe modello:

class Cars(Base):
__tablename__ = 'cars'
id = Column(Integer, primary_key=True)
make = Column(String(50), nullable=False)
color = Column(String(50), nullable=False)

Questo semplice esempio utilizza le automobili, ma le tue tabelle potrebbero contenere qualsiasi dato.

Ogni classe deve ereditare Base . Il nome della tabella del tuo database è definito in __nometabella__ . Dovrebbe essere lo stesso del nome della classe, ma questa è solo una raccomandazione e nulla si romperà se non corrispondono.

Infine, ogni colonna è definita come una variabile python all'interno della classe. Vengono utilizzati diversi tipi di dati e chiave primaria attributo dice a SQLAlchemy di creare il ID colonna come chiave primaria.

Vai avanti e aggiungi un'ultima importazione, questa volta per il Chiave Estera modulo. Aggiungi questo insieme al tuo Colonna importare:

from sqlalchemy import Column, ForeignKey, Integer, String

Ora crea una seconda classe di modelli. Questa classe si chiama Proprietari di auto e memorizza i dettagli del proprietario di auto specifiche memorizzate nel Macchine tavolo:

class CarOwners(Base):
__tablename__ = 'carowners'
id = Column(Integer, primary_key=True)
name = Column(String(50), nullable=False)
age = Column(Integer, nullable=False)
car_id = Column(Integer, ForeignKey('cars.id'))
car = relationship(Cars)

Ci sono diversi nuovi attributi introdotti qui. Il id_auto campo è definito come una chiave esterna. È legato al ID nel macchine tavolo. Notare come viene utilizzato il nome della tabella minuscolo, invece del nome della classe maiuscolo.

Infine, un attributo di macchina è definito come a relazione . Ciò consente al tuo modello di accedere al Macchine tabella tramite questa variabile. Questo è dimostrato di seguito.

Se esegui questo codice ora, vedrai che non succede nulla. Questo perché non gli hai ancora detto di fare nulla di evidente.

Oggetti in SQLAlchemy

Ora che i tuoi modelli sono stati creati, puoi iniziare ad accedere agli oggetti e leggere e scrivere dati. È una buona idea inserire la tua logica nella propria classe e file, ma per ora può rimanere accanto ai modelli.

Scrittura dei dati

In questo esempio, è necessario inserire alcuni dati nel database prima di poterlo leggere. Se stai utilizzando un database esistente, potresti avere già dei dati. Ad ogni modo, è comunque molto utile sapere come inserire i dati.

Potresti essere abituato a scrivere INSERIRE istruzioni in SQL. SQLAlchemy gestisce questo per te. Ecco come inserire una riga nel Macchine modello. Inizia con una nuova importazione per sessionemaker :

from sqlalchemy.orm import sessionmaker

Questo è necessario per creare il sessione e DBSession oggetti, che vengono utilizzati per leggere e scrivere dati:

DBSession = sessionmaker(bind=engine)
session = DBSession()

Ora metti questo sotto il tuo create_all dichiarazione:

car1 = Cars(
make='Ford',
color='silver'
)
session.add(car1)
session.commit()

Scomponiamo quel codice. La variabile auto1 è definito come un oggetto basato sul Macchine modello. La sua marca e il colore sono impostati come parametri. È come dire 'fai una macchina, ma non scriverla ancora nel database'. Questa macchina esiste in memoria ma aspetta di essere scritta.

Aggiungi l'auto alla sessione con session.add , quindi scrivilo nel database con session.commit .

Ora aggiungiamo un proprietario:

owner1 = CarOwners(
name='Joe',
age='99',
car_id=(car1.id)
)
session.add(owner1)
session.commit()

Questo codice è quasi identico al precedente inserto per il Macchine modello. La differenza principale qui è che id_auto è una chiave esterna, quindi necessita di un ID di riga che esiste nell'altra tabella. Questo è accessibile tramite il auto1.id proprietà.

Non è necessario interrogare il database o restituire alcun ID, poiché SQLAlchemy lo gestisce per te (a patto che tu commetta prima i dati).

Lettura dei dati

Dopo aver scritto alcuni dati, puoi iniziare a rileggerli. Ecco come interrogare il Macchine e Proprietari di auto tabelle:

result = session.query(Cars).all()

È così semplice. Usando il interrogazione metodo trovato nel sessione , si specifica il modello, quindi si usa il Tutti metodo per recuperare tutti i risultati. Se sai che ci sarà un solo risultato, puoi usare il primo metodo:

result = session.query(Cars).first()

Dopo aver interrogato il modello e archiviato i risultati restituiti in una variabile, puoi accedere ai dati tramite l'oggetto:

print(result[0].color)

Questo stampa il colore 'argento', poiché quel record è la prima riga. Se lo desideri, puoi eseguire il loop sull'oggetto risultato.

Poiché hai definito la relazione nel tuo modello, è possibile accedere ai dati nelle tabelle correlate senza specificare un'unione:

result = session.query(CarOwners).all()
print(result[0].name)
print(result[0].car.color)

Funziona perché il modello contiene i dettagli della struttura della tabella e il macchina attributo è stato definito come un collegamento al macchine tavolo.

Cosa non va degli ORM?

Questo tutorial ha coperto solo le basi, ma una volta che hai preso la mano, puoi passare agli argomenti avanzati. Ci sono alcuni potenziali svantaggi degli ORM:

  • Devi scrivere il tuo modello prima di poter eseguire qualsiasi query.
  • È un'altra nuova sintassi da imparare.
  • Potrebbe essere troppo complesso per esigenze semplici.
  • È necessario disporre di un buon design del database per cominciare.

Questi problemi non sono un grosso problema da soli, ma sono cose a cui prestare attenzione. Se stai lavorando con un database esistente, potresti essere scoperto.

Se non sei convinto che un ORM sia lo strumento giusto per te, assicurati di leggere il importanti comandi SQL che i programmatori dovrebbero conoscere .

Condividere Condividere Tweet E-mail Dovresti eseguire l'aggiornamento a Windows 11 immediatamente?

Windows 11 arriverà presto, ma dovresti aggiornare il prima possibile o aspettare qualche settimana? Scopriamolo.

Leggi Avanti Argomenti correlati
  • Programmazione
  • Pitone
  • SQL
  • Tutorial sulla programmazione
Circa l'autore Joe Coburn(136 articoli pubblicati)

Joe si è laureato in Informatica presso l'Università di Lincoln, nel Regno Unito. È uno sviluppatore di software professionista e, quando non pilota droni o scrive musica, lo si trova spesso a scattare foto o produrre video.

come impostare l'account google come predefinito
Altro da Joe Coburn

Iscriviti alla nostra Newsletter

Iscriviti alla nostra newsletter per consigli tecnici, recensioni, ebook gratuiti e offerte esclusive!

Clicca qui per iscriverti