Первый сайт с помощью Django Python

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

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

Django или WordPress. В чем разница и что выбрать?

Django и WordPress предназначены для разных целей и имеют различные архитектуры, что делает некорректным их прямое сравнение. Вот несколько причин, почему Django и WordPress не являются прямыми конкурентами и почему Django обычно не рассматривается как CMS:

1. Целевая аудитория: Django — это мощный фреймворк для разработки веб-приложений, который предоставляет инструменты для создания сложных и кастомизированных веб-сайтов. WordPress, с другой стороны, предназначен для создания блогов и небольших сайтов с минимальным вмешательством в код.
2. Архитектура: Django разработан как фреймворк с открытым исходным кодом для быстрой разработки сложных веб-приложений, включая CRM, ERP, социальные сети и др. Он предоставляет гибкость и контроль над всеми аспектами приложения. WordPress — это система управления контентом, специально предназначенная для управления содержимым сайта, такого как статьи, страницы, изображения и т.д.
3. Использование: Django позволяет разработчикам создавать собственные веб-приложения с уникальными функциональными возможностями и дизайном. WordPress в первую очередь предоставляет готовые темы и плагины для быстрой установки и запуска простых блогов или сайтов с базовыми возможностями управления содержимым.
4. Уровень сложности: Django может быть сложнее для новичков, так как он предоставляет больше гибкости и требует более глубокого понимания программирования и веб-разработки. WordPress, напротив, спроектирован так, чтобы быть более простым в использовании, даже для пользователей без опыта веб-разработки.

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

Установка Django  на компьютер с Windows

Шаг 1: Установка Python Для начала необходимо установить Python на ваш компьютер. Можно скачать установочный файл с официального сайта Python (https://www.python.org/downloads/). Рекомендуется выбрать последнюю стабильную версию Python 3.x.

Шаг 2: Установка pip pip — это менеджер пакетов Python, который используется для установки и управления пакетами Python. Установка pip происходит автоматически при установке Python версии 3.4 и выше. Если у вас установлена старая версия Python без pip, то его можно установить, следуя инструкциям на сайте: https://pip.pypa.io/en/stable/installation/

Шаг 3: Установка Django Для установки Django необходимо открыть командную строку Windows и ввести следующую команду:

pip install django

Эта команда загрузит и установит последнюю версию Django из репозитория PyPI (Python Package Index).

Шаг 4: Проверка установки Чтобы проверить, что Django был успешно установлен, можно открыть командную строку и ввести следующую команду:

python -m django --version

Если все было установлено правильно, вам будет показана версия Django, установленная на вашем компьютере.

Теперь Django установлен на вашем компьютере и готов к использованию. Если вам нужно создать новый Django проект, то следует использовать команду django-admin startproject projectname, где projectname — название вашего проекта.

Запуск Django в изолированной виртуальной среде

Запуск проекта Django в изолированной виртуальной среде — это хорошая практика, которая помогает избежать конфликтов между разными версиями пакетов и зависимостей, используемых в разных проектах. Кроме того, это позволяет легко переносить проект между разными средами и сохранять их настроенные зависимости.

Для создания виртуальной среды можно использовать инструмент virtualenv, который может быть установлен с помощью pip. Для этого следует выполнить следующие шаги:

Шаг 1: Установка virtualenv

pip install virtualenv

Шаг 2: Создание виртуальной среды

virtualenv env

где env — это название вашей виртуальной среды. Вы можете выбрать любое другое название.

Шаг 3: Активация виртуальной среды

env\Scripts\activate

Для пользователей Linux и macOS команда активации выглядит немного иначе:

source env/bin/activate

Шаг 4: Установка Django

pip install django

Шаг 5: Создание нового проекта Django

django-admin startproject myproject .

гдеmyproject — это название вашего проекта.

Теперь вы можете перейти в папку проекта myproject и запустить локальный сервер, используя следующую команду:

python manage.py runserver

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

deactivate

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

Рекомендуем использовать именно этот способ для запуска проекта Django

Логика работы Django

Django работает с помощью трех взаимосвязанных частей MVT.

MVT (Model-View-Template) — это архитектурный шаблон, который используется в фреймворке Django для разделения логики приложения на три основных компонента:

1. Model (Модель): Отвечает за представление данных и бизнес-логику приложения. Модель определяет структуру данных и методы для работы с ними. Он обычно представляет таблицы базы данных или другие источники данных и позволяет работать с данными с помощью ORM (Object-Relational Mapping). ORM позволяет использовать объекты Python для взаимодействия с базой данных, что упрощает и ускоряет разработку.
2. View (Представление): Отвечает за обработку запросов и взаимодействие с моделью и шаблонами. Представление получает данные из модели, обрабатывает их и передает в шаблон для отображения. В представлении определены функции или классы, которые обрабатывают HTTP-запросы и возвращают HTTP-ответы.
3. Template (Шаблон): Отвечает за отображение данных пользователю. Шаблоны представляют собой HTML-файлы с добавленными в них тегами и переменными Django Template Language (DTL). DTL позволяет вставлять данные из модели в HTML и осуществлять логику принятия решений внутри шаблонов.

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

MVT архитектура помогает разделять код на логические компоненты, что делает проект более структурированным, облегчает сопровождение и позволяет команде разработчиков эффективно сотрудничать над проектом.

Структура Django проекта

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

1. Директория проекта (Project Directory) — это корневая директория вашего проекта Django. Обычно это название вашего проекта, который был создан при помощи команды django-admin startproject.
2. Файл manage.py — это файл, который вы можете использовать для управления различными аспектами вашего проекта Django. Он позволяет запускать сервер, создавать и удалять таблицы в базе данных, создавать новые приложения и многое другое.
3. Директория приложения (Application Directory) — это директория, которая содержит все файлы вашего приложения. Вы можете создать несколько приложений в одном проекте Django.
4. Файл settings.py — это файл, который содержит все настройки вашего проекта Django. Здесь вы можете определить базу данных, статические файлы, локализацию, настройки безопасности и многое другое.
5. Файл urls.py — это файл, который содержит все URL-адреса вашего проекта Django. Здесь вы можете настроить маршруты и перенаправления для различных запросов.
6. Директория static — это директория, которая содержит все статические файлы вашего проекта, такие как CSS, JavaScript, изображения и т.д.
7. Директория templates — это директория, которая содержит все шаблоны HTML-страниц вашего проекта.
8. Файл models.py — это файл, который содержит все модели базы данных вашего проекта Django. Здесь вы можете определить таблицы, связи между ними и многое другое.
9. Файл views.py — это файл, который содержит все представления вашего проекта Django. Здесь вы можете определить функции, которые обрабатывают запросы и возвращают ответы.

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

Django приложения

В Django веб-приложение называется «проектом», а разделы или модули сайта — «приложениями». Например, давай представим, что ты создаешь свой собственный сайт.

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

Далее, чтобы добавить разделы или функциональность к своему сайту, ты создаешь Django приложения. Приложения — это как разделы сайта, такие как блог, форум, новости или портфолио. Каждое приложение занимается своими задачами.

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

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

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

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

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

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

Для создания нового Django приложения можно использовать команду python manage.py startapp <app_name> в терминале или командной строке, где <app_name> — это название вашего приложения.

Когда вы запустите эту команду, Django создаст новую директорию внутри вашего проекта с указанным названием приложения и набором стандартных файлов и каталогов:

<app_name>/
    __init__.py
    admin.py
    apps.py
    models.py
    tests.py
    views.py
    migrations/
        __init__.py

Кратко об этих файлах и директориях:

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

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

INSTALLED_APPS = [    ...    '<app_name>',]

Теперь вы можете использовать все функции и модели, определенные в вашем новом приложении, в рамках вашего Django проекта.

Пример создания приложения для обработки API запросов

Создадим шаблон приложения для получения и изменения данных, хранящихся в БД tasks

1. Создайте новое Django приложение с помощью команды python manage.py startapp api_app.
2. В файле models.py определите модель, которую вы будете использовать в своем API:

from django.db import models

class Task(models.Model):
    title = models.CharField(max_length=200)
    description = models.TextField()
    completed = models.BooleanField(default=False)

    def __str__(self):
        return self.title

 

3. В файле serializers.py создайте сериализатор для вашей модели:

Сериализатор модели — это класс в Django, который позволяет преобразовывать данные модели в формат, который может быть легко передан по сети. Обычно это формат JSON, но сериализаторы также могут работать с другими форматами, такими как XML или YAML.

Сериализатор модели играет важную роль в API, который использует Django. Он позволяет преобразовывать объекты модели Django в формат, который может быть передан клиентской стороне, и наоборот — принимать данные, введенные пользователем на клиентской стороне, и создавать соответствующие объекты модели на стороне сервера.

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

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

from rest_framework import serializers
from .models import Task

class TaskSerializer(serializers.ModelSerializer):
    class Meta:
        model = Task
        fields = '__all__'

4. В файле views.py определите представления для вашего API:

from rest_framework import generics
from .models import Task
from .serializers import TaskSerializer

class TaskList(generics.ListCreateAPIView):
    queryset = Task.objects.all()
    serializer_class = TaskSerializer

class TaskDetail(generics.RetrieveUpdateDestroyAPIView):
    queryset = Task.objects.all()
    serializer_class = TaskSerializer

5. В файле urls.py определите маршруты для вашего API:

from django.urls import path
from .views import TaskList, TaskDetail

urlpatterns = [
    path('tasks/', TaskList.as_view(), name='task-list'),
    path('tasks/<int:pk>/', TaskDetail.as_view(), name='task-detail'),
]

6. Для того, чтобы включить эти URL-адреса в список URL-адресов проекта, необходимо изменить файл urls.py вашего проекта следующим образом:

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

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

В этом примере мы включаем URL-адреса приложения api_app в список URL-адресов проекта, используя функцию include() из модуля django.urls. Обратите внимание, что мы указываем /api/ в качестве префикса для URL-адресов нашего приложения.

6. Зарегистрируйте ваше приложение в INSTALLED_APPS в файле settings.py.
7. Установите djangorestframework с помощью команды pip install djangorestframework.
8. Добавьте rest_framework в INSTALLED_APPS в файле settings.py.

Теперь вы можете запустить ваш Django сервер и обращаться к API, используя эндпоинты /tasks/ и /tasks/<int:pk>/, чтобы получать, создавать, обновлять или удалять объекты модели Task.

Подключение Django к базе данных Postgres Pro

По-умолчанию, Django работает с БД SQLite. Однако я рассмотрю процесс интеграции с другой СУБД — Postgres Pro

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

1. Установить Postgres Pro на свой компьютер, если его еще нет. Скачать установщик можно с официального сайта: https://www.postgresql.org/download/.
2. Запустить Postgres Pro и создать базу данных. Для этого можно использовать командную строку или утилиту pgAdmin, которая обычно поставляется вместе с Postgres Pro. В pgAdmin необходимо выбрать сервер, к которому хотите подключиться, щелкнуть правой кнопкой мыши на разделе «Базы данных» и выбрать «Создать базу данных». Задайте имя базы данных и нажмите «ОК».
3. Установить драйвер для работы с Postgres Pro в Django. Для этого необходимо выполнить команду pip install psycopg2.
4. В файле settings.py Django проекта настроить подключение к базе данных. В секции DATABASES необходимо указать следующие параметры:

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'имя_базы_данных',
        'USER': 'имя_пользователя',
        'PASSWORD': 'пароль_пользователя',
        'HOST': 'localhost',
        'PORT': '5432',
    }
}

Здесь указывается тип базы данных ('ENGINE': 'django.db.backends.postgresql'), имя базы данных ('NAME': 'имя_базы_данных'), имя пользователя и пароль для доступа к базе данных ('USER': 'имя_пользователя' и 'PASSWORD': 'пароль_пользователя' соответственно), а также хост и порт, на котором работает база данных ('HOST': 'localhost' и 'PORT': '5432').

После этого база данных Postgres Pro будет готова к использованию в Django проекте.

Создание таблицы в модели данных приложения Django

Для создания таблицы в Django модели и PostgresPro необходимо выполнить следующие шаги:

1. В файле models.py вашего Django приложения определите класс модели, который будет представлять таблицу в базе данных. Например, создадим модель Person, которая будет иметь поля first_name, last_name и email:

from django.db import models

class Person(models.Model):
    first_name = models.CharField(max_length=30)
    last_name = models.CharField(max_length=30)
    email = models.EmailField(max_length=254)

Здесь мы использовали класс CharField для хранения строковых значений с максимальной длиной 30 символов и класс EmailField для хранения email адресов с максимальной длиной 254 символа.

2. Создайте миграции для этой модели, используя команду python manage.py makemigrations. Django создаст файл миграции в папке migrations вашего приложения.
3. Примените миграции, используя команду python manage.py migrate. Django создаст таблицу person в базе данных PostgresPro.

После выполнения этих шагов таблица person будет создана в базе данных PostgresPro и будет готова к использованию. Если вы хотите проверить, что таблица была создана правильно, можете использовать утилиту pgAdmin или выполнить запрос на выборку данных из таблицы с помощью команды SELECT * FROM person;.

Создание контента

В Django представления (views) отвечают за обработку запросов и возвращение ответов. Представления могут быть написаны как в виде функций, так и в виде классов.

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

from django.http import HttpResponse

def hello(request):
    return HttpResponse("Hello, world!")

Здесь мы создали функцию hello, которая принимает объект request, представляющий текущий HTTP-запрос. Функция возвращает объект HttpResponse, который содержит ответ на запрос в виде строки «Hello, world!».

Чтобы связать это представление с URL-адресом, мы должны определить маршрут (route) в файле urls.py. Маршрут связывает URL-адрес с соответствующим представлением. Например, в файле urls.py мы можем добавить следующий код:

from django.urls import path
from . import views

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

Здесь мы определили маршрут для URL-адреса /hello/, который будет использовать представление hello. Функция hello импортируется из файла views.py с помощью оператора from . import views. Кроме того, мы задали имя маршрута с помощью параметра name.

Теперь при обращении к URL-адресу /hello/ будет вызываться функция hello из файла views.py, и пользователь увидит сообщение «Hello, world!».

Использование шаблонов контента

В Django шаблоны (templates) используются для генерации HTML-страниц на основе данных из базы данных или других источников.

Для создания простого шаблона в Django необходимо создать файл с расширением .html и определить его структуру, используя специальный язык шаблонов Django. Шаблон нужно создать в папке templates корневой папки проекта (там где хранится файл manage.py). Имя файла с шаблоном my_template.html. Там же, нужно будет сохранить фал шаблона base.html (его код будет приведен ниже), а также index.html для кода главной страницы сайта.

Пример простого шаблона (my_template.html) для отображения списка объектов модели:

{% extends 'base.html' %}

{% block content %}
    <h1>Список объектов модели</h1>
    <ul>
    {% for object in object_list %}
        <li>{{ object }}</li>
    {% empty %}
        <li>Список объектов пуст</li>
    {% endfor %}
    </ul>
{% endblock %}

В этом примере мы используем наследование шаблона base.html с помощью директивы {% extends 'base.html' %}. В блоке {% block content %} мы определяем контент страницы, который будет добавлен в блок content в базовом шаблоне.

Далее мы используем цикл for для перебора объектов модели, переданных в шаблон из представления. Для каждого объекта мы выводим его строковое представление с помощью {{ object }}. Если список объектов пуст, мы выводим сообщение «Список объектов пуст» с помощью директивы {% empty %}.

Код шаблона base.html

Создать базовый шаблон проекта, если его еще нет. Это может быть файл base.html, который содержит общую структуру страницы, например, шапку, навигационное меню и подвал. Этот файл также должен находиться в директории templates/ в корневом каталоге проекта.

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

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>{% block title %}Мой сайт{% endblock %}</title>
</head>
<body>
    <header>
        <!-- Шапка сайта -->
    </header>
    <nav>
        <!-- Навигационное меню -->
    </nav>
    <main>
        {% block content %}{% endblock %}
    </main>
    <footer>
        <!-- Подвал сайта -->
    </footer>
</body>
</html>

Здесь мы определили блок {% block content %} в основном контентном блоке страницы. Этот блок будет заполняться контентом из шаблона приложения.

В шаблоне приложения расширить базовый шаблон проекта и определить контент, который будет отображаться в блоке {% block content %}. Например:

{% extends 'base.html' %}

{% block content %}
<h1>Список объектов модели</h1>
<ul>
{% for object in object_list %}
    <li>{{ object }}</li>
{% empty %}
    <li>Список объектов пуст</li>
{% endfor %}
</ul>
{% endblock %}

Здесь мы используем директиву {% extends 'base.html' %} для наследования базового шаблона.

Также, заполним шаблон пустой главной страницы. Впоследствии, мы заполним его необходимыми данными. Содержимое файла index.html:

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>{% block title %}Мой сайт{% endblock %}</title>
</head>
<body>
    <header>
        <!-- Шапка сайта -->
    </header>
    <nav>
        <!-- Навигационное меню -->
    </nav>
    <main>
        {% block content %}{% endblock %}
    </main>
    <footer>
        <!-- Подвал сайта -->
    </footer>
</body>
</html>

Чтобы использовать эти шаблоны в представлении, мы должны вернуть его из функции представления вместе с данными для заполнения шаблона.

Данные мы будем брать из модели приложения api_app, которую создали в примере создания приложения api. Мы возьмем список задач и выведем их на экран. Редактируем файл views.py в папке проекта.

from django.shortcuts import render
from api_app.models import Task
def my_view(request):
    objects = Task.objects.all()
    return render(request, 'my_template.html', {'object_list': objects})
def index(request):
    return render(request, 'index.html')

Здесь мы создали функцию представления my_view, которая получает все объекты из модели приложения api_app task и передает их в шаблон my_template.html в виде списка с ключом object_list. Функция render используется для загрузки и рендеринга шаблона с передачей данных из представления.

Кроме того, мы определили функцию представления index, для загрузки данных главной страницы из шаблона index.html.

Подключение представления и шаблона к основному проекту

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

Создать URL-маршрут для представления в файле urls.py проекта. Например:

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

urlpatterns = [
path('admin/', admin.site.urls),
path('api/', include('api_app.urls')),
path('main/', include('main.urls')),
path('', views.index, name='index'),
path('my-view/', views.my_view, name='my-view'),
]

В этом примере мы импортируем функцию представления my_view из файла views.py и создаем URL-маршрут, который будет вызывать это представление при обращении к адресу /my-view/. Также, создаем маршрут для главной страницы проекта, который будет вызывать представление index из views.py.

Статическое содержимое сайта на Django

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

При создании проекта Django уже создает директорию с именем «static» в корневой директории проекта. Внутри нее могут быть поддиректории, соответствующие различным компонентам проекта, и в каждой поддиректории могут храниться файлы статики.

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

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

Здесь BASE_DIR — это переменная, содержащая путь к корневой директории проекта.

После этого можно использовать статические файлы в шаблонах, добавляя соответствующие теги:

{% load static %}

<link rel="stylesheet" type="text/css" href="{% static 'css/styles.css' %}">

Здесь load static — это команда загрузки тегов для работы со статическими файлами в шаблонах, а {% static 'css/styles.css' %} — это тег, указывающий на путь к нужному файлу статики.

Подключение дополнительных модулей Python к Django проекту

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

Вот как добавить дополнительные модули:

Активируйте виртуальную среду: Перейдите в папку с вашим проектом и активируйте виртуальную среду. В командной строке Windows это делается командой:

venv\Scripts\activate

На macOS и Linux:

source venv/bin/activate

Установите дополнительные модули: Далее, используйте pip для установки нужных модулей. Например, если вы хотите установить модуль requests, выполните команду:

pip install requests

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

Сохраните зависимости: Чтобы сохранить список установленных модулей для будущих использований (например, чтобы поделиться проектом с другими разработчиками), создайте файл requirements.txt и сохраните в нем список модулей. Это можно сделать командой:

pip freeze > requirements.txt

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

deactivate

Это деактивирует виртуальную среду и вернет вас в глобальное окружение Python.

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

Восстановление зависимостей при миграции проекта

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

1. Активируйте виртуальную среду (если она уже не активирована):
Перейдите в папку с вашим проектом и активируйте виртуальную среду, как указано в предыдущем ответе.

2. Установите исходные версии модулей из `requirements.txt`:
Для этого выполните следующую команду:

pip install -r requirements.txt

Это установит все модули, перечисленные в `requirements.txt`, с их исходными версиями.

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