Tot ce trebuie să știți despre Python și hărțile relaționale dintre obiecte

Tot ce trebuie să știți despre Python și hărțile relaționale dintre obiecte

Este posibil să fi auzit de cartarea obiect-relațională (ORM). Este posibil să fi folosit chiar una, dar ce anume sunt acestea? Și cum le folosești în Python?





Iată tot ce trebuie să știți despre ORM-uri și Python.



Ce este un ORM?

Cartarea obiect-relațională (ORM) este o tehnică de programare utilizată pentru a accesa o bază de date. Vă expune baza de date într-o serie de obiecte. Nu trebuie să scrieți comenzi SQL pentru a insera sau prelua date, utilizați o serie de atribute și metode atașate obiectelor.





Poate suna complex și inutil, dar vă pot economisi mult timp și vă pot ajuta să controlați accesul la baza de date.

Iată un exemplu. Spuneți că ori de câte ori introduceți o parolă în baza de date, doriți să o hash, așa cum este explicat în securitatea parolei site-ului web. Aceasta nu este o problemă pentru cazurile de utilizare simple --- faceți calculul înainte de a introduce. Dar dacă trebuie să introduceți o înregistrare în multe locuri din cod? Ce se întâmplă dacă un alt programator introduce în masa dvs. și nu știți despre?



Utilizând un ORM, puteți scrie cod pentru a vă asigura că ori de câte ori și oriunde este accesat orice rând sau câmp din baza de date, celălalt cod personalizat este executat mai întâi.

Aceasta acționează și ca o „sursă unică de adevăr”. Dacă doriți să modificați un calcul personalizat, trebuie să îl modificați doar într-un singur loc, nu în mai multe. Este posibil să îndepliniți multe dintre aceste principii cu programare orientată pe obiecte (OOP) în Python , dar ORM-urile funcționează în tandem cu principiile OOP pentru a controla accesul la o bază de date.



Există anumite lucruri de care trebuie să fii atent când folosești un ORM și există circumstanțe în care este posibil să nu vrei să folosești unul, dar sunt considerate, în general, un lucru bun, mai ales într-o bază de cod mare.

ORM-uri în Python folosind SQLAlchemy

La fel ca multe activități din Python, este mai rapid și mai ușor să importați un modul decât să scrieți al dvs. Desigur, este posibil să scrieți propriul ORM, dar de ce să reinventați roata?



Următoarele exemple sunt folosite SQLAlchimie , un ORM Python popular, dar multe dintre principii se aplică indiferent de implementare.

Configurarea Python pentru SQLAlchemy

Înainte de a intra direct, va trebui să vă configurați mașina pentru dezvoltarea Python cu SQLAlchemy.

Va trebui să utilizați Python 3.6 pentru a urma împreună cu aceste exemple. În timp ce versiunile mai vechi vor funcționa, codul de mai jos va necesita unele modificări înainte de a rula. Nu sunteți sigur cu privire la diferențe? Întrebările noastre frecvente despre Python acoperă toate diferențele.

Înainte de codificare, ar trebui să configurați un mediu Python, care va preveni probleme cu alte pachete Python importate.

Asigura-te ca ai PIP, managerul de pachete Python instalat, care vine cu cele mai multe versiuni moderne de Python.

Odată ce sunteți gata de plecare, puteți începe prin a pregăti SQLAlchemy. Din mediul dvs. Python din linia de comandă, instalați SQLAlchemy cu instalare pip comanda:

pip install SQLAlchemy-1.2.9

The 1.2.9 este numărul versiunii. Puteți lăsa acest lucru oprit pentru a obține cel mai recent pachet, dar este o bună practică să fiți specific. Nu știți când o nouă versiune vă poate rupe codul actual.

Acum sunteți gata să începeți codarea. Este posibil să trebuiască să vă pregătiți baza de date pentru a accepta o conexiune Python, dar următoarele exemple folosesc toate un SQLite baza de date creată în memorie mai jos.

Modele în SQLAlchemy

Una dintre componentele cheie ale unui ORM este un model . Aceasta este o clasă Python care prezintă cum ar trebui să arate un tabel și cum ar trebui să funcționeze. Este versiunea ORM a CREAȚI TABEL declarație în SQL. Aveți nevoie de un model pentru fiecare tabel din baza de date.

Deschideți editorul de text preferat sau IDE și creați un fișier nou numit test.py . Introduceți acest cod de pornire, salvați fișierul și rulați-l:

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

Acest cod face mai multe lucruri. Importurile sunt necesare pentru ca Python să înțeleagă unde să găsească modulele SQLAlchemy de care are nevoie. Modelele dvs. vor folosi declarative_base ulterior și configurează orice modele noi pentru a funcționa așa cum era de așteptat.

The create_engine metoda creează o nouă conexiune la baza de date. Dacă aveți deja o bază de date, va trebui să vă schimbați sqlite: // în baza de date URI. Într-adevăr, acest cod va crea o nouă bază de date numai în memorie. Baza de date este distrusă odată ce codul dvs. termină de executat.

În cele din urmă, create_all metoda creează toate tabelele definite în modurile dvs. în baza de date. Deoarece nu ați definit încă niciun model, nu se va întâmpla nimic. Continuați și rulați acest cod, pentru a vă asigura că nu aveți probleme sau greșeli de scriere.

Să facem un model. Adăugați un alt import în partea de sus a fișierului:

from sqlalchemy import Column, Integer, String

Aceasta importă Coloană , Întreg , și Şir module din SQLAlchemy. Acestea definesc modul în care funcționează tabelele, câmpurile, coloanele și tipurile de date ale bazei de date.

Sub declarative_base , creați clasa modelului:

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

Acest exemplu simplu folosește mașini, dar tabelele dvs. pot conține orice date.

Fiecare clasă trebuie să moștenească Baza . Numele tabelului bazei de date este definit în __tablename__ . Acesta ar trebui să fie același cu numele clasei, dar aceasta este doar o recomandare și nimic nu se va sparge dacă nu se potrivesc.

În cele din urmă, fiecare coloană este definită ca o variabilă python în cadrul clasei. Sunt folosite diferite tipuri de date și cheia principala atributul îi spune lui SQLAlchemy să creeze id coloană ca cheie principală.

Continuați și adăugați un ultim import, de data aceasta pentru Cheie externă modul. Adăugați acest lucru alături de Coloană import:

from sqlalchemy import Column, ForeignKey, Integer, String

Acum creați o a doua clasă de model. Această clasă se numește Proprietarii de mașini , și stochează detaliile proprietarului magazinelor de mașini specifice stocate în Mașini masa:

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)

Aici sunt introduse câteva atribute noi. The car_id câmpul este definit ca o cheie străină. Este legat de id în mașini masa. Observați modul în care este utilizat numele tabelului minuscul, instatat cu numele clasei majuscule.

În cele din urmă, un atribut al mașină este definit ca a relaţie . Acest lucru permite modelului dvs. să acceseze Mașini treceți prin această variabilă. Acest lucru este demonstrat mai jos.

Dacă rulați acest cod acum, veți vedea că nu se întâmplă nimic. Acest lucru se datorează faptului că nu i-ați spus încă să facă nimic vizibil.

Obiecte în SQLAlchemy

Acum că modelele dvs. sunt create, puteți începe să accesați obiectele și să citiți și să scrieți date. Este o idee bună să vă așezați logica în propria clasă și fișier, dar deocamdată poate rămâne alături de modele.

Scrierea datelor

În acest exemplu, trebuie să inserați unele date în baza de date înainte de ao putea citi. Dacă utilizați o bază de date existentă, este posibil să aveți deja date. Oricum ar fi, este încă foarte util să știți cum să inserați date.

Poți fi obișnuit să scrii INTRODUCE declarații în SQL. SQLAlchemy se ocupă de acest lucru pentru dvs. Iată cum se introduce un rând în Mașini model. Începeți cu un nou import pentru fabricant de sesiuni :

from sqlalchemy.orm import sessionmaker

Acest lucru este necesar pentru a crea fișierul sesiune și DBSession obiecte, care sunt folosite pentru a citi și scrie date:

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

Acum pune asta sub create_all afirmație:

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

Să descompunem acest cod. Variabila car1 este definit ca un obiect bazat pe Mașini model. Marca și culoarea acestuia sunt setate ca parametri. Este ca și cum ai spune „fă-mă o mașină, dar nu o scrie încă în baza de date”. Această mașină există în memorie, dar așteaptă să fie scrisă.

Adăugați mașina la sesiune cu sesiune.add , apoi scrieți-l în baza de date cu sesiune.comit .

Acum să adăugăm un proprietar:

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

Acest cod este aproape identic cu inserția anterioară pentru Mașini model. Principala diferență aici este că car_id este o cheie străină, deci are nevoie de un id de rând care există în cealaltă tabelă. Acest lucru este accesat prin car1.id proprietate.

Nu trebuie să interogați baza de date sau să returnați niciun ID, deoarece SQLAlchemy gestionează acest lucru pentru dvs. (atâta timp cât comiteți mai întâi datele).

Citirea datelor

După ce ați scris câteva date, puteți începe să le citiți din nou. Iată cum să interogați fișierul Mașini și Proprietarii de mașini Mese:

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

Este atât de simplu. Prin utilizarea interogare metoda găsită în sesiune , specificați modelul și apoi utilizați toate metoda de recuperare a tuturor rezultatelor. Dacă știți că va exista un singur rezultat, atunci puteți utiliza fișierul primul metodă:

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

După ce ați întrebat modelul și ați stocat rezultatele returnate într-o variabilă, puteți accesa datele prin intermediul obiectului:

print(result[0].color)

Aceasta imprimă culoarea „argintiu”, deoarece înregistrarea este primul rând. Puteți face loop peste obiectul rezultat dacă doriți.

Pe măsură ce ați definit relația în modelul dvs., este posibil să accesați datele din tabelele conexe fără a specifica o asociere:

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

Acest lucru funcționează deoarece modelul dvs. conține detalii despre structura tabelului și mașină atributul a fost definit ca o legătură către mașini masa.

Ce nu-ți place despre ORM-uri?

Acest tutorial a acoperit doar elementele de bază, dar odată ce le-ați atins, puteți trece la subiectele avansate. Există unele potențiale dezavantaje ale ORM-urilor:

  • Trebuie să scrieți modelul înainte ca orice interogare să poată rula.
  • Este o altă sintaxă nouă de învățat.
  • Poate fi prea complex pentru nevoi simple.
  • Pentru început trebuie să aveți un design bun al bazei de date.

Aceste probleme nu sunt o mare problemă de la sine, dar sunt lucruri de care trebuie să fii atent. Dacă lucrați cu o bază de date existentă, este posibil să fiți prins.

Dacă nu sunteți convins că un ORM este instrumentul potrivit pentru dvs., atunci asigurați-vă că ați citit despre importante comenzi SQL ar trebui să știe programatorii .

Acțiune Acțiune Tweet E-mail Ar trebui să faceți upgrade la Windows 11 imediat?

Windows 11 vine în curând, dar ar trebui să vă actualizați cât mai curând posibil sau să așteptați câteva săptămâni? Să aflăm.

Citiți în continuare Subiecte asemănătoare
  • Programare
  • Piton
  • SQL
  • Tutoriale de codare
Despre autor Joe Coburn(136 articole publicate)

Joe este absolvent de Informatică de la Universitatea Lincoln, Marea Britanie. Este un dezvoltator de software profesionist și, atunci când nu zboară cu drone sau nu scrie muzică, poate fi găsit adesea făcând fotografii sau producând videoclipuri.

cum se dezactivează subtitrările pe netflix
Mai multe de la Joe Coburn

Aboneaza-te la newsletter-ul nostru

Alăturați-vă newsletterului pentru sfaturi tehnice, recenzii, cărți electronice gratuite și oferte exclusive!

Faceți clic aici pentru a vă abona