Как создать проект на Django

Установка Django

Django — популярный фреймворк для разработки веб-приложений на языке Python. Он берет на себя рутину, связанную с обработкой запросов, работой с базой данных и созданием панели администратора, позволяя сосредоточиться на логике приложения.

Перед началом работы необходимо установить Python, создать виртуальную среду и развернуть Django внутри нее. Использование виртуальной среды позволяет изолировать зависимости проекта и предотвратить конфликты между пакетами.

Установка Python

В большинстве Linux-дистрибутивов Python уже установлен, но рекомендуем убедиться, что у вас актуальная версия.

Откройте терминал и выполните команду:

    python3 --version

Если Python установлен, вы увидите ответ в формате:

    Python 3.x.x

Если команда вернула ошибку, установите актуальную версию:

    sudo apt update && sudo apt install python3 -y

Также нам потребуется модуль для работы с виртуальным окружением (python3-venv) и пакетный менеджер для установки зависимостей (python3-pip).

    sudo apt install python3-venv python3-pip -y

Создание и активация виртуальной среды

Как мы уже упоминали, виртуальная среда позволяет изолировать зависимости проекта от глобальной системы. Это полезно по следующим причинам:

• Избежание конфликтов зависимостей. В разных проектах могут использоваться разные версии Django и других библиотек. Виртуальное окружение позволяет каждому проекту использовать свою версию.
• Не засоряет глобальную систему. Установленные внутри виртуального окружения библиотеки не затрагивают другие проекты и системные пакеты.
• Облегчает развертывание. Если проект использует виртуальное окружение, его легко перенести на другой сервер, просто установив те же зависимости.

Для создания нового виртуального окружения перейдите в каталог, где будет храниться ваш проект, и выполните команду:

    python3 -m venv .venv

Здесь .venv — имя виртуальной среды. Можно выбрать любое имя, но принято использовать .venv или .env.

После создания виртуального окружения его следует активировать.

    source .venv/bin/activate

В терминале появится префикс (.venv). Он указывает на то, что все устанавливаемые библиотеки и зависимости привязаны исключительно к этой среде и не затрагивают глобальную систему.

Установка Django

Теперь, когда виртуальная среда активирована, можно установить Django. Выполните команду:

    pip install django

После завершения установки убедитесь, что все прошло успешно:

    django-admin --version

Если установка выполнена корректно, в терминале отобразится версия фреймворка.

Создание проекта Django

Новый проект

После установки можно приступить к созданию нового проекта. Для этого используется утилита django-admin, которая помогает быстро сгенерировать структуру и управлять основными операциями.

В каталоге, где уже создано виртуальное окружение, выполните команду для создания нового проекта:

    django-admin startproject myproject

Здесь myproject — название проекта, можно выбрать любое, но без пробелов и спецсимволов. Имя проекта не должно совпадать с именами встроенных модулей Python: django, test, config и т. д.

После выполнения команды в текущей директории появится новый каталог myproject/ со следующей структурой:

    myproject/
│── manage.py
│── myproject/
│   │── __init__.py
│   │── settings.py
│   │── urls.py
│   │── wsgi.py
│   │── asgi.py

Где:

• manage.py — управляющий файл, который позволяет запускать сервер, создавать миграции, работать с базой данных и управлять проектом через командную строку;
• init.py — делает каталог модулем Python, позволяя использовать его в импортах;
• settings.py — файл с настройками проекта, включая базу данных, установленные приложения и параметры безопасности;
• urls.py — определяет маршруты (URL-адреса) проекта и их обработчики;
• wsgi.py — точка входа для запуска через WSGI-серверы;
• asgi.py — аналог WSGI, но для асинхронного сервера ASGI. Необходим для работы с WebSocket и другими асинхронными технологиями.

Тестовый запуск

Для тестового запуска проекта используется встроенный в Django сервер разработки. Он позволяет убедиться, что проект создан и настроен правильно.

Чтобы создать сервер, необходимо выполнить следующую команду, находясь в корневой директории проекта (где расположен manage.py):

    python manage.py runserver

После этого сервер начнет работать, и консоли появится сообщение с адресом, по которому доступен проект. По умолчанию это http://127.0.0.1:8000/.

Если перейти по адресу в браузере, откроется стандартная стартовая страница Django с сообщением «The install worked successfully!».

Чтобы остановить сервер, достаточно нажать в терминале Ctrl+C.

Настройка проекта в settings.py

Далее нужно отредактировать файл settings.py, чтобы настроить проект в соответствии с требованиями. Например, чтобы изменить язык интерфейса, часовой пояс и пути к статическим файлам.

Язык и страна

Django поддерживает локализацию, позволяя задавать язык проекта и региональные параметры, такие как формат даты, времени и чисел. Для этого в settings.py следует изменить переменную LANGUAGE_CODE.

По умолчанию в Django установлен английский язык:

    LANGUAGE_CODE = 'en-us'

Если проект рассчитан на русскоязычных пользователей, этот параметр можно изменить:

    LANGUAGE_CODE = 'ru-RU'

Часовой пояс

Часовой пояс влияет на работу временных меток в базе данных, генерацию времени в логах и обработку времени в шаблонах. По умолчанию в Django установлен UTC:

    TIME_ZONE = 'UTC'

Если проект ориентирован на Россию, можно установить соответствующий часовой пояс. Например, для Москвы:

    TIME_ZONE = 'Europe/Moscow'

Путь к статическим файлам

Статические файлы — это CSS, JavaScript, изображения и другие ресурсы, не связанные с базой данных. Django использует специальную настройку для указания пути к папке со статическими файлами.

По умолчанию в settings.py содержится следующая строка:

    STATIC_URL = 'static/'

Эта настройка задает URL-префикс для статических файлов. Однако для корректной работы нужно дополнительно указать путь, где файлы будут храниться. Это делается с помощью параметра STATICFILES_DIRS для локальной разработки или STATIC_ROOT для продакшена.

Добавим в начало файла следующую строку:

    import os

А также добавим путь для хранения статических файлов в локальной среде после строки STATIC_URL = ‘static/’:

    STATICFILES_DIRS = [
    os.path.join(BASE_DIR, "static")
]

Теперь при разработке можно поместить файлы в папку static/ в корне проекта, и Django их корректно обработает.

Если сайт разрабатывается только локально, STATICFILES_DIRS будет достаточно. Но если вы собираетесь разворачивать проект на сервере, нужно добавить STATIC_ROOT:

    STATIC_ROOT = os.path.join(BASE_DIR, "staticfiles")

Тогда перед загрузкой проекта на сервер следует выполнить команду:

    python manage.py collectstatic

Она собирает все статические файлы проекта в папку staticfiles/, чтобы сервер мог их обслуживать.

Работа с приложением в проекте

Создание приложения

Django использует модульную архитектуру, где каждый функциональный блок оформляется в виде отдельного приложения. Это удобно, так как позволяет разрабатывать разные компоненты проекта независимо друг от друга.

Для создания приложения используется команда:

    python manage.py startapp myapp

Здесь myapp — имя нового приложения.

Django автоматически создаст папку myapp/ со следующей структурой:

    myapp/
│── migrations/
│── __init__.py
│── admin.py
│── apps.py
│── models.py
│── tests.py
│── views.py

Где:

• migrations/ — каталог для хранения миграций базы данных, которые применяются для изменения структуры таблиц;
• init.py — делает директорию Python-модулем, позволяя импортировать файлы приложения;
• admin.py — регистрирует модели для работы с ними через панель администратора Django;
• apps.py — конфигурация приложения, используемая для его настройки в проекте;
• models.py — содержит модели базы данных, описывающие структуру таблиц;
• tests.py — файл для написания тестов приложения;
• views.py — содержит представления, которые обрабатывают запросы и возвращают ответы.

Далее приложение нужно зарегистрировать в проекте, иначе Django не будет его учитывать. Для этого в settings.py найдите список INSTALLED_APPS и добавьте в него название приложения:

    INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'myapp',
]

На этом этапе приложение создано, но пока ничего не делает. Дальше мы займемся моделями и базой данных.

Создание моделей

Django предоставляет инструмент для работы с базой данных — ORM (Object-Relational Mapping, объектно-реляционное отображение). Он позволяет описывать структуру данных с помощью классов на языке Python, а затем автоматически превращает их в таблицы БД.

То есть вместо написания SQL-запросов вручную мы создаем модели — специальные Python-классы, которые определяют, какие поля будут в таблицах базы данных, их типы данных и связи между таблицами.

Модели в Django описываются в файле models.py, который находится в корневой папке приложения. Для каждого приложения в проекте этот файл уникален, и все его модели будут храниться в одной таблице БД.

Создадим первую модель. Для этого откроем файл models.py в папке нашего приложения и добавим следующее:

    from django.db import models

class Order(models.Model):
    product_name = models.CharField(max_length=255)
    quantity = models.IntegerField()
    ordered_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return f"{self.product_name} ({self.quantity})"

• class Order(models.Model): — создаем класс Order, который наследуется от models.Model. Это означает, что Django будет работать с этим классом как с таблицей базы данных.
• product_name = models.CharField(max_length=255) — определяем строковое поле с максимальной длиной 255 символов.
• quantity = models.IntegerField() — числовое поле для хранения количества товара в заказе.
• ordered_at = models.DateTimeField(auto_now_add=True) — поле для хранения даты и времени оформления заказа. Параметр auto_now_add=True означает, что при создании объекта в это поле автоматически запишутся текущая дата и время.
• def __str__(self): — определяет строковое представление объекта. Когда мы будем просматривать объекты в административной панели Django, вместо ID модели будет отображаться название товара и его количество.

Создание модели — только первый шаг. Django пока не знает, что мы добавили новую таблицу. Чтобы система начала работать с моделью, нужно выполнить миграции.

Каждый раз, когда мы создаем новую модель или вносим изменения в существующую, нужно обновлять миграции.

Создаем файл миграции:

    python manage.py makemigrations

После выполнения этой команды Django создаст новый файл в папке migrations/. Он будет содержать описание изменений в базе данных.

Применяем миграции (вносим изменения в базу данных):

    python manage.py migrate

Эта команда создаст в БД таблицу Order с тремя столбцами: product_name, quantity и ordered_at.

Теперь наша база данных полностью соответствует описанию модели.

Чтобы сделать модель доступной в панели администратора, нужно зарегистрировать ее в файле admin.py внутри приложения.

Открываем admin.py и добавляем следующие строки:

    from django.contrib import admin
from .models import Order

admin.site.register(Order)

Настройка базы данных

Для настройки БД необходимо отредактировать параметры, которые находятся в файле settings.py в разделе DATABASES. По умолчанию там указан SQLite:

    DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}

Django автоматически создает файл db.sqlite3 в корневой директории проекта и использует его как базу данных. Если SQLite вас устраивает, можно сразу перейти к выполнению миграций. Но если вы хотите использовать PostgreSQL, следует выполнить дополнительную настройку.

Сначала установим драйвер для PostgreSQL:

    pip install psycopg2-binary

После этого изменим раздел DATABASES в settings.py:

    DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'mydatabase',
        'USER': 'myuser',
        'PASSWORD': 'mypassword',
        'HOST': 'localhost',
        'PORT': '5432',
    }
}

Теперь нужно создать базу данных в PostgreSQL, если она еще не создана. Открываем консоль PostgreSQL командой:

    sudo -u postgres psql

В интерактивном режиме PostgreSQL выполняем команды:

    CREATE DATABASE mydatabase;

    CREATE USER myuser WITH PASSWORD 'mypassword';

    ALTER ROLE myuser SET client_encoding TO 'utf8';

    ALTER ROLE myuser SET default_transaction_isolation TO 'read committed';

    ALTER ROLE myuser SET timezone TO 'Europe/Moscow';

    GRANT ALL PRIVILEGES ON DATABASE mydatabase TO myuser;

После этого можно выйти из PostgreSQL командой \q. Теперь Django будет использовать PostgreSQL вместо SQLite.

Когда база данных настроена, необходимо выполнить миграции, чтобы Django создал все нужные таблицы:

    python manage.py migrate

Если необходимо проверить, какие SQL-инструкции будут выполнены, можно использовать следующую команду:

    python manage.py sqlmigrate app_name 0001

Здесь:

• app_name — название приложения;
• 0001 — номер миграции. Найти его можно в каталоге migrations/ в первой части имени файла миграции. Например, 0001_initial.py.

Чтобы убедиться, что все работает правильно, создадим суперпользователя для входа в панель администратора:

    python manage.py createsuperuser

Запускаем сервер командой:

    python manage.py runserver

Теперь, если зайти по адресу http://127.0.0.1:8000/admin/, в панели появится раздел Order, где можно создавать, редактировать и удалять заказы.

Создание представлений

В Django представления (views) — это функции или классы, которые обрабатывают входящие HTTP-запросы и возвращают HTTP-ответы. Они определяют, какая информация будет показана пользователю при обращении к определенному URL.

Механизм работы представлений:

1. Пользователь вводит адрес в браузере. Например, http://127.0.0.1:8000/home/.
2. Django определяет, какое представление должно обработать этот запрос, сверяясь с маршрутизацией (urls.py).
3. Вызывается соответствующее представление, которое обрабатывает запрос и формирует ответ.
4. Ответ отправляется пользователю — например, HTML-страница или текст.

Django поддерживает два основных типа представлений:

• Функции-представления (Function-Based Views, FBV) — обычные Python-функции, которые принимают объект запроса и возвращают ответ.
• Классы-представления (Class-Based Views, CBV) — объектно-ориентированный подход, где представления реализованы в виде классов.

Рассмотрим оба подхода подробнее.

Функциональные представления

Самый простой способ создать представление — написать функцию в файле views.py внутри приложения. Например, создадим представление для главной страницы.

Открываем файл views.py в нашем приложении и пишем:

    from django.http import HttpResponse

def home(request):
    return HttpResponse("FBV: Привет от Тирекса!")

Функция-представление принимает объект request, содержащий информацию о запросе, и возвращает объект HttpResponse.

Чтобы представление заработало, нужно связать его с URL-адресом. Открываем файл urls.py и добавляем маршрут:

    from django.urls import path
from . import views

urlpatterns = [
    path('', views.home, name='home'),
]

Теперь, если мы запустим сервер (python manage.py runserver) и откроем в браузере http://127.0.0.1:8000/, то увидим наш текст.

Классовые представления

Django также позволяет создавать представления в виде классов. Такой подход рекомендуется, когда представление должно выполнять сложную логику или повторяться в разных частях приложения.

Пример представления-класса в views.py:

    from django.views import View
from django.http import HttpResponse

class HomeView(View):
    def get(self, request):
        return HttpResponse("CBV: Hello from Trex.")

Чтобы этот класс заработал, его нужно добавить в маршруты (urls.py):

    from django.urls import path
from .views import HomeView

urlpatterns = [
    path('', HomeView.as_view(), name='home'),
]

Добавление маршрутов приложений

Ранее мы уже кратко упомянули, что маршруты (URL-адреса) определяют, какие представления будут обрабатывать запросы. Мы добавили маршрут в urls.py самого приложения, но теперь разберемся в этом подробнее.

Маршруты в Django строятся по иерархической системе:

• Главный файл urls.py в корневой папке отвечает за маршрутизацию на уровне всего проекта.
• Файл маршрутов urls.py внутри каждого приложения описывает маршруты, относящиеся к конкретному приложению.

Теперь разберем, как правильно организовать маршруты в нашем проекте.

Настройка маршрутов на уровне проекта

Когда мы создавали проект Django, в нем автоматически появился файл urls.py внутри папки myproject/. Открываем его:

    from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('myapp.urls')),
]

Здесь:

• path(‘admin/’, admin.site.urls) — стандартный маршрут для административной панели;
• path(», include(‘myapp.urls’)) – говорит Django: «Все запросы к корневому URL (/) передавай в urls.py внутри приложения myapp».

Если бы у нас было несколько приложений, то каждое можно было бы подключить отдельно:

    urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('myapp.urls')),
    path('users/', include('users.urls')),
]

Таким образом, Django будет искать маршруты в myapp/urls.py, если пользователь перешел на /, и в users/urls.py, если пользователь зашел на /users/.

Настройка маршрутов внутри приложения

Теперь создадим (или откроем, если уже создавали) файл urls.py в папке myapp/:

    from django.urls import path
from . import views

urlpatterns = [
    path('', views.home, name='home'),
    path('about/', views.about, name='about'),
    path('items/<int:item_id>/', views.item_detail, name='item_detail'),
]

Здесь мы объявляем три маршрута:

• » — главная страница (по адресу / вызывается функция home);
• ‘about/’ — страница «О нас» (по /about/ вызывается about);
• ‘items/<int:item_id>/’ — динамический маршрут. При переходе на /items/3/ Django вызовет item_detail(request, item_id=3).

Файл views.py должен содержать соответствующие функции представлений, например:

    from django.http import HttpResponse

def home(request):
    return HttpResponse("Главная страница")

def about(request):
    return HttpResponse("О нас")

def item_detail(request, item_id):
    return HttpResponse(f"Вы открыли страницу товара с ID {item_id}")

Создание шаблонов

Шаблоны в Django позволяют отделить логику представлений от отображения данных. Представления обрабатывают данные, а шаблоны отвечают только за их красивый вывод в HTML-формате.

Чтобы Django мог находить шаблоны, необходимо создать папку templates внутри приложения. Затем в ней следует создать подкаталог с именем самого приложения. Например, если у нас есть приложение myapp, то структура будет такой:

    myproject/
│── myapp/
│   │── templates/
│   │   ├── myapp/
│   │   │   ├── home.html
│   │   │   ├── about.html
│   │   │   ├── item_detail.html

Теперь создадим несколько HTML-шаблонов. Например, home.html для главной страницы:

    <!DOCTYPE html>
<html lang="ru">
  <head>
    <meta charset="UTF-8">
    <title>Главная страница</title>
  </head>
  <body>
    <h1>Добро пожаловать на сайт!</h1>
    <p>Это главная страница нашего Django-проекта.</p>
  </body>
</html>

Чтобы использовать этот шаблон, нужно изменить представление home в views.py и использовать функцию render, которая автоматически найдет нужный шаблон в templates/.

Файл views.py:

    from django.shortcuts import render

def home(request):
    return render(request, 'myapp/home.html')

Теперь, когда пользователь заходит на главную страницу, Django загрузит и отобразит home.html.

Допустим, у нас есть динамическая страница с деталями какого-то объекта. Создадим шаблон item_detail.html, который будет принимать параметр item_id и отображать его в HTML-коде:

    <!DOCTYPE html>
<html lang="ru">
  <head>
    <meta charset="UTF-8">
    <title>Детали товара</title>
  </head>
  <body>
    <h1>Товар №{{ item_id }}</h1>
    <p>Это страница с описанием товара.</p>
  </body>
</html>

Изменим представление item_detail, чтобы передавать в шаблон item_id:

    def item_detail(request, item_id):
    return render(request, 'myapp/item_detail.html', {'item_id': item_id})

Запуск сервера и вывод БД

У нас настроены маршруты, представления и шаблоны, а также подключена база данных. Теперь мы можем запустить сервер разработки Django и убедиться, что все работает:

    python manage.py runserver

Откройте браузер и перейдите по адресу http://127.0.0.1:8000/. Вы должны увидеть главную страницу нашего Django-проекта.

Проверка работы базы данных PostgreSQL

Мы настроили PostgreSQL в settings.py и выполнили миграции. Давайте убедимся, что база данных работает корректно.

Проверка через Django ORM

Запустим интерактивную оболочку Django:

    python manage.py shell

Затем попробуем выполнить SQL-запрос через Django ORM. Например, вывести список пользователей (по умолчанию таблица пользователей создается Django):

    from django.contrib.auth.models import User
User.objects.all()

Команда должна вернуть список пользователей. Если он пуст, значит, в базе пока нет записей.

Проверка напрямую через PostgreSQL

Можно подключиться к PostgreSQL и проверить наличие таблиц в базе:

    sudo -u postgres psql

    \c mydatabase;

    \dt;

Если мы хотим убедиться, что в базе есть данные, можно выполнить запрос. Например, проверим список пользователей:

    SELECT * FROM auth_user;

Чтобы остановить сервер разработки, нажмите Ctrl+C в терминале, где он запущен.

Когда работа с проектом завершена, виртуальную среду можно отключить, чтобы вернуть систему к глобальному окружению.

    deactivate

Django-проект на серверах Selectel

Теперь вы умеете создавать собственный проект на Django. Реализуйте свои идеи в проектах и разверните их на сервере, чтобы они были доступны 24/7, независимо от локальной машины.

В этом может помочь облако. Создание сервера займет пару минут. Все просто: регистрируемся или заходим в панель управления и создаем сервер в разделе Облачная платформа:

Доступны различные конфигурации под любые задачи — от минимального варианта для тестирования до мощного решения для высоких нагрузок.

Заключение

Django — мощный и удобный фреймворк, который позволяет быстро создавать веб-приложения любой сложности. В этой статье мы разобрали основные шаги настройки и работы с ним, так что теперь вы готовы к разработке своего проекта.