Lahat ng Kailangan Mong Malaman Tungkol sa Python at Mga Mapa na Kaugnay ng Mga Bagay

Lahat ng Kailangan Mong Malaman Tungkol sa Python at Mga Mapa na Kaugnay ng Mga Bagay

Maaaring narinig mo ang tungkol sa pagmamapa ng object-relational (ORM). Maaaring ginamit mo pa ang isa, ngunit ano nga ba sila? At paano mo magagamit ang mga ito sa Python?





Narito ang lahat ng kailangan mong malaman tungkol sa ORMs at Python.



Ano ang isang ORM?

Ang object-relational mapping (ORM) ay isang diskarte sa pagprograma na ginamit upang ma-access ang isang database. Inilalantad nito ang iyong database sa isang serye ng mga bagay. Hindi mo kailangang isulat ang mga utos ng SQL upang maipasok o makuha ang data, gumagamit ka ng isang serye ng mga katangian at pamamaraan na nakakabit sa mga bagay.





Maaari itong tunog kumplikado at hindi kinakailangan, ngunit maaari kang makatipid sa iyo ng maraming oras, at makakatulong upang makontrol ang pag-access sa iyong database.

Narito ang isang halimbawa. Sabihin na tuwing magsingit ka ng isang password sa iyong database nais mong i-hash ito, tulad ng ipinaliwanag sa seguridad ng password sa website. Hindi ito isang problema para sa mga simpleng kaso ng paggamit --- ginagawa mo ang pagkalkula bago ipasok. Ngunit paano kung kailangan mong magsingit ng isang record sa maraming mga lugar sa code? Paano kung ang isa pang programmer ay nagsisingit sa iyong talahanayan, at hindi mo alam ang tungkol sa?



Sa pamamagitan ng paggamit ng isang ORM, maaari kang magsulat ng code upang matiyak na kahit kailan at saanman ma-access ang anumang hilera o patlang sa iyong database, ang iyong iba pang, pasadyang code ay naisakatuparan muna.

Gumagawa rin ito bilang isang 'solong mapagkukunan ng katotohanan'. Kung nais mong baguhin ang isang pasadyang pagkalkula, kailangan mo lamang itong palitan sa isang lugar, hindi marami. Posibleng gumanap ng marami sa mga prinsipyong ito kasama object orientated programming (OOP) sa Python , ngunit gumagana ang mga ORM kasabay ng mga prinsipyo ng OOP upang makontrol ang pag-access sa isang database.



Mayroong ilang mga bagay na dapat abangan kapag gumagamit ng isang ORM, at may mga pangyayari kung saan hindi mo nais na gumamit ng isa, ngunit sa pangkalahatan ay itinuturing silang isang magandang bagay, lalo na sa isang malaking codebase.

Ang mga ORM sa Python Gamit ang SQLAlchemy

Tulad ng maraming mga gawain sa Python, mas mabilis at mas madaling mag-import ng isang module kaysa sa pagsusulat ng iyong sarili. Siyempre, posible na magsulat ng iyong sariling ORM, ngunit bakit muling ibalik ang gulong?



Ang mga sumusunod na halimbawa ay ginagamit lahat SQLAlchemy , isang tanyag na Python ORM, ngunit marami sa mga prinsipyo ang nalalapat anuman ang pagpapatupad.

Pag-set up ng Python para sa SQLAlchemy

Bago tumalon kaagad, kakailanganin mong i-setup ang iyong makina para sa pag-unlad ng Python sa SQLAlchemy.

Kakailanganin mong gamitin ang Python 3.6 upang sundin kasama ang mga halimbawang ito. Habang gagana ang mga mas lumang bersyon, ang code sa ibaba ay mangangailangan ng ilang pagbabago bago ito tumakbo. Hindi sigurado sa mga pagkakaiba? Saklaw ng aming Python FAQ ang lahat ng mga pagkakaiba.

Bago ang pag-coding, dapat mong i-set up ang isang kapaligiran sa Python, na maiiwasan ang mga problema sa iba pang na-import na mga package ng Python.

Siguraduhin na mayroon ka Ang PIP, ang manager ng package sa Python naka-install, na kasama ng karamihan sa mga modernong bersyon ng Python.

Kapag handa ka nang pumunta, maaari kang magsimula sa pamamagitan ng paghahanda ng SQLAlchemy. Mula sa loob ng iyong kapaligiran sa Python sa linya ng utos, i-install ang SQLAlchemy kasama ang i-install ang pip utos:

pip install SQLAlchemy-1.2.9

Ang 1.2.9 ang numero ng bersyon. Maaari mong iwanan ito upang makuha ang pinakabagong pakete, ngunit mahusay na kasanayan na maging tiyak. Hindi mo alam kung kailan maaaring masira ng isang bagong paglabas ang iyong kasalukuyang code.

Handa ka na ngayong magsimulang mag-coding. Maaaring kailanganin mong ihanda ang iyong database upang tanggapin ang isang koneksyon sa Python, ngunit ang mga sumusunod na halimbawa ay gumagamit ng lahat ng isang SQLite nilikha ang database ng in-memory sa ibaba.

Mga modelo sa SQLAlchemy

Ang isa sa mga pangunahing bahagi ng isang ORM ay a modelo . Ito ay isang klase ng Python na naglalarawan kung ano ang dapat magmukhang isang talahanayan, at kung paano ito dapat gumana. Ito ang bersyon ng ORM ng GUMAWA NG TABLE pahayag sa SQL. Kailangan mo ng isang modelo para sa bawat talahanayan sa iyong database.

Buksan ang iyong paboritong text editor o IDE, at lumikha ng isang bagong file na tinawag pagsubok.py . Ipasok ang starter code na ito, i-save ang file, at patakbuhin ito:

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

Maraming ginagawa ang code na ito. Ang mga pag-import ay kinakailangan upang maunawaan ng Python kung saan mahahanap ang mga module ng SQLAlchemy na kinakailangan nito. Gagamitin ng iyong mga modelo ang nagpapahayag_base sa paglaon, at ini-configure nito ang anumang mga bagong modelo upang gumana tulad ng inaasahan.

Ang lumikha_engine Lumilikha ang pamamaraan ng isang bagong koneksyon sa iyong database. Kung mayroon ka nang isang database, kailangan mong baguhin sqlite: // sa iyong database URI. Tulad nito, ang code na ito ay lilikha ng isang bagong database sa memorya lamang. Nawasak ang database kapag natapos na ang iyong code sa pagpapatupad.

Sa wakas, ang lumikha_all Lumilikha ang pamamaraan ng lahat ng mga talahanayan na tinukoy sa iyong mga mode sa iyong database. Tulad ng hindi mo pa natukoy ang anumang mga modelo, walang mangyayari. Sige at patakbuhin ang code na ito, upang matiyak na wala kang anumang mga problema o typo.

Gumawa tayo ng isang modelo. Magdagdag ng isa pang pag-import sa tuktok ng iyong file:

from sqlalchemy import Column, Integer, String

Ini-import ang Haligi , Integer , at String mga module mula sa SQLAlchemy. Tinutukoy nila kung paano gumagana ang mga talahanayan, patlang, haligi, at database ng database.

Sa ilalim ng nagpapahayag_base , lumikha ng iyong modelo ng modelo:

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

Ang simpleng halimbawang ito ay gumagamit ng mga kotse, ngunit ang iyong mga talahanayan ay maaaring maglaman ng anumang data.

Dapat magmana ang bawat klase Base . Ang iyong pangalan ng talahanayan ng database ay tinukoy sa __tablename__ . Ito ay dapat na kapareho ng pangalan ng klase, ngunit ito ay isang rekomendasyon lamang, at walang masisira kung hindi sila tumutugma.

Sa wakas, ang bawat haligi ay tinukoy bilang isang variable ng sawa sa loob ng klase. Iba't ibang mga uri ng data ang ginagamit, at ang pangunahing susi Sinasabi ng katangiang SQLAlchemy na likhain ang id haligi bilang pangunahing key.

Sige at magdagdag ng isang huling pag-import, sa oras na ito para sa Dayuhang susi modyul Idagdag ito sa tabi ng iyong Haligi angkat:

from sqlalchemy import Column, ForeignKey, Integer, String

Ngayon lumikha ng isang pangalawang modelo ng modelo. Tinawag ang klase na ito Mga May-ari ng Kotse , at mga tindahan ng mga detalye ng may-ari ng mga tukoy na kotse na nakaimbak sa Mga sasakyan mesa:

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)

Mayroong maraming mga bagong katangian na ipinakilala dito. Ang kotse_id ang patlang ay tinukoy bilang isang banyagang susi. Naka-link ito sa id nasa mga kotse mesa Pansinin kung paano ginagamit ang pangalan ng talahanayan ng mas maliit na kaso, na inilagay ang pangalan ng malalaking klase.

Panghuli, isang katangian ng kotse ay tinukoy bilang isang relasyon . Pinapayagan nitong i-access ng iyong modelo ang Mga sasakyan talahanayan sa pamamagitan ng variable na ito. Ito ay ipinakita sa ibaba.

Kung patakbuhin mo ang code na ito ngayon, makikita mo na walang nangyayari. Ito ay dahil hindi mo pa nasabi na gumawa ng anumang kapansin-pansin.

Mga bagay sa SQLAlchemy

Ngayong nilikha ang iyong mga modelo, maaari mo nang simulang i-access ang mga object, at basahin at isulat ang data. Magandang ideya na ilagay ang iyong lohika sa sarili nitong klase at file, ngunit sa ngayon, maaari itong manatili sa tabi ng mga modelo.

Data ng Pagsulat

Sa halimbawang ito, kailangan mong maglagay ng ilang data sa database bago mo ito mabasa. Kung gumagamit ka ng isang mayroon nang database, maaaring mayroon ka nang data. Alinmang paraan, kapaki-pakinabang pa rin upang malaman kung paano magsingit ng data.

Maaaring nasanay ka sa pagsusulat INSERT pahayag sa SQL. Hinahawakan ito ng SQLAlchemy para sa iyo. Narito kung paano ipasok ang isang hilera sa Mga sasakyan modelo Magsimula sa isang bagong pag-import para sa tagagawa ng sesyon :

from sqlalchemy.orm import sessionmaker

Kailangan ito upang likhain ang sesyon at DBSession mga bagay, na ginagamit upang mabasa at sumulat ng data:

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

Ngayon ilagay ito sa ilalim ng iyong lumikha_all pahayag:

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

Basagin natin ang code na iyon. Ang variable kotse1 ay tinukoy bilang isang bagay batay sa Mga sasakyan modelo Ang paggawa at kulay nito ay itinakda bilang mga parameter. Ito ay tulad ng pagsasabing 'gumawa ako ng kotse, ngunit huwag mo itong isulat sa database'. Ang kotseng ito ay umiiral sa memorya ngunit naghihintay na maisulat.

Idagdag ang kotse sa session kasama ang session.add , at pagkatapos ay isulat ito sa database na may session.commit .

Ngayon magdagdag tayo ng isang may-ari:

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

Ang code na ito ay halos magkapareho sa nakaraang insert para sa Mga sasakyan modelo Ang pangunahing pagkakaiba dito ay iyon kotse_id ay isang banyagang susi kaya nangangailangan ng isang row id na umiiral sa kabilang talahanayan. Ma-access ito sa pamamagitan ng kotse1.id pag-aari

Hindi mo kailangang magtanong sa database o ibalik ang anumang mga id, dahil hinahawakan ito ng SQLAlchemy para sa iyo (hangga't nais mo muna ang data).

Data ng Pagbasa

Kapag nakasulat ka na ng ilang data, maaari mo nang simulang basahin ito muli. Narito kung paano magtanong sa Mga sasakyan at Mga May-ari ng Kotse mga talahanayan:

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

Ito ay simple. Sa pamamagitan ng paggamit ng tanong pamamaraan na matatagpuan sa sesyon , tinukoy mo ang modelo, at pagkatapos ay gamitin ang lahat pamamaraan upang makuha ang lahat ng mga resulta. Kung alam mong magkakaroon lamang ng isang resulta, maaari mong gamitin ang una pamamaraan:

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

Kapag natanung mo na ang modelo, at naimbak ang iyong naibalik na mga resulta sa isang variable, maaari mong ma-access ang data sa pamamagitan ng object:

print(result[0].color)

Ito ang naglilimbag ng kulay na 'pilak', dahil ang talaang iyon ay ang unang hilera. Maaari mong i-loop ang object ng resulta kung nais mo.

Habang tinukoy mo ang ugnayan sa iyong modelo, posible na mag-access ng data sa mga nauugnay na talahanayan nang hindi tumutukoy sa isang sumali:

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

Gumagana ito dahil naglalaman ang iyong modelo ng mga detalye ng istraktura ng iyong talahanayan, at ang kotse ang katangian ay tinukoy bilang isang link sa mga kotse mesa

Ano ang Hindi Gusto ng Tungkol sa ORMs?

Sinasaklaw lamang ng tutorial na ito ang mga pangunahing kaalaman, ngunit sa sandaling makuha mo ang hang ng mga iyon, maaari kang magpatuloy sa mga advanced na paksa. Mayroong ilang mga potensyal na downsides sa ORMs:

  • Kailangan mong isulat ang iyong modelo bago tumakbo ang anumang mga query.
  • Ito ay isa pang bagong syntax upang malaman.
  • Maaaring ito ay masyadong kumplikado para sa simpleng mga pangangailangan.
  • Dapat ay mayroon kang magandang disenyo ng database upang magsimula ka.

Ang mga isyung ito ay hindi isang malaking problema sa kanilang sarili, ngunit ang mga ito ay mga bagay na dapat abangan. Kung nagtatrabaho ka sa isang mayroon nang database, maaari kang mahuli.

Kung hindi ka kumbinsido na ang isang ORM ay tamang tool para sa iyo, tiyakin na nabasa mo ang tungkol sa mahalagang dapat malaman ng mga programmer ng SQL .

Magbahagi Magbahagi Mag-tweet Email Dapat Ka Bang Mag-upgrade sa Windows 11 Kaagad?

Malapit na ang Windows 11, ngunit dapat mo bang i-update sa lalong madaling panahon o maghintay ng ilang linggo? Alamin Natin.

Basahin Susunod Mga Kaugnay na Paksa
  • Programming
  • Sawa
  • SQL
  • Mga Tutorial sa Coding
Tungkol sa May-akda Joe Coburn(136 Mga Artikulo Na-publish)

Si Joe ay nagtapos sa Computer Science mula sa University of Lincoln, UK. Siya ay isang propesyonal na developer ng software, at kapag hindi siya lumilipad ng mga drone o sumusulat ng musika, madalas siyang matagpuan na kumukuha ng mga larawan o gumawa ng mga video.

ang aking laptop keyboard ay hindi gumagana
Higit pa Mula kay Joe Coburn

Mag-subscribe sa aming newsletter

Sumali sa aming newsletter para sa mga tip sa tech, pagsusuri, libreng ebook, at eksklusibong deal!

Mag-click dito upang mag-subscribe