Всичко, което трябва да знаете за Python и обектно-релационни карти

Всичко, което трябва да знаете за Python и обектно-релационни карти

Може да сте чували за обектно-релационно картографиране (ORM). Може дори да сте използвали такъв, но какви точно са те? И как ги използвате в Python?





Ето всичко, което трябва да знаете за ORM и Python.



Какво е ORM?

Обектно-релационното картографиране (ORM) е техника за програмиране, използвана за достъп до база данни. Той излага вашата база данни в поредица от обекти. Не е нужно да пишете SQL команди за вмъкване или извличане на данни, вие използвате поредица от атрибути и методи, прикрепени към обекти.





Може да звучи сложно и ненужно, но те могат да ви спестят много време и да ви помогнат да контролирате достъпа до вашата база данни.

Ето един пример. Кажете, че всеки път, когато вмъкнете парола във вашата база данни, искате да я хеширате, както е обяснено в защитата на паролата на уебсайта. Това не е проблем за простите случаи на използване --- правите изчислението преди да го вмъкнете. Но какво, ако трябва да вмъкнете запис на много места в кода? Ами ако друг програмист вмъкне в таблицата ви, а вие не знаете?



С помощта на ORM можете да напишете код, за да сте сигурни, че когато и където и да е достъп до който и да е ред или поле във вашата база данни, първо се изпълнява другият ви персонализиран код.

Това също действа като „единствен източник на истина“. Ако искате да промените персонализирано изчисление, трябва да го промените само на едно място, а не на няколко. Възможно е да се изпълнят много от тези принципи обектно -ориентирано програмиране (ООП) в Python , но ORM работят в тандем с принципите на ООП, за да контролират достъпа до база данни.



Има някои неща, за които трябва да внимавате, когато използвате ORM, и има обстоятелства, при които може да не искате да използвате такъв, но те обикновено се считат за добре, особено в голяма кодова база.

ORMs в Python Използване на SQLAlchemy

Подобно на много задачи в Python, по -бързо и по -лесно е да импортирате модул, отколкото да напишете свой собствен. Разбира се, възможно е да напишете свой собствен ORM, но защо да преоткривате колелото?



Всички примери по -долу използват SQLA алхимия , популярен Python ORM, но много от принципите се прилагат независимо от изпълнението.

Настройване на Python за SQLAlchemy

Преди да влезете, ще трябва да настроите машината си за разработка на Python с SQLAlchemy.

Ще трябва да използвате Python 3.6, за да следвате тези примери. Докато по -старите версии ще работят, кодът по -долу ще се нуждае от някои промени, преди да се стартира. Не сте сигурни за разликите? Нашите често задавани въпроси за Python обхващат всички различия.

Преди да кодирате, трябва да настроите среда на Python, която ще предотврати проблеми с други импортирани пакети на Python.

Уверете се, че имате PIP, мениджърът на пакети на Python инсталиран, който идва с повечето съвременни версии на Python.

След като сте готови да започнете, можете да започнете, като подготвите SQLAlchemy. От вашата Python среда в командния ред инсталирайте SQLAlchemy с pip install команда:

pip install SQLAlchemy-1.2.9

The 1.2.9 е номера на версията. Можете да оставите това изключено, за да получите най -новия пакет, но е добра практика да бъдете конкретни. Не знаете кога нова версия може да наруши текущия ви код.

Сега сте готови да започнете кодирането. Може да се наложи да подготвите базата данни, за да приемете връзка с Python, но всички примери по -долу използват SQLite база данни, създадена в паметта по-долу.

Модели в SQLAlchemy

Един от ключовите компоненти на ORM е a модел . Това е клас на Python, който очертава как трябва да изглежда таблицата и как трябва да работи. Това е ORM версията на СЪЗДАЙТЕ ТАБЛИЦА израз в SQL. Нуждаете се от модел за всяка таблица във вашата база данни.

Отворете любимия си текстов редактор или IDE и създайте нов файл, наречен test.py . Въведете този стартов код, запишете файла и го стартирайте:

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

Този код прави няколко неща. Импортирането е необходимо, за да може Python да разбере къде да намери модулите SQLAlchemy, от които се нуждае. Вашите модели ще използват декларативна_база по -късно и конфигурира всички нови модели да работят според очакванията.

The create_engine метод създава нова връзка с вашата база данни. Ако вече имате база данни, ще трябва да промените sqlite: // към URI на вашата база данни. Така е, този код ще създаде нова база данни само в паметта. Базата данни се унищожава, след като кодът завърши изпълнението.

Накрая, create_all метод създава всички таблици, дефинирани във вашите режими, във вашата база данни. Тъй като все още не сте дефинирали никакви модели, нищо няма да се случи. Продължете и стартирайте този код, за да сте сигурни, че нямате проблеми или правописни грешки.

Нека направим модел. Добавете друг импорт в горната част на вашия файл:

from sqlalchemy import Column, Integer, String

Това импортира Колона , Цело число , и Низ модули от SQLAlchemy. Те определят как работят таблиците на базата данни, полета, колони и типове данни.

Под декларативна_база , създайте своя модел модел:

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

Този прост пример използва автомобили, но вашите таблици може да съдържат всякакви данни.

Всеки клас трябва да наследява База . Името на вашата таблица на база данни е дефинирано в __ име на таблица__ . Това трябва да е същото като името на класа, но това е само препоръка и нищо няма да се счупи, ако не съвпадат.

И накрая, всяка колона е дефинирана като променлива на python в рамките на класа. Използват се различни типове данни и първичен ключ атрибут казва на SQLAlchemy да създаде документ за самоличност колона като първичен ключ.

Продължете и добавете последен импорт, този път за ForeignKey модул. Добавете това заедно с вашето Колона внос:

from sqlalchemy import Column, ForeignKey, Integer, String

Сега създайте втори клас модел. Този клас се нарича Собственици на автомобили , и съхранява подробности за собственика на конкретни автомобили, съхранявани в Автомобили маса:

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)

Тук са въведени няколко нови атрибута. The car_id полето е дефинирано като външен ключ. Той е свързан с документ за самоличност в автомобили маса. Забележете как се използва името на таблицата с малки букви, въведено от името на класа с главни букви.

И накрая, атрибут на кола се определя като а връзка . Това позволява на вашия модел да има достъп до Автомобили таблица чрез тази променлива. Това е показано по -долу.

Ако пуснете този код сега, ще видите, че нищо не се случва. Това е така, защото все още не сте му казали да направи нещо забележимо.

Обекти в SQLAlchemy

След като вашите модели са създадени, можете да започнете да осъществявате достъп до обектите, да четете и записвате данни. Добра идея е да поставите логиката си в собствен клас и файл, но засега тя може да остане до моделите.

Записване на данни

В този пример трябва да вмъкнете някои данни в базата данни, преди да можете да ги прочетете. Ако използвате съществуваща база данни, може би вече имате данни. Така или иначе, все още е много полезно да знаете как да вмъквате данни.

Може да сте свикнали да пишете ИНСЕРТ изрази в SQL. SQLAlchemy се справя с това вместо вас. Ето как да вмъкнете един ред в Автомобили модел. Започнете с нов импорт за сесияджия :

from sqlalchemy.orm import sessionmaker

Това е необходимо за създаването на сесия и DBS сесия обекти, които се използват за четене и записване на данни:

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

Сега поставете това под вашия create_all изявление:

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

Нека разбием този код. Променливата кола1 се дефинира като обект въз основа на Автомобили модел. Нейната марка и цвят са зададени като параметри. Това е все едно да кажете „направете ми кола, но все още не я записвайте в базата данни“. Тази кола съществува в паметта, но чака да бъде написана.

Добавете колата към сесията с session.add , и след това го запишете в базата данни с session.commit .

Сега нека добавим собственик:

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

Този код е почти идентичен с предишното вмъкване за Автомобили модел. Основната разлика тук е, че car_id е чужд ключ, така че се нуждае от идентификатор на ред, който съществува в другата таблица. Това е достъпно чрез car1.id Имот.

Не е нужно да заявявате базата данни или да връщате идентификатори, тъй като SQLAlchemy обработва това вместо вас (стига първо да ангажирате данните).

Четене на данни

След като сте написали някои данни, можете да започнете да ги четете обратно. Ето как да попитате Автомобили и Собственици на автомобили таблици:

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

Толкова е просто. Като използвате запитване метод, открит в сесия , задавате модела и след това използвате всичко метод за извличане на всички резултати. Ако знаете, че ще има само един резултат, можете да използвате първо метод:

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

След като заявите модела и съхранявате върнатите резултати в променлива, можете да получите достъп до данните чрез обекта:

print(result[0].color)

Това отпечатва цвета „сребърен“, тъй като този запис е първият ред. Можете да преминете през обекта на резултата, ако искате.

Тъй като сте определили връзката във вашия модел, е възможно да получите достъп до данни в свързани таблици, без да посочвате съединение:

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

Това работи, защото вашият модел съдържа подробности за структурата на вашата таблица и кола атрибута е дефиниран като връзка към автомобили маса.

Какво не харесвате в ORM?

Този урок обхваща само самите основи, но след като се справите с тях, можете да преминете към разширените теми. Има някои потенциални недостатъци на ORM:

  • Трябва да напишете своя модел, преди да могат да се изпълняват заявки.
  • Това е още един нов синтаксис за научаване.
  • Може да е твърде сложно за прости нужди.
  • Трябва да имате добър дизайн на базата данни за начало.

Тези проблеми сами по себе си не са голям проблем, но те са неща, на които трябва да внимавате. Ако работите със съществуваща база данни, може да ви хванат.

Ако не сте убедени, че ORM е правилният инструмент за вас, не забравяйте да прочетете за важните SQL команди, които програмистите трябва да знаят .

Дял Дял Туит електронна поща Трябва ли незабавно да надстроите до Windows 11?

Windows 11 идва скоро, но трябва ли да актуализирате възможно най -скоро или да изчакате няколко седмици? Нека разберем.

Прочетете Напред Свързани теми
  • Програмиране
  • Python
  • SQL
  • Уроци по кодиране
За автора Джо Кобърн(136 статии са публикувани)

Джо е завършил компютърни науки от университета в Линкълн, Великобритания. Той е професионален разработчик на софтуер и когато не лети с дронове или пише музика, често може да бъде намерен да прави снимки или да произвежда видеоклипове.

как да промените иконите на windows 10
Още от Джо Кобърн

Абонирайте се за нашия бюлетин

Присъединете се към нашия бюлетин за технически съвети, рецензии, безплатни електронни книги и изключителни оферти!

Щракнете тук, за да се абонирате