В этой лекции мы поговорим о том, как Django ORM (Object-Relational Mapping) упрощает нашу жизнь, позволяя писать Python-код для работы с базой данных вместо написания SQL-запросов. Вы узнаете, как модели связываются с таблицами базы данных, какие типы полей существуют и как эффективно использовать их в своих проектах.
Модель в Django
Модель в Django — это класс Python, который представляет собой таблицу в базе данных. Каждый атрибут класса (так называемое поле модели) будет соответствовать колонке в таблице базы данных. Django ORM позволяет нам работать с этими таблицами, добавлять, изменять или удалять данные через Python-код, избегая написания SQL-запросов вручную.
Вот как это выглядит на простом примере:
from django.db import models
class Author(models.Model):
# Имя автора
name = models.CharField(max_length=100)
# Электронная почта автора
email = models.EmailField(unique=True)
def __str__(self):
return self.name
Этот код создаёт модель Author, которая будет представлена в базе данных как таблица со следующими колонками:
id: первичный ключ (добавляется автоматически, если вы не указали свой).name: строковое поле с максимальной длиной 100 символов.email: уникальное поле для хранения адреса электронной почты.
Теперь, когда модель создана, давайте разберёмся, как она взаимодействует с базой данных.
Связь моделей и баз данных
Django использует ORM для взаимодействия с базой данных. Каждая модель отображается на таблицу в базе, а её поля — на колонки.
Если вышеуказанная модель Author будет применена к базе данных (через процесс миграции, о котором мы поговорим далее), то в базе появится таблица, похожая на эту:
| id | name | |
|---|---|---|
| 1 | Иван Иванов | ivan@example.com |
| 2 | Анна Петрова | anna@example.com |
Django автоматически создаёт все таблицы и отношения, описанные в моделях, а также предоставляет интерфейс для работы с ними.
Работать с ORM удобнее и безопаснее, чем напрямую писать SQL-запросы. Django берёт на себя большую часть операционной работы:
- Обеспечивает независимость от используемой базы данных (SQLite, PostgreSQL, MySQL и т.д.).
- Проверяет целостность данных.
- Автоматизирует создание и обновление таблиц.
Типы полей в Django
Каждое поле модели представляет собой колонку таблицы базы данных. Django предоставляет множество типов полей для описания данных, которые будут храниться в таблице. Вот наиболее часто используемые:
| Тип поля | Описание |
|---|---|
CharField |
Хранит строки фиксированной длины |
TextField |
Хранит длинные тексты |
IntegerField |
Хранит целые числа |
FloatField |
Хранит числа с плавающей точкой |
BooleanField |
Хранит значения True или False |
DateTimeField |
Хранит дату и время |
EmailField |
Хранит строку, проверяя, что она является корректным email-адресом |
ForeignKey |
Создаёт связь «один ко многим» между двумя моделями |
ManyToManyField |
Создаёт связь «многие ко многим» между моделями |
Пример использования различных типов полей
from django.db import models
class BlogPost(models.Model):
title = models.CharField(max_length=200) # Заголовок статьи, строковое поле
content = models.TextField() # Основной текст статьи
published = models.BooleanField(default=False) # Опубликована ли статья
pub_date = models.DateTimeField(auto_now_add=True) # Дата публикации
views = models.IntegerField(default=0) # Счётчик просмотров
def __str__(self):
return self.title
Тут мы видим, как можно использовать разные типы данных для описания различных характеристик статьи в блоге.
Связь моделей с отношениями
Поскольку модели обычно не изолированы, они часто связаны друг с другом через отношения. Вот три основных типа отношений в Django:
One-to-One (Один-к-одному)
Используется, когда одна запись в таблице связана только с одной записью другой таблицы.
class Profile(models.Model):
user = models.OneToOneField(User, on_delete=models.CASCADE)
bio = models.TextField()
Many-to-One (Многие-к-одному)
Используется, когда несколько записей из одной таблицы могут быть связаны с одной записью из другой таблицы.
class BlogPost(models.Model):
author = models.ForeignKey(Author, on_delete=models.CASCADE)
title = models.CharField(max_length=200)
Many-to-Many (Многие-ко-многим)
Используется, когда несколько записей из одной таблицы могут быть связаны с несколькими записями другой таблицы.
class Tag(models.Model):
name = models.CharField(max_length=50)
class BlogPost(models.Model):
title = models.CharField(max_length=200)
tags = models.ManyToManyField(Tag)
Примеры создания моделей
Давайте создадим модель для комментариев к статьям блога. Это позволит пользователям оставлять отзывы на статьи.
class Comment(models.Model):
post = models.ForeignKey(BlogPost, on_delete=models.CASCADE) # Связь с моделью BlogPost
author_name = models.CharField(max_length=100)
text = models.TextField()
created_at = models.DateTimeField(auto_now_add=True)
def __str__(self):
return f"Комментарий от {self.author_name} к {self.post.title}"
Эта модель демонстрирует использование ForeignKey для связи комментариев с конкретной статьёй. Поле on_delete=models.CASCADE указывает, что при удалении статьи все её комментарии также будут удалены.
Создание таблиц для моделей: миграции
Чтобы изменения в моделях были применены к базе данных, необходимо использовать систему миграций Django.
Работа с миграциями включает три шага:
- Создание миграции: команда
makemigrations. - Применение миграции: команда
migrate. - Проверка состояния базы данных.
Приведём ример работы с миграциями.
После добавления модели Comment в файл models.py, выполните:
python manage.py makemigrations
python manage.py migrate
Первая команда создаст файл миграции, описывающий изменения в модели. Вторая команда применит эти изменения к базе данных, создав таблицу Comment.
Полезные советы по работе с моделями
- Всегда добавляйте метод
__str__в свои модели. Это делает их отображение в админке и в отладочных сообщениях более читаемым. - Используйте понятные имена полей и моделей. Это упростит написание кода и сделает его более читаемым.
- Регулярно выполняйте миграции, чтобы изменения в моделях не накапливались.
- Если ваши данные имеют связи, подумайте о правильном выборе типа отношения (ForeignKey, ManyToMany и т.д.).
На этом этапе у нас есть базовое понимание, как создавать модели и как они связаны с базой данных. Двигаемся дальше к тому, чтобы оживить наше приложение и начать активно работать с данными.
ПЕРЕЙДИТЕ В ПОЛНУЮ ВЕРСИЮ