Веб-фреймворк Django (Python) — Изучение веб-разработки

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

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

Рекомендуется базовое понимание концепций программирования и языка Python, но это не обязательно для освоения основных понятий.

Примечание: Python является одним из самых доступных в чтении и понимании для новичков языком программирования. Тем не менее, если вы захотите глубже понять этот модуль, в Интернете сейчас доступны многочисленные бесплатные книги и учебные пособия (новички в программирование возможно захотят посетить Python for Non Programmers на вики-страницах python. org).

Введение в Django

В этой первой статье по Django мы ответим на вопрос «Что такое Django?» и сделаем обзор того, что делает этот веб-фреймворк особенным. Мы кратко рассмотрим основные особенности, включая некоторую продвинутую функциональность, на которой у нас не будет возможности подробно остановиться в этом модуле. Мы также покажем вам некоторые из основных строительных блоков приложения Django, чтобы дать вам представление о том, что он может сделать, прежде чем вы перейдёте к установке и начнёте экспериментировать.

Установка среды разработки Django

Теперь, когда вы знаете, что такое Django, мы покажем вам, как установить и протестировать среду разработки Django для Windows, Linux (Ubuntu) и Mac OS X — какую бы операционную систему вы не использовали, эта статья должна дать вам понимание того, что вам потребуется, чтобы начать разработку Django-приложений .

Учебник Django: Веб-сайт местной библиотеки

Первая статья в нашей серии практических уроков объясняет, что вы узнаете, и представит обзор веб-сайта «местной библиотеки», над которым мы будем работать и развиваться в последующих статьях.

Учебник Django часть 2: Создание скелета веб-сайта

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

Учебник Django часть 3: Использование моделей

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

Учебник Django часть 4: Django admin веб-сайта

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

Учебник Django часть 5: Создание главной страницы 

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

Учебник Django часть 6: Общий список и подробные представления

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

Учебник Django часть 7:  Структура сессий

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

Учебник Django часть 8: Авторизация и права пользователей

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

Учебник Django часть 9: Работа с формами

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

Учебник Django часть10: Тестирование веб-приложения Django

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

Учебник Django часть 11: Деплой Django на продакшн

Теперь вы создали (и протестировали) удивительный сайт местной библиотеки, вам захочется установить его на общедоступный веб-сервер, чтобы к нему мог получить доступ персонал библиотеки и пользователи Интернета. В этой статье представлен обзор того, как вы можете найти хост для развёртывания вашего веб-сайта и что вам нужно сделать, чтобы подготовить ваш сайт к выпуску.

Безопасность веб-приложений Django

Защита пользовательских данных является неотъемлемой частью любой разработки сайта. Ранее мы объяснили некоторые из наиболее распространённых угроз безопасности в статье Web security — Эта статья даёт практическую демонстрацию того, как встроенные средства защиты Django справляются с такими угрозами.

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

DIY Django мини-блог

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

Django учебник Часть 3: Использование моделей — Изучение веб-разработки

В этой статье показано, как определить модели для LocalLibrary сайта. Она объясняет, что такое модель, как она объявляется, и некоторые из основных типов полей. В ней также кратко показаны некоторые из основных способов доступа к данным модели.

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

В этом учебнике показано, как определить и получить доступ к моделям на примере LocalLibrary website.

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

Мы знаем, что нам нужно хранить информацию о книгах (название, резюме, автор, язык, на котором написана книга, категория, ISBN) и что у нас может быть несколько доступных экземпляров (с уникальным глобальным идентификатором, статусом доступности и т. Д.). Нам может потребоваться хранить больше информации об авторе, чем просто их имя, и могут быть несколько авторов с одинаковыми или похожими именами. Мы хотим иметь возможность сортировать информацию на основе названия книги, автора, письменного языка и категории.

При проектировании ваших моделей имеет смысл иметь отдельные модели для каждого «объекта» (группа связанной информации). В этом случае очевидными объектами являются книги, экземпляры книг и авторы.

Вы также можете использовать модели для представления параметров списка выбора (например, как выпадающий список вариантов), вместо жёсткого кодирования выбора на самом веб-сайте — это рекомендуется, когда все варианты неизвестны заранее или могут измениться. Очевидные кандидаты на модели в этом случае включают жанр книги (например, «Научная фантастика», «Французская поэзия» и т. д.) И язык (английский, французский, японский).

Как только мы определились с нашими моделями и полями, нам нужно подумать об отношениях. Django позволяет вам определять отношения, как один к одному (OneToOneField), один ко многим (ForeignKey) и многие ко многим (ManyToManyField).

Диаграмма ассоциации UML, приведённая ниже показывает модели, которые мы определили в этом случае (в виде блоков). Как и выше, мы создали модели для книги (общие сведения о книге), экземпляр книги (статус конкретных физических копий книги, доступных в системе) и автора.Мы также решили создать модель для жанра, чтобы можно было создавать / выбирать значения через интерфейс администратора. Мы решили не иметь модель для BookInstance: status — мы жёстко закодировали значения (LOAN_STATUS), потому что мы не ожидаем их изменения. В каждом из полей вы можете увидеть имя модели, имена и типы полей, а также методы и их типы возврата.

На диаграмме также показаны зависимости между моделями, включая их множители. Множители представляют собой числа на диаграмме, показывающие минимум и максимум единиц каждой модели, которые могут присутствовать в этой связи. Например, соединительная линия между ящиками показывает, что книга и жанр связаны между собой. Цифры, близкие к модели жанра, показывают, что у книги может быть один или несколько жанров (сколько угодно), а числа на другом конце строки рядом с моделью книги показывают, что у жанра может быть ноль или более связанных книг.

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

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

Определение модели

Модели обычно определяются в приложении models.py. Они реализуются как подклассы django.db.models.Model, и могут включать поля, методы и метаданные. В приведённом ниже фрагменте кода показана «типичная» модель, названная MyModelName:

from django.db import models

class MyModelName(models.Model):
    """
    A typical class defining a model, derived from the Model class.
    """

    # Fields
    my_field_name = models.CharField(max_length=20, help_text="Enter field documentation")
    ...

    # Metadata
    class Meta:
        ordering = ["-my_field_name"]

    # Methods
    def get_absolute_url(self):
         """
         Returns the url to access a particular instance of MyModelName.
         """
         return reverse('model-detail-view', args=[str(self.id)])

    def __str__(self):
        """
        String for representing the MyModelName object (in Admin site etc.)
        """
        return self.field_name

В следующих разделах мы подробно рассмотрим каждый элемент внутри модели:

Поля

Модель может иметь произвольное количество полей любого типа — каждый представляет столбец данных, который мы хотим сохранить в одной из наших таблиц базы данных. Каждая запись (строка) базы данных будет состоять из одного значения каждого поля. Давайте рассмотрим приведённый выше пример:

my_field_name = models.CharField(max_length=20, help_text="Enter field documentation")

Наш вышеприведённый пример имеет одно поле, называемое my_field_name, типа models.CharField — что означает, что это поле будет содержать строки буквенно-цифровых символов. Типы полей назначаются с использованием определённых классов, которые определяют тип записи, которая используется для хранения данных в базе данных, а также критерии проверки, которые должны использоваться, когда значения получены из формы HTML (то есть, что составляет действительное значение). Типы полей также могут принимать аргументы, которые дополнительно определяют, как поле хранится или может использоваться. В этом случае мы даём нашему полю два аргумента:

• max_length=20 — Указывает, что максимальная длина значения в этом поле составляет 20 символов.
• help_text="Enter field documentation" — предоставляет текстовую метку для отображения, чтобы помочь пользователям узнать, какое значение необходимо предоставить, когда это значение должно быть введено пользователем через HTML-форму.

Имя поля используется для обращения к нему в запросах и шаблонах. В полях также есть метка, которая задаётся как аргумент (verbose_name), либо выводится путём заглавной буквы первой буквы имени переменной поля и замены любых символов подчёркивания пробелом (например, my_field_name будет иметь метку по умолчанию My field name).

Порядок, в котором объявляются поля, будет влиять на их порядок по умолчанию, если модель отображается в форме (например, на сайте администратора), хотя это может быть переопределено.

Общие аргументы поля

Следующие общие аргументы могут использоваться при объявлении многих / разных типов полей:

• help_text: Предоставляет текстовую метку для HTML-форм (например, на сайте администратора), как описано выше.
• verbose_name: Удобочитаемое имя для поля, используемого в поле метки. Если не указано, Django выведет по умолчанию подробное название от имени поля.
• default: Значение по умолчанию для поля. Это может быть значение или вызываемый объект, и в этом случае объект будет вызываться каждый раз, когда создаётся новая запись.
• null: Если True, Django будет хранить пустые значения как NULL в базе данных для полей, где это уместно (CharField вместо этого сохранит пустую строку). По умолчанию используется значение False.
• blank: Если True, поле может быть пустым в ваших формах. По умолчанию используется значение False, что означает, что проверка формы Django заставит вас ввести значение. Это часто используется с null = True, потому что если вы хотите разрешить пустые значения, вы также хотите, чтобы база данных могла представлять их соответствующим образом.
• choices: Группа вариантов для этого поля. Если это предусмотрено, по умолчанию соответствующий виджет формы будет полем выбора с этими вариантами вместо стандартного текстового поля.
• primary_key: Если True, задаёт текущее поле в качестве первичного ключа для модели (первичный ключ — это специальный столбец базы данных, предназначенный для однозначной идентификации всех разных записей таблицы). Если в качестве первичного ключа не указано поле, Django автоматически добавит для этой цели поле.

Есть много других вариантов — вы можете просмотреть full list of field options here.

Общие типы полей

Следующие общие аргументы могут использоваться при объявлении многих / разных типов полей:

• CharField Используется для определения строк фиксированной длины от короткой до средней. Вы должны указать max_length для хранения данных.
• TextField используется для больших строк произвольной длины. Вы можете указать max_length для поля, но это используется только тогда, когда поле отображается в формах (оно не применяется на уровне базы данных).
• IntegerField это поле для хранения значений (целого числа) и для проверки введённых значений в виде целых чисел в формах.
• DateField и DateTimeField используются для хранения / представления дат и информации о дате / времени (как Python datetime.date и datetime.datetime, соответственно). Эти поля могут дополнительно объявлять (взаимоисключающие) параметры auto_now=True (для установки поля на текущую дату каждый раз, когда модель сохраняется), auto_now_add (только для установки даты, когда модель была впервые создана) и по умолчанию (чтобы установить дату по умолчанию, которую пользователь может переустановить).
• EmailField используется для хранения и проверки адресов электронной почты.
• FileField и ImageField используются для загрузки файлов и изображений соответственно ( ImageField просто добавляет дополнительную проверку, что загруженный файл является изображением). Они имеют параметры для определения того, как и где хранятся загруженные файлы.
• AutoField — это особый тип IntegerField, который автоматически увеличивается. Первичный ключ этого типа автоматически добавляется в вашу модель, если вы явно не укажете его.
• ForeignKey Используется для указания отношения «один ко многим» к другой модели базы данных (например, автомобиль имеет одного производителя, но производитель может делать много автомобилей). «Одна» сторона отношения — это модель, содержащая ключ.
• ManyToManyField используется для определения отношения «многие ко многим» (например, книга может иметь несколько жанров, и каждый жанр может содержать несколько книг). В нашем приложении для библиотек мы будем использовать их аналогично ForeignKeys, но их можно использовать более сложными способами для описания отношений между группами. Они имеют параметр on_delete, чтобы определить, что происходит, когда связанная запись удаляется (например, значение models.SET_NULL просто установило бы значение NULL)

Существует много других типов полей, включая поля для разных типов чисел (большие целые числа, малые целые числа, дробные), логические значения, URL-адреса, slugs, уникальные идентификаторы и другие «связанные с временем» сведения (продолжительность, время и т. д.). Вы можете просмотреть full list here.

Метаданные

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

class Meta:
    ordering = ["-my_field_name"]
    ...

Одной из наиболее полезных функций этих метаданных является управление сортировка записей, возвращаемых при запросе типа модели. Вы можете сделать это, указав соответствия названия полей для сортировки, как показано выше. Порядок будет зависеть от типа поля (поля символов отсортированы в алфавитном порядке, а поля даты отсортированы в хронологическом порядке). Как показано выше, вы можете префикс имени поля минус-символом (-), чтобы изменить порядок сортировки.

Например, если мы решили сортировать книги по умолчанию:

ordering = ["title", "-pubdate"]

Книги будут отсортированы по алфавиту по названию, от A-Z, а затем по дате публикации внутри каждого названия, от самого нового до самого старого.

Другим распространённым атрибутом является verbose_name, подробное имя для класса в единственной и множественной форме:

verbose_name = "BetterName"

Другие полезные атрибуты позволяют создавать и применять новые «разрешения доступа» для модели (разрешения по умолчанию применяются автоматически), разрешить упорядочение на основе другого поля или объявить, что класс является «абстрактным» (базовый класс, для которого вы не можете создавать записи, и вместо этого будет создан для создания других моделей). Многие другие параметры метаданных управляют тем, какая база данных должна использоваться для модели и как хранятся данные (это действительно полезно, если вам нужно сопоставить модель с существующей базой данных). Полный список опций метаданных доступен здесь: Model metadata options (Django документация).

Методы

Модель также может иметь методы. Минимально в каждой модели вы должны определить стандартный метод класса для Python __str __ (), чтобы вернуть удобочитаемую строку для каждого объекта. Эта строка используется для представления отдельных записей на сайте администрирования (и в любом другом месте, где вам нужно обратиться к экземпляру модели). Часто это возвращает поле названия или имени из модели.

def __str__(self):
    return self.field_name

Другим распространённым методом включения в модели Django является get_absolute_url (), который возвращает URL-адрес для отображения отдельных записей модели на веб-сайте (если вы определяете этот метод, тогда Django автоматически добавит кнопку «Просмотр на сайте» на экранах редактирования записей модели на сайте администратора). Типичный шаблон для get_absolute_url () показан ниже.

def get_absolute_url(self):
    """
    Returns the url to access a particular instance of the model.
    """
    return reverse('model-detail-view', args=[str(self.id)])

Примечание. Предполагается, что вы будете использовать URL-адреса, например / myapplication / mymodelname / 2, для отображения отдельных записей для вашей модели (где «2» — это идентификатор для определённой записи), вам нужно будет создать URL-карту, чтобы передать ответ и идентификатор «Образцовое представление модели» (которое будет выполнять работу, необходимую для отображения записи). Вышеуказанная функция reverse () может «перевернуть» ваш URL-адрес (в приведённом выше примере с именем «model-detail-view»), чтобы создать URL-адрес правильного формата.

Конечно, для выполнения этой работы вам всё равно придётся писать сопоставление URL-адрес, просмотр и шаблон!

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

Управление моделью

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

Создание и изменение записей

Чтобы создать запись, вы можете определить экземпляр модели, а затем вызвать метод save ().

a_record = MyModelName(my_field_name="Instance #1")


a_record. save()

Примечание. Если вы не указали какое-либо поле в качестве primary_key, новая запись будет выдаваться автоматически, с идентификатором имени поля. Вы можете запросить это поле после сохранения указанной выше записи, и оно будет иметь значение 1.

Вы можете получить доступ к полям в этой новой записи с использованием синтаксиса точек и изменить значения. Вы должны вызвать save (), чтобы сохранить изменённые значения в базе данных.

print(a_record.id) 
print(a_record.my_field_name) 


a_record.my_field_name="New Instance Name"
a_record.save()

Поиск записей

Вы можете искать записи, соответствующие определённым критериям, используя атрибут объектов модели (предоставляемый базовым классом).

Примечание. Объяснение того, как искать записи, используя «абстрактную» модель и имена полей, может быть немного запутанным. В приведённом ниже обсуждении мы будем ссылаться на модель книги с полями названия и жанра, где жанр также является моделью с единственным именем в поле.

Мы можем получить все записи для модели как объект QuerySet,  используя objects.all(). QuerySet — это итерируемый объект, означающий, что он содержит несколько объектов, которые мы можем перебирать / прокручивать.

all_books = Book.objects.all()

Метод filter() Django позволяет отфильтровать возвращаемый QuerySet для соответствия указанному текстовому или числовому полю по конкретным критериям. Например, чтобы отфильтровать книги, содержащие  слово «wild» («дикие») в заголовке, а затем подсчитать их, мы могли бы сделать следующее.

wild_books = Book.objects.filter(title__contains='wild')
number_wild_books = Book.objects.filter(title__contains='wild').count()

Соответствующие поля и тип соответствия определяются в имени параметра фильтра, используя формат: field_name__match_type (обратите внимание на двойное подчёркивание между заголовком выше). Выше мы фильтруем заголовок с учётом регистра. Есть много других типов совпадений, которые вы можете сделать: icontains (без учёта регистра), iexact (точное совпадение без учёта регистра), exact (точное совпадение с учётом регистра ) и in, gt (больше), startswith и т. д смотреть полный список (Django Docs, [EN]).

В некоторых случаях вам нужно будет фильтровать поле, которое определяет отношение «один ко многим» к другой модели (например, ForeignKey). В этом случае вы можете «индексировать» поля в связанной модели с дополнительными двойными подчёркиваниями. Так, например, чтобы фильтровать книги с определённым жанровым рисунком, вам нужно будет указывать имя в поле жанра, как показано ниже:

books_containing_genre = Book.objects.filter(genre__name__icontains='fiction')  

Примечание: Вы можете использовать символы подчёркивания (__) для навигации по многим уровням отношений (ForeignKey / ManyToManyField) по своему усмотрению. Например, книга, имеющая разные типы, определяемая с использованием дополнительной связи «обложка», может иметь имя параметра: type__cover__name__exact = ‘hard’.

Существует гораздо больше возможностей для запросов, включая обратные поиски от связанных моделей, цепочки фильтров, возврат меньшего набора значений и т. д. Для получения дополнительной информации см. Making queries (Django Docs, [EN]).

В этом разделе мы начнём определять модели для библиотеки. Откройте models.py (в / locallibrary / catalog /). Шаблон в верхней части страницы импортирует модуль моделей, который содержит базовый класс модели models.Model, от которого наследуются наши модели.

from django.db import models

Модель жанра

Скопируйте приведённый ниже код модели Genre и вставьте его в нижнюю часть вашего файла models.py. Эта модель используется для хранения информации о категории книг — например, будь то художественная или документальная, роман или военно-историческая и т. д. Как уже упоминалось выше, мы создали жанр как модель, а не как свободный текст или список выбора, чтобы возможные значения могли управляться через базу данных, а не были закодированными.

class Genre(models.Model):
    """
    Model representing a book genre (e.g. Science Fiction, Non Fiction).
    """
    name = models.CharField(max_length=200, help_text="Enter a book genre (e.g. Science Fiction, French Poetry etc.)")

    def __str__(self):
        """
        String for representing the Model object (in Admin site etc.)
        """
        return self.name

Модель имеет один CharField field (имя), которое используется для описания жанра (оно ограничено 200 символами и имеет некоторый help_text. В конце модели мы объявляем метод __str__(), который просто возвращает имя жанра, определённого конкретной записью. Verbose name не был определён, поэтому поле будет называться Name в формах.

Модель книги

Скопируйте модель книги ниже и снова вставьте её в нижнюю часть файла. Модель книги представляет всю информацию о доступной книге в общем смысле, но не конкретный физический «экземпляр» или «копию» для временного использования. Модель использует CharField для представления названия книги и isbn (обратите внимание, как isbn указывает свой ярлык как «ISBN», используя первый неименованный параметр, поскольку в противном случае ярлык по умолчанию был бы «Isbn»). Модель использует TextField для summary, потому что этот текст, возможно, должен быть очень длинным.

from django.urls import reverse 

class Book(models.Model):
    """
    Model representing a book (but not a specific copy of a book).
    """
    title = models.CharField(max_length=200)
    author = models.ForeignKey('Author', on_delete=models.SET_NULL, null=True)
    
    
    summary = models.TextField(max_length=1000, help_text="Enter a brief description of the book")
    isbn = models.CharField('ISBN',max_length=13, help_text='13 Character <a href="https://www.isbn-international. org/content/what-isbn">ISBN number</a>')
    genre = models.ManyToManyField(Genre, help_text="Select a genre for this book")
    
    

    def __str__(self):
        """
        String for representing the Model object.
        """
        return self.title


    def get_absolute_url(self):
        """
        Returns the url to access a particular book instance.
        """
        return reverse('book-detail', args=[str(self.id)])

Жанр представляет из себя ManyToManyField, так что книга может иметь несколько жанров, а жанр может иметь много книг. Автор объявляется через ForeignKey, поэтому в каждой книге будет только один автор, но у автора может быть много книг (на практике книга может иметь несколько авторов, но не в такой реализации!)

В обоих типах полей соответствующий класс модели объявляется как первый неименованный параметр, используя либо класс модели, либо строку, содержащую имя соответствующей модели. Вы должны использовать имя модели как строку, если связанный класс ещё не был определён в этом файле до того, как он будет указан! Другими параметрами, представляющими интерес для поля автора, являются null=True, которое позволяет базе данных хранить значение Null , если автор не выбран, и on_delete = models.  SET_NULL установит значение автора в Null, если связанная с автором запись будет удалена.

Модель также определяет __str __ (), используя поле заголовка книги для представления книги. Окончательный метод get_absolute_url () возвращает URL-адрес, который можно использовать для доступа к подробной записи для этой модели (для этого нам нужно будет определить сопоставление URL-адресов, в котором содержится подробная информация о книге, и определить связанное представление и шаблон ).

Модель BookInstance

Затем скопируйте модель BookInstance (показано ниже) под другие модели. BookInstance представляет собой определённую копию книги, которую кто-то может брать взаймы, и включает информацию о том, доступна ли копия или в какой день она ожидается, «отпечаток» или сведения о версии, а также уникальный идентификатор книги в библиотеке. Теперь некоторые из полей и методов будут знакомы. Модель использует

• ForeignKey для идентификации связанной книги (в каждой книге может быть много копий, но в копии может быть только одна книга).
• CharField, для представления данных (конкретного выпуска) о книге.

import uuid 

class BookInstance(models.Model):
    """
    Model representing a specific copy of a book (i.e. that can be borrowed from the library).
    """
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, help_text="Unique ID for this particular book across whole library")
    book = models.ForeignKey('Book', on_delete=models.SET_NULL, null=True)
    imprint = models.CharField(max_length=200)
    due_back = models.DateField(null=True, blank=True)

    LOAN_STATUS = (
        ('m', 'Maintenance'),
        ('o', 'On loan'),
        ('a', 'Available'),
        ('r', 'Reserved'),
    )

    status = models.CharField(max_length=1, choices=LOAN_STATUS, blank=True, default='m', help_text='Book availability')

    class Meta:
        ordering = ["due_back"]


    def __str__(self):
        """
        String for representing the Model object
        """
        return '%s (%s)' % (self. id,self.book.title)

Мы дополнительно объявляем несколько новых типов полей:

• UUIDField используется для поля id, чтобы установить его как primary_key для этой модели. Этот тип поля выделяет глобальное уникальное значение для каждого экземпляра (по одному для каждой книги, которую вы можете найти в библиотеке).
• DateField используется для данных due_back (при которых ожидается, что книга появится после заимствования или обслуживания). Это значение может быть blank или null (необходимо, когда книга доступна). Метаданные модели (Class Meta) используют это поле для упорядочивания записей, когда они возвращаются в запросе.
• status — это CharField, который определяет список choice/selection. Как вы можете видеть, мы определяем кортеж, содержащий кортежи пар ключ-значение и передаём его аргументу выбора. Значение в key/value паре — это отображаемое значение, которое пользователь может выбрать, а ключи — это значения, которые фактически сохраняются, если выбрана опция. Мы также установили значение по умолчанию «m» (техническое обслуживание), поскольку книги изначально будут созданы недоступными до того, как они будут храниться на полках.

Модель __str __ () представляет объект BookInstance, используя комбинацию его уникального идентификатора и связанного с ним заголовка книги.

Примечание. Немного Python:

• Значение, возвращаемое __str __ (), является форматированной строкой. В строке мы используем % S для объявления ‘placeholders’. После строки укажем %, а затем кортеж, содержащий значения, которые будут вставлены в заполнители. Если у вас просто один заполнитель, вы можете опустить кортеж — например, ‘Моё значение:% S’ % переменная.

  Обратите также внимание на то, что, хотя этот подход совершенно применим, но он более не является предпочтительным. Начиная с Python 3, вы должны использовать метод format, например. ‘{0} ({1})’.format (self.id, self.book.title). Вы можете узнать больше об этом  здесь.

Модель автора

Скопируйте модель автора (показано ниже) под существующим кодом в models. py.

Теперь все поля/методы должны быть знакомы. Модель определяет автора как имя, фамилию, дату рождения и (необязательную) дату смерти. Он указывает, что по умолчанию __str __ () возвращает имя в фамилии, порядковый номер первого имени. Метод get_absolute_url () отменяет сопоставление URL-адреса автора с целью получения URL-адреса для отображения отдельного автора.

class Author(models.Model):
    """
    Model representing an author.
    """
    first_name = models.CharField(max_length=100)
    last_name = models.CharField(max_length=100)
    date_of_birth = models.DateField(null=True, blank=True)
    date_of_death = models.DateField('Died', null=True, blank=True)

    def get_absolute_url(self):
        """
        Returns the url to access a particular author instance.
        """
        return reverse('author-detail', args=[str(self.id)])


    def __str__(self):
        """
        String for representing the Model object.
        """
        return '%s, %s' % (self. last_name, self.first_name)

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

python3 manage.py makemigrations
python3 manage.py migrate

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

Некоторые вещи, которые следует учитывать:

• Должен ли «язык» ассоциироваться с Book, BookInstance или каким-либо другим объектом?
• Должны ли быть представлены разные языки с использованием модели, свободного текстового поля или жёстко запрограммированного списка выбора?

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

В этой статье мы узнали, как определять модели, а затем использовать эту информацию в разработке и внедрении соответствующих моделей для сайта LocalLibrary.

На этом этапе мы отвлечёмся от создания сайта и проверим Django Administration site. Этот сайт позволит нам добавить некоторые данные в библиотеку, которые мы можем отобразить с помощью наших (ещё не созданных) представлений и шаблонов.

Setting up a Django development environment — Изучение веб-разработки

Теперь, когда вы знаете, что такое Django, мы покажем вам, как настроить и протестировать среду разработки Django для Windows, Linux (Ubuntu) и Mac OS X — какую бы операционную систему вы не использовали, эта статья должна дать вам все, что необходимо для возможности начать разрабатывать приложения Django.

Django упрощает настройку собственного компьютера, чтобы вы могли начать разработку веб-приложений. В этом разделе объясняется, что входит в состав среды разработки, и даётся обзор некоторых параметров настройки и конфигурации. В оставшейся части статьи объясняется рекомендуемый метод установки среды разработки Django на Ubuntu, Mac OS X и Windows, и как вы можете её протестировать.

Что такое среда разработки Django?

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

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

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

Какие есть разновидности установки Django ?

Django очень гибок с точки зрения способа и места установки и настройки. Django может быть:

• установлен на различных операционных системах,
• установлен из исходного кода, из Python Package Index (PyPi) и во многих случаях из любого менеджера пакетов,
• настроен на использование различных баз данных, которые должны быть установлены и настроены отдельно,
• запущен в основной системе окружения Python или в отдельном виртуальном окружении Python.

Каждый из этих вариантов требует немного разной настройки и установки. Следующие подразделы объяснят некоторые аспекты вашего выбора. Далее мы покажем вам, как установить Django на некоторые операционные системы, и эта установка будет предполагаться на всём протяжении данного модуля.

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

Какие операционные системы поддерживаются?

Веб-приложения Django можно запускать почти на любых машинах, которые поддерживают язык программирования Python 3, среди прочих: Windows, Mac OS X, Linux/Unix, Solaris. Почти любой компьютер имеет необходимую производительность для запуска Django во время разработки.

В этой статье мы предоставляем инструкции для Windows, Mac OS X, and Linux/Unix.

Какую версию Python стоит использовать?

Мы рекомендуем использовать самую последнюю доступную версию — на момент написания статьи это Python 3.6.

Замечание: Python 2.7 не может быть использован вместе с Django 2.0 (последние поддерживаемые серии для Python 2.7 — Django 1.11.x).

Откуда можно скачать Django?

Для загрузки Django можно воспользоваться 3 источниками:

• The Python Package Repository (PyPi), при помощи инструмента pip. Это лучший способ получения последней стабильной версии Django.
• Использование версии из менеджера пакетов вашего компьютера. Такие дистрибутивы Django, собранные для конкретных операционных систем, предлагают знакомый механизм установки. Однако обратите внимание на то, что пакетные версии могут быть достаточно старыми и установлены только в системную среду Python (что может отличаться от ваших желаний).
• Установка из исходного кода. Вы можете получить и установить последний выпуск Django из исходного кода. Этот способ не рекомендован для новичков, но необходим в случае, когда вы готовы начать вносить собственный вклад в проект Django.

Данный материал описывает способ установки Django из PyPi с целью получения последней стабильной версии.

Какую базу данных выбрать?

Django поддерживает 4 основных базы данных (PostgreSQL, MySQL, Oracle и SQLite), также есть публичные библиотеки, которые предоставляют разные уровни поддержки других SQL и NoSQL баз данных. Мы рекомендуем вам выбрать одинаковую БД для обеих рабочей и разрабатываемой сред (несмотря на  то, что Django нивелирует множество различий баз данных при помощи Object-Relational Mapper (ORM), всё равно возможны потенциальные проблемы, которых лучше избегать.

Для данной статьи (и большей части модуля) мы будем использовать базу данных SQLite, которая сохраняет свои данные в файл. SQLite предназначен для использования в качестве облегчённой базы данных и не может поддерживать высокий уровень параллелизма. Это, однако, отличный выбор для приложений, которые в основном предназначены только для чтения.

Замечание: Django сконфигурирован для использования SQLite по умолчанию, при создании вашего проекта с использованием стандартных инструментов (django-admin). Это отличный выбор для начала работы, потому что он не требует дополнительной настройки.

Глобальная установка или установка в виртуальную среду Python?

Когда вы устанавливаете Python 3 на свой компьютер, вы получаете единую глобальную среду (набор установленных пакетов) для вашего кода Python, которая доступна любому коду на компьютере. Вы можете установить любые пакеты Python, необходимые вам в этой среде, но только одну конкретную версию конкретного пакета.

Замечание: Установленные в глобальную среду приложения Python потенциально могут конфликтовать друг с другом (т.е. если они зависят от разных версий одного и того же пакета).

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

По этой причине опытные разработчики Python / Django часто предпочитают вместо этого запускать свои приложения Python в независимых виртуальных средах Python. Это позволяет разработчикам иметь несколько разных сред Django на одном компьютере. Команда разработчиков Django сама рекомендует использовать виртуальные среды Python!

Этот модуль предполагает вашу установку Django в виртуальную среду, и мы покажем, как это сделать.

Для использования Django вам необходимо установить Python 3 на свою операционную систему. Вам также понадобится инструмент Python Package Index — pip3 — который используется для управления (установка, обновление и удаление) библиотек/пакетов Python, используемых Django и другими вашими приложениями Python.

Этот раздел коротко описывает то, как вы можете проверить имеющиеся версии и при необходимости установить новые для Ubuntu Linux 16.04, Mac OS X, and Windows 10.

Замечание: В зависимости от платформы, вы можете иметь возможность установки Python/pip из собственного менеджера пакетов операционной системы или при помощи других инструментов. Для большинства платформ вы можете скачать необходимые установочные файлы из https://www.python.org/downloads/ и установить их при помощи соответствующего специфичного для платформы метода.

Ubuntu 16.04

Ubuntu Linux включает в себя Python 3 по умолчанию. Вы можете удостовериться в этом, выполнив следующую команду в терминале:

python3 -V
 Python 3. 5.2

Однако, инструмент Python Package Index, при помощи которого вам нужно будет установить пакеты для  Python 3 (включая Django), по умолчанию не установлен. Вы можете установить pip3 через терминал bash при помощи:

sudo apt-get install python3-pip

Mac OS X

Mac OS X «El Capitan» не включает Python 3. Вы можете удостовериться в этом, выполнив следующую команду в терминале:

python3 -V
 -bash: python3: command not found

Вы можете легко установить Python 3 (вместе с инструментом pip3) с python.org:

1. Скачайте нужный установочный файл:
   1. Перейдите в https://www.python.org/downloads/
   2. Нажмите на кнопку Скачать Python 3.6.4 (точная основная версия может отличаться).
2. Найдите файл при помощи Finder, дважды кликните по нему и следуйте подсказкам по установке.

Удостовериться в успешной установке вы можете проверкой на наличие  Python 3, как показано ниже:

python3 -V
 Python 3. 5.20

Подобным образом вы можете проверить установку pip3, отобразив список доступных пакетов:

pip3 list

Windows 10

Windows не включает Python по умолчанию, но вы можете легко установить его (вместе с инструментом pip) с python.org:

1. Скачайте нужный установочный файл:
   1. Перейдите в https://www.python.org/downloads/
   2. Нажмите на кнопку Скачать Python 3.6.4 (точная основная версия может отличаться).
2. Установите Python, дважды кликнув на скачанный файл и следуя инструкциям по установке.

После этого вы сможете подтвердить успешную установку Python путём выполнения следующего текста в командной строке:

py -3 -V
 Python 3.5.2

Установщик Windows включает в себя pip3 (менеджер пакетов Python) по умолчанию. Вы можете отобразить список установленных пакетов, как показано далее:

pip list

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

Для создания виртуальных сред мы будем использовать библиотеки virtualenvwrapper (Linux и macOS X) и virtualenvwrapper-win (Windows), которые в свою очередь обе используют инструмент virtualenv. Инструмент обёртки предоставляет совместимый интерфейс для управления интерфейсами на всех платформах.

Установка ПО виртуальной среды

Установка виртуальной среды для Ubuntu

После установки Python и pip вы можете установить virtualenvwrapper (который включает в себя virtualenv). Вы можете либо воспользоваться официальной инструкций по установке отсюда, либо следовать следующим инструкциям:

Установите инструмент при помощи pip3:

sudo pip3 install virtualenvwrapper

Затем добавьте следующие строки в конец файла загрузки программной оболочки (shell) (это скрытый файл в вашей домашней директории с именем .bashrc). Они устанавливают расположение виртуальных сред, расположение каталога разрабатываемого проекта и расположение установленного с этим пакетом скрипта.

export WORKON_HOME=$HOME/.virtualenvs
export VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3
export VIRTUALENVWRAPPER_VIRTUALENV_ARGS=' -p /usr/bin/python3 '
export PROJECT_HOME=$HOME/Devel
source /usr/local/bin/virtualenvwrapper.sh

Затем перезагрузите файл загрузки, выполнив в терминале следующую команду:

source ~/.bashrc

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

virtualenvwrapper.user_scripts creating /home/ubuntu/.virtualenvs/premkproject
virtualenvwrapper.user_scripts creating /home/ubuntu/.virtualenvs/postmkproject
...
virtualenvwrapper.user_scripts creating /home/ubuntu/.virtualenvs/preactivate
virtualenvwrapper.user_scripts creating /home/ubuntu/.virtualenvs/postactivate
virtualenvwrapper.user_scripts creating /home/ubuntu/.virtualenvs/get_env_details

Теперь вы можете создать новую виртуальную среду при помощи команды mkvirtualenv.

Установка виртуальной среды для macOS X

Установка virtualenvwrapper на macOS X почти идентична Ubuntu (и снова вы можете воспользоваться либо официальными, либо следующими инструкциями).

Установите инструмент при помощи pip3:

sudo pip3 install virtualenvwrapper

Затем добавьте следующие строки в конец вашего файла загрузки программной оболочки:

export WORKON_HOME=$HOME/.virtualenvs
export VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3
export PROJECT_HOME=$HOME/Devel
source /usr/local/bin/virtualenvwrapper.sh

Замечание: Переменная VIRTUALENVWRAPPER_PYTHON указывает на обычное расположение Python3. Если virtualenv не работает во время тестирования, то вам следует проверить, находится ли интерпретатор Python в нужном расположении (и затем поменять его соответствующим образом в значении переменной).

Эти строки такие же, как в случае с Ubuntu, но файл загрузки в вашей домашней директории назван иначе — .bash_profile. 

Замечание: Если вы не можете найти и изменить .bash_profile при помощи Finder, то можно также открыть его при помощи редактора терминала nano.

Команды в этом случае выглядят примерно так:

cd ~ # Navigate to my home directory
ls -la #List the content of the directory. You should see .bash_profile
nano .bash_profile # Open the file in the nano text editor, within the terminal
# Scroll to the end of the file, and copy in the lines above
# Use Ctrl+X to exit nano, Choose Y to save the file.

После этого перезагрузите файл загрузки путём выполнения следующей команды в терминале:

source ~/.bash_profile

В этот момент вы должны увидеть запуск группы скриптов (те же скрипты, что и в случае установки на Ubuntu).

Теперь вы должны иметь возможность создания новой виртуальной среды при помощи команды mkvirtualenv.

Установка виртуальной среды для Windows 10

Установка virtualenvwrapper-win ещё более проста, чем установка virtualenvwrapper, потому что вам не нужно настраивать расположения сохранения информации о виртуальной среде инструментом (эти значения заданы по умолчанию). Все, что вам нужно сделать, это запустить следующую команду в командной строке:

pip3 install virtualenvwrapper-win

Теперь вы можете создать новую виртуальную среду при помощи команды mkvirtualen.

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

После установки virtualenvwrapper и virtualenvwrapper-win работа с виртуальными средами становится одинаковой для всех платформ.

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

$ mkvirtualenv my_django_environment
Running virtualenv with interpreter /usr/bin/python3 ...
virtualenvwrapper.user_scripts creating /home/ubuntu/.virtualenvs/t_env7/bin/get_env_details
(my_django_environment) ubuntu@ubuntu:~$

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

Замечание: С этого момента в этой статье (и всем модуле) пожалуйста учитывайте, что любые команды запускаются в виртуальной среде Python, как та, что мы показали выше.

Использование виртуальной среды

Есть ещё несколько полезных команд, которые вам следует знать (в документации по инструменту их гораздо больше, но эти вы будете использовать регулярно):

• deactivate — Выход из текущей виртуальной среды Python
• workon — Список доступных виртуальных сред
• workon name_of_environment — Активация конкретной виртуальной среды Python
• rmvirtualenv name_of_environment — Удаление конкретной виртуальной среды.

После создания виртуальной среды и вызова workon для входа в неё вы можете использовать pip3 для установки Django. 

pip3 install django

Вы можете проверить установку Django, выполнив следующую команду (она просто проверяет, что Python может найти модуль Django):

# Linux/Mac OS X
python3 -m django --version
 1.10.10

# Windows
py -3 -m django --version
 1.10.10

Замечание: Для Windows вы запускаете скрипты Python 3 с префиксом команды py -3, в то время как для Linux/Mac OSX префикс — python3.

Важно: В оставшейся части материала используется вариант команды Linux для вызова Python 3 (python3) . Если вы работаете в Windows, то просто замените этот префикс на: py -3

Указанная выше проверка работает, но не представляет особого интереса.Более интересная проверка заключается в создании шаблона проекта и проверки его работы. Для её выполнения перейдите в командной строке/терминале в место, где планируете сохранять приложения Django. Создайте папку для теста и перейдите в неё.

mkdir django_test
cd django_test

Затем вы можете создать шаблон сайта «mytestsite» при помощи инструмента django-admin. После создания сайта вы можете перейти в папку, где найдёте основной скрипт для управления проектами с именем manage.py.

django-admin startproject mytestsite
cd mytestsite

Мы можем запустить веб-сервер разработки из этой папки при помощи manage.py и команды runserver, как показано ниже.

$ python3 manage.py runserver 
Performing system checks...

System check identified no issues (0 silenced).

You have 13 unapplied migration(s). Your project may not work properly until you apply the migrations for app(s): admin, auth, contenttypes, sessions.
Run 'python manage.py migrate' to apply them.

September 19, 2016 - 23:31:14
Django version 1.10.1, using settings 'mysite.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

Замечание: Указанная команда демонстрирует выполнение для Linux/Mac OS X. В настоящий момент вы можете проигнорировать предупреждения о  «13 непримененных миграциях»!

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

Теперь у вас на компьютере установлена и запущена среда разработки Django.

В разделе проверки вам коротко был показан способ создания нового сайта на Django при помощи django-admin startproject и его запуск в вашем браузере при помощи веб-сервера разработки (python3 manage.py runserver). В следующей статье мы подробнее рассмотрим этот процесс создания простого, но полноценного веб-приложения.

Документация Django — Документация Django 3.0

Все, что вам нужно знать о Django.

Первые шаги

Вы новичок в Django или программировании? Вам сюда!

Получение помощи

Проблемы? Мы готовы помочь!

Как организована документация

Документация Django очень обширна. Это описание поможет вам понять как она организована и подскажет где искать необходимую информацию:

• Учебник проведёт вас через ряд шагов для создания веб приложения. Начните с него, если вы новичок в Django или разработке веб-приложений. Также обратите внимание на «Первые шаги».
• Список тем содержит основные концепции и разделы, которые предоставляют базовую информацию для понимания.
• Описание API содержит техническое описание API и других механизмов Django. Рассказывает как работает Django и предполагает, что вы знакомы с базовыми концепциями.
• Практические руководства содержат рецепты. Они описывают как решить конкретные задачи и проблемы. Они более продвинуты чем учебник и предполагают знания Django.

ORM и работа с базой данных

Django предоставляет абстрактный уровень («модели») для создания структуры и управления данными вашего приложения. Прочитать об это вы можете в следующих разделах:

Представления

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

Шаблоны

Шаблоны предоставляют удобный для дизайнера синтаксис для управления отображением информации пользователю. Узнайте как использовать этот синтаксис и как дополнять его:

Формы

Django предоставляет инструмент для создания форм.

Процесс разработки

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

Интерфейс администратора

Узнайте все что вам нужно об интерфейсе администратора, одной из самых популярных особенностей Django:

Безопасность

Безопасность очень важна при разработке веб-приложений и Django предоставляет ряд необходимых инструментов и механизмов:

Интернационализация и локализация

Django позволяет создавать многоязычные приложения:

Производительность и оптимизация

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

Фреймворк геоданных

GeoDjango претендует на место популярного веб-фреймверка для работы с геоданными. Его цель позволить быстро создавать GIS веб-приложения и использовать мощность пространственных данных.

Разные инструменты

Прочитайте про остальные важные инструменты в Django:

Django – проект с открытым исходным кодом

Прочитайте о процессе разработки Django и о том, как вы можете помочь:

Глава 1: DjangoBook по-русски | Django на русском

Данная книга посвящена Django, среде^[1]
WEB^[2] разработки, которая
позволяет сэкономить время и превращает работу в
развлечение. Используя Django, вы можете с минимальными усилиями
создавать и обслуживать высококачественные приложения.

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

Цель данной книги — сделать вас экспертом по Django. Книга
сфокусирована на двух вещах. Первое, мы подробно объясним, как
работает Django и как создавать приложения с её помощью. Второе,
там где это необходимо, мы обсудим высокоуровневую концепцию,
отвечая на вопрос «Как я могу эффективно применять эти инструменты в своих проектах?» Читая эту книгу, вы получите
навыки необходимые для разработки мощных приложений с простым
поддерживаемым кодом.

Что такое среда разработки?

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

Для того, чтобы ответить на этот вопрос давайте рассмотрим
дизайн приложения написанного на языке Python без использования среды разработки. На протяжении всей
книги мы будем использовать данный подход, чтобы показать вам
основные способы выполнить работу без
вспомогательных средств, в надежде, что вы разберётесь почему
эти средства так полезны. Также важно знать как можно решить
задачу на низком уровне, так как высокий уровень
(вспомогательные средства) не всегда доступен. И очень важно то,
что знание почему что-то работает именно
так, а не иначе, делает вас опытнее.

Одним из простых, наиболее прямолинейных способов создать с нуля
вебприложение на языке Python является использование стандарта
Common Gateway Interface (CGI), который был популярен, начиная с
1998 года. Кратко рассмотрим как это работает: создаётся скрипт
на языке Python, который выводит HTML, скрипт сохраняется на веб
сервере в файле с расширением .cgi, затем к
скрипту можно обращаться через веб браузер. Вот и всё.

Ниже приведён простой CGI скрипт, написанный на языке Python,
который отображает десять наиболее свежих книг из базы
данных. Не беспокойтесь о деталях, просто рассмотрите как он
работает:

#!/usr/bin/env python

import MySQLdb

print "Content-Type: text/html"
print
print "<html><head><title>Книги</title></head>"
print "<body>"
print "<h2>Книги</h2>"
print "<ul>"

connection = MySQLdb.connect(user='me', passwd='letmein', db='my_db')
cursor = connection.cursor()
cursor.execute("SELECT name FROM books ORDER BY pub_date DESC LIMIT 10")
for row in cursor.fetchall():
    print "<li>%s</li>" % row[0]

print "</ul>"
print "</body></html>"

connection.close()

Во-первых, согласно требованиям CGI, код выводит строку
«Content-Type», затем пустую строку. Скрипт
выводит необходимые HTML теги, подключается к базе данных и
выполняет запрос для получения имён последних десяти
книг. Обрабатывая результат запроса, скрипт создаёт
ненумерованный список имён. Наконец, скрипт закрывает HTML теги
и закрывает соединение с базой данных.

Для одиночной динамической страницы, подобной этой, методика
«написать всё с нуля» не всегда плоха. Во-первых,
этот код прост для понимания даже неопытным разработчиком и его
легко установить на «боевую»^[3] систему — просто сохранить в
файл с расширением .cgi и зайди браузером.

Но несмотря на свою простоту, данный подход имеет ряд проблем и
недостатков. Задайте себе эти вопросы:

• Что произойдёт, если потребуется обеспечить работу множества компонентов вашего приложения с базой данных? Несомненно, что код для подключения к базе не должен быть скопирован в каждый отдельный CGI скрипт. Придётся вынести этот код в общую библиотеку функций.

• Действительно ли разработчик должен беспокоиться о выводе
  строки «Content-Type» и помнить о
  необходимости закрывать соединение с базой данных? Такие
  вещи снижают производительность разработчика и увеличивают
  вероятность появления ошибок в коде. Такими задачами
  должна заниматься некая общая инфраструктура.

• Что произойдёт, если этот код будет использоваться во множестве сред, каждая со своей базой данных и логином? В этом случае потребуется вводить некоторую конфигурацию, специфичную для среды исполнения.

• Что произойдёт, если дизайнер, который не имеет опыта разработки на языке Python, пожелает поменять вид страницы? Один неверный символ может уронить целое приложение. В идеале, при отображении страницы, логика страницы — получение названий книг из базы данных — должна быть отделена от вывода HTML. В этом случае дизайнер может вносить необходимые изменения в HTML без влияния на всё остальное.

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

Документация Джанго 3.2 — Вся документация Django на русском языке

Все, что вам нужно знать о Django.

Первые шаги ¶

Вы новичок в Django или в программировании? Это место, чтобы начать!

Получение помощи ¶

Возникли проблемы? Хотим помочь!

Как организована документация ¶

У Django много документации. Общий обзор того, как он организован, поможет вам узнать, где искать определенные вещи:

• Учебники проведут вас за руку через серию шагов по созданию веб-приложения. Начните здесь, если вы новичок в разработке Django или веб-приложений. Также посмотрите « Первые шаги ».
• Руководства по темам обсуждают ключевые темы и концепции на довольно высоком уровне и предоставляют полезную справочную информацию и объяснения.
• Справочные руководства содержат технические справочники по API и другим аспектам оборудования Django. Они описывают, как это работает и как его использовать, но предполагают, что у вас есть базовое понимание ключевых понятий.
• Практические руководства — это рецепты. Они проведут вас через шаги, необходимые для решения ключевых проблем и вариантов использования. Они более продвинуты, чем учебники, и предполагают некоторое знание того, как работает Django.

Слой модели ¶

Django предоставляет уровень абстракции («модели») для структурирования и управления данными вашего веб-приложения. Подробнее об этом ниже:

Слой просмотра ¶

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

Слой шаблона ¶

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

Формы ¶

Django предоставляет богатый фреймворк для облегчения создания форм и манипулирования данными форм.

Процесс разработки ¶

Узнайте о различных компонентах и ​​инструментах, которые помогут вам в разработке и тестировании приложений Django:

Админ ¶

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

Безопасность ¶

Безопасность — тема первостепенной важности при разработке веб-приложений, и Django предоставляет несколько инструментов и механизмов защиты:

Интернационализация и локализация ¶

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

Производительность и оптимизация ¶

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

Географические рамки ¶

GeoDjango намерен стать географической веб-платформой мирового класса. Его цель — максимально упростить создание веб-приложений ГИС и использовать всю мощь пространственных данных.

Общие инструменты веб-приложений ¶

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

Другие основные функции ¶

Узнайте о некоторых других основных функциях фреймворка Django:

Проект с открытым исходным кодом Django ¶

Узнайте о процессе разработки самого проекта Django и о том, как вы можете внести свой вклад:

ТОП-5 книг по Django (Python) на русском языке – Библиотека программиста

Просмотров 14.5k.
Обновлено 26.01.2021

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

Django. Адриан Головатый, Джейкоб Каплан-Мосс

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

Издание написано для тех, кто имеет навыки программирования и знаком с принципами Python и веб-разработкой.

Достоинства:

• отлично структурирована;
• радует достаточное количество теории и примеров;
• хорошее качество книги;
• позволяет изучить Django на начальном этапе, а в дальнейшем использовать книгу, как справочник.

Недостатки:

• некачественный перевод;
• некоторая информация уже устаревшая.

Изучаем Python. Эрик Мэтиз

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

Издание отлично подходит для новичков.

Достоинства:

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

Недостатки:

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

Django. Уэсли Чан, Джефф Форсье, Пол Биссекс

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

Авторы делятся секретами использования Django, применяя большое количество примеров и объяснений к ним.

Достоинства:

• понятный стиль написания;
• легко воспринимается информация;
• подробное описание без воды;
• много полезной информации для версии Django 1,0 или 1,2.

Недостатки:

• много устаревшей информации.

Django: практика создания Web-сайтов на Python. Владимир Дронов

Книга создана для того, чтобы научить разрабатывать Web-сайты при помощи библиотеки Django. Здесь детально описываются процессы создания модулей, шаблонов, написание кодов и применение сторонних библиотек. Рассматриваются вопросы администрирования и тестирования сайтов.

Достоинства:

• пошаговые инструкции по разработке веб-сайтов;
• адекватная цена.

Недостатки:

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

Django 2 в примерах. Антонио Меле

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

Достоинства:

• реальные проекты в книге дают прокачать свои навыки;
• понятный стиль подачи материала;
• последовательность излагаемой информации.

Недостатки:

• неточности и ошибки в примерах кода;
• новичкам нужно иметь представления о языке Python.

Выводы

1. Лучшая книга в библиотеке начинающего программиста для старта в изучении Python и Django – «Изучаем Python» Эрик Мэтиз.
2. Лучшее руководство для тех, кто уже имеет навыки программирования – «Django» Адриан Головатый, Джейкоб Каплан-Мосс.
3. «Django 2 в примерах» — подойдет широкому кругу аудитории. Отличная книга для тех, кто хочет освоить работу с Django и узнать новые подходы.

Делитесь хорошими книгами по Django не попавшими в эту подборку в комментариях!

Django Tutorial Part 2: Создание скелета веб-сайта — Изучите веб-разработку

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

В этой статье показано, как создать «каркасный» веб-сайт, который затем можно будет заполнить настройками, путями, моделями, представлениями и шаблонами для конкретного сайта (мы обсудим их в следующих статьях).

Для начала:

1. Используйте инструмент django-admin для создания папки проекта, базовых шаблонов файлов и manage.py , который служит сценарием управления вашим проектом.
2. Используйте manage.py для создания одного или нескольких приложений .

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

3. Зарегистрируйте новые приложения, чтобы включить их в проект.
4. Подключите преобразователь url / path для каждого приложения.

Для веб-сайта локальной библиотеки папки веб-сайта и проекта называются locallibrary и включают одно приложение с именем catalog .
Таким образом, структура папок верхнего уровня будет следующей:

  локальная библиотека /
    manage.py
    locallibrary /
    каталог/
  

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

1. Откройте командную оболочку (или окно терминала) и убедитесь, что вы находитесь в своей виртуальной среде.
2. Перейдите туда, где вы хотите хранить приложения Django (упростите поиск, например, в папке Documents ) и создайте папку для своего нового веб-сайта (в данном случае: django_projects ). Затем перейдите во вновь созданный каталог:

     мкдир django_projects
   компакт-диск django_projects  

3. Создайте новый проект с помощью команды django-admin startproject , как показано, а затем перейдите в папку проекта:

     django-admin startproject locallibrary
   cd locallibrary  

Инструмент django-admin создает структуру папок / файлов следующим образом:

  локальная библиотека /
    управлять.ру
    locallibrary /
        __init__.py
        settings.py
        urls.py
        wsgi.py
        asgi.py  

Наш текущий рабочий каталог должен выглядеть примерно так:

  ../django_projects/locallibrary/  

Подпапка проекта locallibrary является точкой входа на веб-сайт:

• __init__.py — это пустой файл, который указывает Python рассматривать этот каталог как пакет Python.
• настроек.py содержит все настройки веб-сайта, включая регистрацию любых создаваемых нами приложений, расположение наших статических файлов, детали конфигурации базы данных и т. д.
• urls.py определяет сопоставления URL-адресов сайта и просмотра. Хотя это может содержать и код сопоставления URL-адресов, более распространено делегирование некоторых сопоставлений конкретным приложениям, как вы увидите позже.
• wsgi.py используется, чтобы помочь вашему приложению Django взаимодействовать с веб-сервером.Вы можете рассматривать это как шаблон.
• asgi.py — это стандарт для асинхронных веб-приложений и серверов Python для взаимодействия друг с другом. ASGI является асинхронным преемником WSGI и обеспечивает стандарт как для асинхронных, так и для синхронных приложений Python (тогда как WSGI предоставил стандарт только для синхронных приложений). Он обратно совместим с WSGI и поддерживает несколько серверов и платформ приложений.

Сценарий manage.py используется для создания приложений, работы с базами данных и запуска веб-сервера разработки.

Затем выполните следующую команду, чтобы создать приложение каталога , которое будет жить внутри нашего проекта locallibrary . Обязательно запускайте эту команду из той же папки, что и ваш проект manage.py :

  python3 manage.py каталог startapp  

Примечание: Пример команды для Linux / macOS X. В Windows команда должна быть:

py -3 manage.py каталог startapp

Если вы работаете в Windows, замените python3 на py -3 в этом модуле.

Если вы используете Python 3.7.0 или новее, вам следует использовать только py manage.py startapp catalog

Инструмент создает новую папку и заполняет ее файлами для различных частей приложения (показано в следующем примере).
Большинство файлов названы в соответствии с их назначением (например, представления должны храниться в views.py , модели в models.py , тесты в tests.py , конфигурация сайта администрирования в admin.py , регистрация приложения в приложениях.py ) и содержат некоторый минимальный шаблонный код для работы со связанными объектами.

Обновленный каталог проекта теперь должен выглядеть так:

  локальная библиотека /
    manage.py
    locallibrary /
    каталог/
        admin.py
        apps.py
        models.py
        tests.py
        views.py
        __init__.py
        миграции /
  

Вдобавок теперь у нас:

• Папка migrations , используемая для хранения «миграций» — файлов, которые позволяют автоматически обновлять вашу базу данных по мере изменения ваших моделей.
• __init__.py — пустой файл, созданный здесь, чтобы Django / Python распознал папку как пакет Python и позволял вам использовать его объекты в других частях проекта.

Примечание: Вы заметили, чего не хватает в приведенном выше списке файлов? Хотя есть место для ваших представлений и моделей, вам некуда разместить сопоставления URL-адресов, шаблоны и статические файлы. Мы покажем вам, как создавать их в дальнейшем (они нужны не на каждом веб-сайте, но они необходимы в этом примере).

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

Откройте файл настроек проекта, django_projects / locallibrary / locallibrary / settings.py , и найдите определение для списка INSTALLED_APPS . Затем добавьте новую строку в конец списка, как показано ниже:

  INSTALLED_APPS = [
    'джанго.contrib.admin ',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    
    'catalog.apps.CatalogConfig',
]  

В новой строке указывается объект конфигурации приложения ( CatalogConfig ), который был сгенерирован для вас в /locallibrary/catalog/apps.py при создании приложения.

Примечание: Вы заметите, что уже есть много других INSTALLED_APPS (и MIDDLEWARE , далее в файле настроек).Это обеспечивает поддержку сайта администрирования Django и используемых им функций (включая сеансы, аутентификацию и т. Д.).

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

Мы будем использовать базу данных SQLite для этого примера, потому что мы не ожидаем, что потребуется много одновременного доступа к демонстрационной базе данных, и это не требует дополнительной работы для настройки! Вы можете увидеть, как эта база данных настроена в настройках .py :

  БАЗЫ ДАННЫХ = {
    'дефолт': {
        'ДВИГАТЕЛЬ': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}
  

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

Файл settings.py также используется для настройки ряда других параметров, но на этом этапе вы, вероятно, хотите изменить только TIME_ZONE — это должно быть сделано равным строке из стандартного списка времени базы данных tz зоны (столбец TZ в таблице содержит нужные вам значения).Измените значение TIME_ZONE на одну из этих строк, соответствующую вашему часовому поясу, например:

  TIME_ZONE = 'Европа / Лондон'  

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

• СЕКРЕТНЫЙ КЛЮЧ . Это секретный ключ, который используется как часть стратегии безопасности веб-сайта Django. Если вы не защищаете этот код в процессе разработки, вам нужно будет использовать другой код (возможно, прочитанный из переменной среды или файла) при вводе его в производство.
• ОТЛАДКА . Это позволяет отображать журналы отладки при ошибке, а не ответы с кодом состояния HTTP. Это должно быть установлено на False в производстве, поскольку отладочная информация полезна для злоумышленников, но пока мы можем оставить его равным True .

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

Откройте locallibrary / locallibrary / urls.py и обратите внимание на учебный текст, в котором объясняются некоторые способы использования сопоставителя URL-адресов.

  "" "Конфигурация URL-адреса локальной библиотеки

Список urlpatterns направляет URL-адреса в представления. Для получения дополнительной информации см .:
    https://docs.djangoproject.com/en/3.1/topics/http/urls/
Примеры:
Представления функций
    1. Добавьте импорт: из представлений импорта my_app
    2. Добавьте URL-адрес в urlpatterns: path ('', views.home, name = 'home')
Представления на основе классов
    1.Добавить импорт: from other_app.views import Home
    2. Добавьте URL-адрес в urlpatterns: path ('', Home.as_view (), name = 'home')
Включение другого URLconf
    1. Импортируйте функцию include (): из импорта django.urls include, path
    2. Добавьте URL-адрес в urlpatterns: path ('blog /', include ('blog.urls'))
"" "
от администратора импорта django.contrib
из пути импорта django.urls

urlpatterns = [
    путь ('admin /', admin.site.urls),
]
  

Сопоставления URL-адресов управляются с помощью переменной urlpatterns , которая представляет собой список Python из функций path () .Каждая функция path () либо связывает шаблон URL-адреса с конкретным представлением , которое будет отображаться при сопоставлении с шаблоном, либо с другим списком кода тестирования шаблона URL (в этом втором случае шаблон становится «базовым URL «для шаблонов, определенных в целевом модуле). Список urlpatterns изначально определяет одну функцию, которая сопоставляет все URL-адреса с шаблоном admin / с модулем admin.site.urls , который содержит определения сопоставления URL-адресов приложения администрирования.

Примечание: Маршрут в path () — это строка, определяющая шаблон URL для сопоставления. Эта строка может включать именованную переменную (в угловых скобках), например 'каталог / /' . Этот шаблон будет соответствовать URL-адресу типа / catalog / any_chars / и передавать any_chars в представление в виде строки с именем параметра id . Мы обсудим методы путей и шаблоны маршрутов далее в следующих разделах.

Чтобы добавить новый элемент списка в список urlpatterns , добавьте следующие строки в конец файла.Этот новый элемент включает путь () , который перенаправляет запросы с шаблоном catalog / в модуль catalog.urls (файл с относительным URL-адресом catalog / urls.py ).

 
из импорта django.urls включить

urlpatterns + = [
    путь ('catalog /', include ('catalog.urls')),
]

  

Примечание: Обратите внимание, что мы включили строку импорта ( из импорта django.urls, включая ) с кодом, который ее использует (так что легко увидеть, что мы добавили), но обычно включают все ваши строки импорта в верхней части файла Python.

Теперь давайте перенаправим корневой URL нашего сайта (т.е. 127.0.0.1:8000 ) на URL 127.0.0.1:8000/catalog/. Это единственное приложение, которое мы будем использовать в этом проекте. Для этого мы будем использовать специальную функцию просмотра, RedirectView , которая принимает новый относительный URL-адрес для перенаправления на ( / catalog / ) в качестве своего первого аргумента, когда шаблон URL-адреса указан в функции path () совпадает (в данном случае корневой URL).

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

 
из джанго.views.generic импорт RedirectView
urlpatterns + = [
    путь ('', RedirectView.as_view (url = 'catalog /', постоянный = True)),
]
  

Оставьте первый параметр функции пути пустым, чтобы подразумевать ‘/’. Если вы напишете первый параметр как ‘/’, Django выдаст вам следующее предупреждение при запуске сервера разработки:

  Проверка системы выявила некоторые проблемы:

ПРЕДУПРЕЖДЕНИЯ:
?: (urls.W002) Ваш шаблон URL '/' имеет маршрут, начинающийся с '/'.
Удалите эту косую черту, поскольку в ней нет необходимости.Если этот шаблон нацелен в include (), убедитесь, что в шаблоне include () есть завершающий символ '/'.
  

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

Добавьте следующий последний блок в конец файла:

 
из джанго.conf настройки импорта
из django.conf.urls.static статический импорт

urlpatterns + = static (settings.STATIC_URL, document_root = settings.STATIC_ROOT)
  

Примечание: Существует несколько способов расширить список urlpatterns (ранее мы просто добавляли новый элемент списка с помощью оператора + = , чтобы четко разделить старый и новый код). Вместо этого мы могли бы просто включить эту новую карту шаблонов в определение исходного списка:

  urlpatterns = [
    путь ('admin /', admin.site.urls),
    путь ('catalog /', include ('catalog.urls')),
    путь ('', RedirectView.as_view (url = 'catalog /')),
] + static (settings.STATIC_URL, document_root = settings.STATIC_ROOT)
  

В качестве последнего шага создайте файл в папке каталога с именем urls.py и добавьте следующий текст, чтобы определить (пустой) импортированный urlpatterns . Здесь мы будем добавлять наши шаблоны по мере создания приложения.

  из пути импорта django.urls
из . импорт просмотров

urlpatterns = [

]
  

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

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

Выполнение миграции базы данных

Django использует объектно-реляционное сопоставление (ORM) для сопоставления определений моделей в коде Django со структурой данных, используемой базовой базой данных.Когда мы меняем определения нашей модели, Django отслеживает изменения и может создавать сценарии миграции базы данных (в / locallibrary / catalog / migrations / ) для автоматического переноса базовой структуры данных в базе данных в соответствии с моделью.

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

  python3 manage.py makemigrations
python3 manage.py перенести
  

Предупреждение: Вам нужно будет запускать эти команды каждый раз, когда ваши модели изменяются таким образом, что это повлияет на структуру данных, которые необходимо сохранить (включая как добавление, так и удаление моделей целиком и отдельных полей).

Команда makemigrations создает (но не применяется) миграции для всех приложений, установленных в вашем проекте.Вы также можете указать имя приложения, чтобы просто запустить миграцию для одного проекта. Это дает вам возможность проверить код этих миграций, прежде чем они будут применены. Если вы эксперт по Django, вы можете немного подправить их!

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

Примечание. Дополнительную информацию о менее используемых командах миграции см. В разделе «Миграции» (документация Django).

Запуск веб-сайта

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

Примечание: Веб-сервер разработки не является надежным и недостаточно производительным для производственного использования, но это очень простой способ запустить и запустить ваш веб-сайт Django во время разработки, чтобы быстро протестировать его. По умолчанию он будет обслуживать сайт на вашем локальном компьютере ( http: // 127.0.0.1: 8000 /) , но вы также можете указать другие компьютеры в вашей сети для обслуживания. Для получения дополнительной информации см. Django-admin и manage.py: runserver (документы Django).

Запустите веб-сервер разработки , вызвав команду runserver (в том же каталоге, что и manage.py ):

  python3 manage.py runserver

 Выполнение системных проверок ...

 Проверка системы не выявила проблем (0 отключено).
 15 августа 2018 года - 16:11:26
 Django версии 2.1, используя настройки 'locallibrary.settings'
 Запуск сервера разработки по адресу http://127.0.0.1:8000/
 Закройте сервер, нажав CTRL-BREAK.
  

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

Не волнуйтесь! Эта страница с ошибкой является ожидаемой, потому что у нас нет страниц / URL-адресов, определенных в модуле catalog.urls (на который мы перенаправляемся, когда получаем URL-адрес корня сайта).

Примечание: Страница примера демонстрирует замечательную функцию Django — автоматическое ведение журнала отладки. Когда страница не может быть найдена, Django отображает экран ошибки с полезной информацией или любой ошибкой, вызванной кодом. В этом случае мы видим, что предоставленный нами URL не соответствует ни одному из наших шаблонов URL (как указано в списке). Ведение журнала отключено в производственной среде (когда мы размещаем сайт в Интернете), и в этом случае будет отображаться менее информативная, но более удобная для пользователя страница.

На данный момент мы знаем, что Django работает!

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

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

Как вы видели ранее, сопоставление URL-адресов для сайта администратора уже добавлено в URL-адреса проекта .py . Перейдите в область администратора в своем браузере и посмотрите, что произойдет (вы можете вывести правильный URL-адрес из сопоставления).

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

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

Учебник по Python и Django в Visual Studio Code

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

В этом руководстве по Django вы создадите простое приложение Django с тремя страницами, использующими общий базовый шаблон. Вы создаете это приложение в контексте Visual Studio Code, чтобы понять, как работать с Django в терминале, редакторе и отладчике VS Code. В этом руководстве не рассматриваются различные детали самого Django, такие как работа с моделями данных и создание административного интерфейса. Чтобы получить рекомендации по этим аспектам, обратитесь к ссылкам на документацию Django в конце этого руководства.

Завершенный проект кода из этого руководства по Django можно найти на GitHub: python-sample-vscode-django-tutorial.

Если у вас есть какие-либо проблемы, не стесняйтесь сообщать о проблеме для этого руководства в репозиторий документации VS Code.

Предварительные требования

Чтобы успешно пройти это руководство по Django, вы должны выполнить следующие действия (которые являются теми же шагами, что и в общем руководстве по Python):

1. Установите расширение Python.

2. Установите версию Python 3 (для которой написано это руководство).Варианты включают:

   • (Все операционные системы) Загрузка с python.org; обычно используйте кнопку Download Python 3.9.1 , которая появляется первой на странице (или любую другую последнюю версию).
   • (Linux) Встроенная установка Python 3 работает хорошо, но для установки других пакетов Python вы должны запустить sudo apt install python3-pip в терминале.
   • (macOS) Установка через Homebrew на macOS с использованием brew install python3 (системная установка Python на macOS не поддерживается).
   • (Все операционные системы) Загрузка из Anaconda (для анализа данных).

3. В Windows убедитесь, что местоположение вашего интерпретатора Python включено в переменную среды PATH. Вы можете проверить расположение, запустив путь в командной строке. Если папка интерпретатора Python отсутствует, откройте настройки Windows, найдите «среда», выберите Изменить переменные среды для своей учетной записи , затем отредактируйте переменную Path , чтобы включить эту папку.

Создание среды проекта для учебника Django

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

1. В файловой системе создайте папку проекта для этого руководства, например hello_django .

2. В этой папке используйте следующую команду (в зависимости от вашего компьютера), чтобы создать виртуальную среду с именем env на основе вашего текущего интерпретатора:

     # Linux
   sudo apt-get install python3-venv # При необходимости
   python3 -m venv env
   
   # macOS
   python3 -m venv env
   
   # Windows
   python -m venv env  

   Примечание : Используйте стандартную установку Python при выполнении вышеуказанных команд.Если вы используете python.exe из установки Anaconda, вы увидите ошибку, потому что модуль surepip недоступен, а среда остается в незавершенном состоянии.

3. Откройте папку проекта в VS Code, запустив код . или запустив VS Code и используя команду File > Open Folder .

4. В VS Code откройте палитру команд ( View > Command Palette или (⇧⌘P (Windows, Linux Ctrl + Shift + P))).Затем выберите Python: Select Interpreter command:

5. Команда представляет список доступных интерпретаторов, которые VS Code может найти автоматически (ваш список будет другим; если вы не видите нужный интерпретатор, см. Настройка сред Python). В списке выберите виртуальную среду в папке проекта, которая начинается с ./env или . \ Env :

   .

6. Запустите терминал : создайте новый интегрированный терминал (⌃⇧` (Windows, Linux Ctrl + Shift + `)) из палитры команд, которая создает терминал и автоматически активирует виртуальную среду, запустив его сценарий активации.

   Примечание : Если в Windows используется тип терминала по умолчанию PowerShell, может появиться сообщение об ошибке, что не удается запустить activate.ps1, поскольку выполнение сценариев отключено в системе. Ошибка содержит ссылку на информацию о том, как разрешить скрипты. В противном случае используйте терминал : выберите «Оболочка по умолчанию », чтобы вместо этого установить «Командную строку» или «Git Bash» по умолчанию.

7. Выбранная среда появится в левой части строки состояния VS Code и обратите внимание на индикатор «(venv)», который сообщает вам, что вы используете виртуальную среду:

8. Обновите pip в виртуальной среде, выполнив следующую команду в VS Code Terminal:

     python -m pip install --upgrade pip  

9. Установите Django в виртуальной среде, выполнив следующую команду в VS Code Terminal:

     python -m pip install django  

Теперь у вас есть автономная среда, готовая для написания кода Django.VS Code активирует среду автоматически, когда вы используете Terminal: Create New Integrated Terminal (⌃⇧` (Windows, Linux Ctrl + Shift + `)). Если вы откроете отдельную командную строку или терминал, активируйте среду, запустив исходный код env / bin / activate (Linux / macOS) или env \ Scripts \ Activate.ps1 (Windows). Вы знаете, что среда активируется, когда в начале командной строки отображается (env) .

Создание и запуск минимального приложения Django

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

Чтобы создать минимальное приложение Django, необходимо сначала создать проект Django, который будет служить контейнером для приложения, а затем создать само приложение. Для обеих целей вы используете административную утилиту Django, django-admin , которая устанавливается при установке пакета Django.

Создайте проект Django

1. В терминале VS Code, где активирована ваша виртуальная среда, выполните следующую команду:

     django-admin startproject web_project.  

   Эта команда startproject предполагает (используя . в конце), что текущая папка является папкой вашего проекта, и создает в ней следующее:

   • manage.py : служебная программа командной строки Django для администрирования проекта.Вы запускаете административные команды для проекта, используя python manage.py [options] .

   • Подпапка с именем web_project , которая содержит следующие файлы:

     • __init__.py : пустой файл, который сообщает Python, что эта папка является пакетом Python.
     • asgi.py : точка входа для ASGI-совместимых веб-серверов для обслуживания вашего проекта. Обычно вы оставляете этот файл как есть, поскольку он обеспечивает перехватчики для производственных веб-серверов.
     • settings.py : содержит настройки для проекта Django, которые вы изменяете в процессе разработки веб-приложения.
     • urls.py : содержит оглавление проекта Django, которое вы также изменяете в процессе разработки.
     • wsgi.py : точка входа для WSGI-совместимых веб-серверов для обслуживания вашего проекта. Обычно вы оставляете этот файл как есть, поскольку он обеспечивает перехватчики для производственных веб-серверов.

2. Создайте пустую базу данных разработки, выполнив следующую команду:

     управление питоном.py migrate  

   Когда вы запускаете сервер в первый раз, он создает базу данных SQLite по умолчанию в файле db.sqlite3 , которая предназначена для целей разработки, но может использоваться в производственной среде для небольших веб-приложений. Дополнительные сведения о базах данных см. В разделе Типы баз данных.

3. Чтобы проверить проект Django, убедитесь, что ваша виртуальная среда активирована, затем запустите сервер разработки Django с помощью команды python manage.py runserver . Сервер работает на порту по умолчанию 8000, и вы видите вывод, подобный следующему, в окне терминала:

     Проверка системы ...
   
   Проверка системы не выявила проблем (0 отключено).
   
   15 января 2021 - 14:33:31
   Django версии 3.1.5, используя настройки web_project.settings
   Запуск сервера разработки по адресу http://127.0.0.1:8000/
   Закройте сервер, нажав CTRL-BREAK.
     

   Встроенный веб-сервер Django предназначен только для локальной разработки.Однако при развертывании на веб-хосте Django вместо этого использует веб-сервер хоста. Модули wsgi.py и asgi.py в проекте Django заботятся о подключении к производственным серверам.

   Если вы хотите использовать порт, отличный от порта по умолчанию 8000, укажите номер порта в командной строке, например python manage.py runserver 5000 .

4. Ctrl + щелкните URL-адрес http://127.0.0.1:8000/ в окне вывода терминала, чтобы открыть браузер по умолчанию для этого адреса.Если Django установлен правильно и проект действителен, вы увидите страницу по умолчанию, показанную ниже. В окне вывода терминала VS Code также отображается журнал сервера.

5. Когда вы закончите, закройте окно браузера и остановите сервер в VS Code, используя Ctrl + C, как указано в окне вывода терминала.

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

1. В VS Code Terminal с активированной виртуальной средой запустите команду startapp административной утилиты в папке проекта (где manage.py проживает):

     python manage.py startapp привет  

   Команда создает папку с именем hello , которая содержит несколько файлов кода и одну подпапку. Из них вы часто работаете с views.py (который содержит функции, которые определяют страницы в вашем веб-приложении) и models.py (который содержит классы, определяющие ваши объекты данных). Папка migrations используется административной утилитой Django для управления версиями базы данных, как описано далее в этом руководстве.Также существуют файлы apps.py (конфигурация приложения), admin.py (для создания административного интерфейса) и tests.py (для создания тестов), которые здесь не рассматриваются.

2. Измените hello / views.py в соответствии со следующим кодом, который создает единое представление для домашней страницы приложения:

     из django.http import HttpResponse
   
   def home (запрос):
       return HttpResponse ("Привет, Джанго!")  

3. Создайте файл hello / urls.py , с содержанием ниже. В файле urls.py вы указываете шаблоны для маршрутизации различных URL-адресов в соответствующие представления. В приведенном ниже коде содержится один маршрут для сопоставления корневого URL-адреса приложения ( "" ) с функцией views.home , которую вы только что добавили в hello / views.py :

     из пути импорта django.urls
   из привет импорта просмотров
   
   urlpatterns = [
       путь ("", views.home, name = "home"),
   ]  

4. Папка web_project также содержит ссылки .py , в котором фактически обрабатывается маршрутизация URL. Откройте web_project / urls.py и измените его, чтобы он соответствовал следующему коду (вы можете сохранить поучительные комментарии, если хотите). Этот код извлекает из приложения hello / urls.py , используя django.urls.include , который сохраняет маршруты приложения, содержащиеся в приложении. Это разделение полезно, когда проект содержит несколько приложений.

     от администратора импорта django.contrib
   из импорта django.urls, путь
   
   urlpatterns = [
       путь ("", include ("привет.URL-адреса ")),
       путь ('admin /', admin.site.urls)
   ]  

5. Сохранить все измененные файлы.

6. В терминале VS Code Terminal, снова с активированной виртуальной средой, запустите сервер разработки с python manage.py runserver и откройте в браузере http://127.0.0.1:8000/ , чтобы увидеть страницу, которая отображает » Привет, Джанго «.

Создать профиль запуска отладчика

Вы, наверное, уже задаетесь вопросом, есть ли более простой способ запустить сервер и протестировать приложение, не набирая python manage.py runserver каждый раз. К счастью, есть! Вы можете создать индивидуальный профиль запуска в VS Code, который также используется для неизбежной отладки.

1. Переключитесь на Запустите представление в VS Code (с помощью левой панели активности или F5). Вы можете увидеть сообщение «Чтобы настроить запуск и отладку, создайте файл launch.json». Это означает, что у вас еще нет файла launch.json , содержащего конфигурации отладки. VS Code может создать это за вас, если вы нажмете на создать запуск.json файл ссылка:

2. Выберите ссылку, и VS Code запросит конфигурацию отладки. Выберите Django из раскрывающегося списка, и VS Code заполнит новый файл launch.json с конфигурацией запуска Django. Файл launch.json содержит ряд конфигураций отладки, каждая из которых представляет собой отдельный объект JSON в массиве конфигурации .

3. Прокрутите вниз и изучите конфигурацию с именем «Python: Django»:

     {
       "name": "Python: Django",
       "тип": "питон",
       "запрос": "запуск",
       "программа": "$ {workspaceFolder} / manage.ру ",
       "аргументы": [
           "сервер запуска",
       ],
       "джанго": правда
   },  

   Эта конфигурация указывает VS Code запустить "$ {workspaceFolder} /manage.py" с использованием выбранного интерпретатора Python и аргументов в списке args . Таким образом, запуск отладчика VS Code с этой конфигурацией аналогичен запуску python manage.py runserver в терминале VS Code с вашей активированной виртуальной средой. (При желании вы можете добавить номер порта, например "5000" к args .) Запись "django": true также сообщает VS Code включить отладку шаблонов страниц Django, что вы увидите позже в этом руководстве.

4. Протестируйте конфигурацию, выбрав команду меню Запустить > Начать отладку или нажав зеленую стрелку Начать отладку рядом со списком (F5):

5. Ctrl + щелкните URL-адрес http://127.0.0.1:8000/ в окне вывода терминала, чтобы открыть браузер и убедиться, что приложение работает правильно.

6. Закройте браузер и остановите отладчик, когда закончите. Чтобы остановить отладчик, используйте кнопку «Остановить» на панели инструментов (красный квадрат) или команду Выполнить > Остановить отладку (⇧F5 (Windows, Linux Shift + F5)).

7. Теперь вы можете использовать команду Run > Start Debugging в любое время для тестирования приложения, которое также имеет преимущество автоматического сохранения всех измененных файлов.

Изучить отладчик

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

Перед тем, как начать : Убедитесь, что вы остановили работающее приложение в конце последнего раздела, нажав Ctrl + C в терминале. Если вы оставите приложение запущенным на одном терминале, оно продолжит владеть портом. В результате, когда вы запускаете приложение в отладчике, используя тот же порт, исходное запущенное приложение обрабатывает все запросы, и вы не увидите никаких действий в отлаживаемом приложении, и программа не остановится на точках останова.Другими словами, если отладчик не работает, убедитесь, что никакой другой экземпляр приложения еще не запущен.

1. В hello / urls.py добавьте маршрут в список urlpatterns :

     путь ("hello / ", views.hello_there, name = "hello_there"),  

   Первый аргумент path определяет маршрут «hello /», который принимает переменную строку с именем name . Строка передается в представления .Функция hello_there , указанная во втором аргументе пути .

   URL-адреса чувствительны к регистру. Например, маршрут / hello / отличается от / Hello / . Если вы хотите, чтобы одна и та же функция просмотра обрабатывала оба варианта, определите пути для каждого варианта.

2. Замените содержимое views.py следующим кодом, чтобы определить функцию hello_there , которую можно выполнить в отладчике:

     импорт ре
   из джанго.utils.timezone импорт datetime
   из django.http import HttpResponse
   
   def home (запрос):
       return HttpResponse ("Привет, Django!")
   
   def hello_there (запрос, имя):
       сейчас = datetime.now ()
       formatted_now = now.strftime ("% A,% d% B,% Y в% X")
   
       # Отфильтруйте аргумент имени по буквам, используя только регулярные выражения. Аргументы URL
       # может содержать произвольный текст, поэтому мы ограничиваемся только безопасными символами.
       match_object = re.match ("[a-zA-Z] +", имя)
   
       если match_object:
           clean_name = match_object.группа (0)
       еще:
           clean_name = "Друг"
   
       content = "Здравствуйте," + clean_name + "! Это" + formatted_now
       возврат HttpResponse (контент)  

   Имя , переменная , определенная в URL-маршруте, передается в качестве аргумента функции hello_there . Как описано в комментариях к коду, всегда фильтруйте произвольную информацию, предоставленную пользователем, чтобы избежать различных атак на ваше приложение. В этом случае код фильтрует аргумент имени, чтобы он содержал только буквы, что позволяет избежать внедрения управляющих символов, HTML и т. Д.(Когда вы используете шаблоны в следующем разделе, Django выполняет автоматическую фильтрацию, и вам не нужен этот код.)

3. Установите точку останова в первой строке кода в функции hello_there ( now = datetime.now () ), выполнив одно из следующих действий:

   • Наведя курсор на эту строку, нажмите F9, или,
   • Наведите курсор на эту строку и выберите команду меню Run > Toggle Breakpoint , или
   • Щелкните прямо на поле слева от номера строки (при наведении курсора появляется блеклая красная точка).

   Точка останова отображается в виде красной точки на левом поле:

4. Запустите отладчик, выбрав команду меню Выполнить > Начать отладку или нажав зеленую стрелку Начать отладку рядом со списком (F5):

   Обратите внимание, что строка состояния меняет цвет, указывая на отладку:

   Панель инструментов отладки (показанная ниже) также появляется в VS Code, содержащая команды в следующем порядке: Пауза (или Продолжить, F5), Step Over (F10), Step Into (F11), Step Out (⇧F11 (Windows, Linux Shift + F11)), перезапуск (⇧⌘F5 (Windows, Linux Ctrl + Shift + F5)) и Стоп (⇧F5 (Windows, Linux Shift + F5)).См. Раздел «Отладка кода VS» для описания каждой команды.

5. Вывод отображается в терминале «Консоль отладки Python». Откройте браузер и перейдите к http://127.0.0.1:8000/hello/VSCode . Перед отрисовкой страницы VS Code приостанавливает выполнение программы в установленной вами точке останова. Маленькая желтая стрелка на точке останова указывает, что это следующая строка кода, которую нужно запустить.

6. Используйте Step Over, чтобы запустить now = datetime.now () заявление.

7. В левой части окна VS Code вы видите панель Variables , которая показывает локальные переменные, такие как теперь , а также аргументы, такие как name . Ниже приведены панели для Watch , Call Stack и Breakpoints (подробности см. В разделе «Отладка кода VS»). В разделе Locals попробуйте расширить различные значения. Вы также можете дважды щелкнуть значения (или использовать Enter (Windows, Linux F2)), чтобы изменить их.Однако изменение переменных, таких как теперь , может нарушить работу программы. Разработчики обычно вносят изменения только в правильные значения, когда код изначально не дал правильного значения.

8. Когда программа приостановлена, панель Debug Console (которая отличается от «Консоли отладки Python» на панели Терминала) позволяет вам экспериментировать с выражениями и опробовать фрагменты кода, используя текущее состояние программы.Например, перешагнув строку now = datetime.now () , вы можете поэкспериментировать с разными форматами даты и времени. В редакторе выберите код, который читает now.strftime («% A,% d% B,% Y at% X») , затем щелкните правой кнопкой мыши и выберите Debug: Evaluate , чтобы отправить этот код в отладку. консоль, на которой работает:

     now.strftime ("% A,% d% B,% Y at% X")
   'Пятница, 07 сентября 2018 г., 07:46:32'  

   Совет : Консоль отладки также показывает исключения из приложения, которые могут не отображаться в терминале.Например, если вы видите сообщение «Приостановлено при исключении» в области Call Stack представления Run, переключитесь на Debug Console , чтобы увидеть сообщение об исключении.

9. Скопируйте эту строку в приглашение> в нижней части консоли отладки и попробуйте изменить форматирование:

     now.strftime ("% a,% d% B,% Y at% X")
   'Пт, 07 сентября, 2018 в 07:46:32'
   now.strftime ("% a,% d% b,% Y в% X")
   'Пт, 07 сен, 2018 в 07:46:32'
   Теперь.strftime ("% a,% d% b,% y в% X")
   'Пт, 07 сен, 18, в 07:46:32'  

   Примечание : Если вы видите изменение, которое вам нравится, вы можете скопировать и вставить его в редактор во время сеанса отладки. Однако эти изменения не применяются, пока вы не перезапустите отладчик.

10. Выполните еще несколько строк кода, если хотите, затем выберите «Продолжить» (F5), чтобы запустить программу. В окне браузера отображается результат:

11. Закройте браузер и остановите отладчик, когда закончите.Чтобы остановить отладчик, используйте кнопку «Остановить» на панели инструментов (красный квадрат) или команду Выполнить > Остановить отладку (⇧F5 (Windows, Linux Shift + F5)).

Совет : Чтобы упростить многократный переход к определенному URL-адресу, например http://127.0.0.1:8000/hello/VSCode , выведите этот URL-адрес с помощью оператора print где-нибудь в файле, например, views. py . URL-адрес отображается в терминале VS Code, где вы можете использовать Ctrl + щелчок, чтобы открыть его в браузере.

Команды «Перейти к определению» и «Просмотр определения»

Во время работы с Django или любой другой библиотекой вы можете захотеть изучить код в самих этих библиотеках. VS Code предоставляет две удобные команды, которые переходят непосредственно к определениям классов и других объектов в любом коде:

• Перейти к определению переходит из вашего кода в код, определяющий объект. Например, в views.py щелкните правой кнопкой мыши HttpResponse в функции home и выберите Go to Definition (или используйте F12), чтобы перейти к определению класса в библиотеке Django.

• Peek Definition (⌥F12 (Windows Alt + F12, Linux Ctrl + Shift + F10), также в контекстном меню, вызываемом правой кнопкой мыши), аналогично, но отображает определение класса непосредственно в редакторе (освобождая место в редакторе). окно, чтобы избежать скрытия кода). Нажмите Escape, чтобы закрыть окно Peek, или используйте x в правом верхнем углу.

Используйте шаблон для рендеринга страницы

Приложение, которое вы создали в этом руководстве, генерирует только текстовые веб-страницы из кода Python.Хотя можно сгенерировать HTML прямо в коде, разработчики избегают такой практики, поскольку она открывает приложение для атак с использованием межсайтовых сценариев (XSS). Например, в функции hello_there этого руководства можно было бы подумать о форматировании вывода в коде, например, content = "

Hello there," + clean_name + "!

, где результат в содержимое передается непосредственно в браузер. Это открытие позволяет злоумышленнику разместить вредоносный HTML, включая код JavaScript, в URL-адресе, который заканчивается в clean_name и, таким образом, запускается в браузере.

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

В Django шаблон - это HTML-файл, содержащий заполнители для значений, которые код предоставляет во время выполнения. Затем механизм шаблонов Django позаботится о заменах при рендеринге страницы и обеспечит автоматическое экранирование для предотвращения атак XSS (то есть, если вы попытаетесь использовать HTML в значении данных, вы увидите, что HTML отображается только как простой текст).Таким образом, код касается только значений данных, а шаблон касается только разметки. Шаблоны Django предоставляют гибкие возможности, такие как наследование шаблонов, которое позволяет вам определять базовую страницу с общей разметкой, а затем строить на этой основе добавления для конкретных страниц.

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

1. В файле web_project / settings.py найдите список INSTALLED_APPS и добавьте следующую запись, которая гарантирует, что проект знает о приложении и может обрабатывать шаблоны:

     привет,  

2. Внутри папки hello создайте папку с именем templates , а затем еще одну подпапку с именем hello в соответствии с именем приложения (эта двухуровневая структура папок является типичным соглашением Django).

3. В папке templates / hello создайте файл с именем hello_there.html со следующим содержимым. Этот шаблон содержит два заполнителя для значений данных с именами «имя» и «дата», которые обозначены парами фигурных скобок: {{ и }} . Весь остальной неизменный текст является частью шаблона вместе с разметкой форматирования (например, ). Как видите, заполнители шаблонов также могут включать форматирование, выражения после вертикальной черты | символов, в данном случае с использованием встроенного фильтра даты и времени Django.Затем коду необходимо передать значение datetime , а не предварительно отформатированную строку:

     
   
       
           
           
       
       
            Здравствуйте, {{name}}!  Это {{date | date: "l, d F, Y"}} в {{date | время: "H: i: s"}} 
     

4. Вверху просмотров.py , добавьте следующий оператор импорта:

     из django.shortcuts import render  

5. Также в views.py измените функцию hello_there , чтобы использовать метод django.shortcuts.render для загрузки шаблона и предоставить контекст шаблона . Контекст - это набор переменных для использования в шаблоне. Функция render принимает объект запроса, за которым следует путь к шаблону относительно папки шаблонов , затем объект контекста.(Разработчики обычно называют шаблоны так же, как и функции, которые их используют, но совпадающие имена не требуются, потому что вы всегда ссылаетесь на точное имя файла в своем коде.)

     def hello_there (запрос, имя):
       вернуть рендер (
           запрос,
           'hello / hello_there.html',
           {
               'name': имя,
               'дата': datetime.now ()
           }
       )  

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

6. Запустите программу (внутри или вне отладчика, используя ⌃F5 (Windows, Linux Ctrl + F5)), перейдите к URL-адресу / hello / name и просмотрите результаты.

7. Также попробуйте перейти к URL-адресу / hello / name, используя имя типа , чтобы увидеть автоматическое экранирование Django на работе. Значение «name» отображается в браузере как обычный текст, а не как отображение фактического элемента.

Обслуживать статические файлы

Статические файлы — это фрагменты содержимого, которые ваше веб-приложение возвращает как есть для определенных запросов, например файлы CSS.Для обслуживания статических файлов необходимо, чтобы список INSTALLED_APPS в settings.py содержал django.contrib.staticfiles , который включен по умолчанию.

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

В производстве вам также необходимо установить DEBUG = False в settings.py , что требует дополнительной работы при использовании контейнеров. Подробности см. В выпуске 13.

Подготовьте приложение для статических файлов

1. В проект web_project / urls.py добавьте следующий оператор import :

     из django.contrib.staticfiles.urls импорт staticfiles_urlpatterns  

2. В том же файле добавьте в конце следующую строку, которая включает стандартные статические URL-адреса файлов в список, который распознает проект:

     urlpatterns + = staticfiles_urlpatterns ()  

Ссылка на статические файлы в шаблоне

1. В папке hello создайте папку с именем static .

2. В папке static создайте подпапку с именем hello , соответствующую имени приложения.

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

3. В папке static / hello создайте файл с именем site.css со следующим содержимым. После ввода этого кода также обратите внимание на выделение синтаксиса, которое VS Code предоставляет для файлов CSS, включая предварительный просмотр цвета.

     .message {
       font-weight: 600;
       цвет синий;
   }  

4. В шаблоне / hello / hello_there.html добавьте следующие строки после элемента {% load static%}

   Главная страница О программе Связаться
   {% блокировать содержание%} {% endblock%} <час /> <нижний колонтитул>

   © 2018

5. Добавьте следующие стили в static / hello / site.css под существующим стилем «сообщения» и сохраните файл. (Это пошаговое руководство не пытается продемонстрировать адаптивный дизайн; эти стили просто дают достаточно интересный результат.)

     .navbar {
       цвет фона: светлый серый;
       размер шрифта: 1em;
       семейство шрифтов: Trebuchet MS, Lucida Sans Unicode, Lucida Grande, Lucida Sans, Arial, без засечек;
       цвет белый;
       отступ: 8px 5px 8px 5px;
   }
   
   .navbar a {
       текстовое оформление: нет;
       цвет: наследовать;
   }
   
   .navbar-brand {
       размер шрифта: 1.2em;
       font-weight: 600;
   }
   
   .navbar-item {
       вариант шрифта: капители;
       маржа слева: 30 пикселей;
   }
   
   .body-content {
       отступ: 5 пикселей;
       семейство шрифтов: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
   }  

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

Создать фрагмент кода

Поскольку три страницы, которые вы создаете в следующем разделе, расширяют layout.html , экономится время на создание фрагмента кода для инициализации нового файла шаблона с соответствующей ссылкой на базовый шаблон. Фрагмент кода предоставляет согласованный фрагмент кода из единого источника, что позволяет избежать ошибок, которые могут закрасться при использовании копирования и вставки из существующего кода.

1. В VS Code выберите меню File (Windows / Linux) или Code (macOS), затем выберите Preferences > User snippets .

2. В появившемся списке выберите html . (Параметр может отображаться как «html.json» в разделе «Существующие фрагменты » списка, если фрагменты были созданы ранее.)

3. После открытия кода VS html.json добавьте приведенный ниже код в существующие фигурные скобки. (Пояснительные комментарии, которые здесь не показаны, описывают такие детали, как то, как строка $ 0 указывает, где VS Code помещает курсор после вставки фрагмента):

     "Учебник по Django: макет расширения шаблона.html ": {
       "префикс": "djextlayout",
       "тело": [
           "{% extends \" hello / layout.html \ "%}",
           "{% block title%}",
           «$ 0»,
           "{% endblock%}",
           "{% блокировать содержание%}",
           "{% endblock%}"
       ],
   
       "description": "Шаблон шаблона, расширяющий layout.html"
   },  

4. Сохраните файл html.json (⌘S (Windows, Linux Ctrl + S)).

5. Теперь, когда вы начинаете вводить префикс фрагмента, например djext , VS Code предоставляет фрагмент в качестве опции автозаполнения, как показано в следующем разделе.Вы также можете использовать команду Insert Snippet , чтобы выбрать фрагмент из меню.

Дополнительные сведения о фрагментах кода в целом см. В разделе Создание фрагментов.

Используйте фрагмент кода для добавления страниц

Имея фрагмент кода, вы можете быстро создавать шаблоны для страниц Home, About и Contact.

1. В папке templates / hello создайте новый файл с именем home.html , затем начните вводить djext , чтобы увидеть, как фрагмент отображается как завершение:

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

2. В точке вставки в блоке «заголовок» напишите Home , а в блоке «content» напишите

   Домашняя страница для учебника Visual Studio Code Django.

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

3. В папке templates / hello создайте about.html , используйте фрагмент, чтобы вставить стандартную разметку, вставьте О нас и

   Страница «О нас» для учебника Visual Studio Code Django.

   в блоках «title» и «content» соответственно, затем сохраните файл.

4. Повторите предыдущий шаг, чтобы создать шаблоны / hello / contact.html с использованием Свяжитесь с нами и

   Контактная страница для руководства по Visual Studio Code Django.

   .

5. В приложении urls.py добавьте маршруты для страниц / about и / contact. Помните, что name аргумент функции path определяет имя, с которым вы ссылаетесь на страницу в тегах {% url%} в шаблонах.

     путь ("about /", views.about, name = "about"),
   путь ("контакт /", просмотров.contact, name = "contact"),  

6. В views.py добавьте функции для маршрутов / about и / contact, которые ссылаются на соответствующие шаблоны страниц. Также измените функцию home , чтобы использовать шаблон home.html .

     # Заменить существующую домашнюю функцию на приведенную ниже
   def home (запрос):
       возврат рендера (запрос, "hello / home.html")
   
   def about (запрос):
       возврат рендера (запрос, "привет / о.html ")
   
   def контакт (запрос):
       возврат рендера (запрос, "hello / contact.html")  

Запустить приложение

Установив все шаблоны страниц, сохраните views.py , запустите приложение и откройте в браузере домашнюю страницу, чтобы увидеть результаты. Перемещайтесь между страницами, чтобы убедиться, что шаблоны страниц правильно расширяют базовый шаблон.

Работа с данными, моделями данных и миграциями

Многие веб-приложения работают с информацией, хранящейся в базе данных, и Django упрощает представление объектов в этой базе данных с помощью моделей .В Django модель — это класс Python, производный от django.db.models.Model , который представляет определенный объект базы данных, обычно таблицу. Вы помещаете эти классы в файл models.py приложения.

С Django вы работаете с базой данных почти исключительно через модели, которые вы определяете в коде. Затем «миграции» Django автоматически обрабатывают все детали базовой базы данных по мере того, как вы развиваете модели с течением времени. Общий рабочий процесс выглядит следующим образом:

1. Внесите изменения в модели своих моделей .py файл.
2. Запустите python manage.py makemigrations , чтобы сгенерировать сценарии в папке migrations , которые переносят базу данных из текущего состояния в новое состояние.
3. Запустите python manage.py migrate , чтобы применить сценарии к реальной базе данных.

Сценарии миграции эффективно записывают все инкрементальные изменения, которые вы вносите в свои модели данных с течением времени. Применяя миграции, Django обновляет базу данных в соответствии с вашими моделями.Поскольку каждое инкрементное изменение имеет свой собственный сценарий, Django может автоматически перенести любую предыдущую версию базы данных (включая новую базу данных) в текущую версию. В результате вам нужно беспокоиться только о своих моделях в models.py , а не о базовой схеме базы данных или сценариях миграции. Вы позволите Django сделать это!

В коде вы также работаете исключительно со своими классами модели для хранения и извлечения данных; Django обрабатывает основные детали.Единственным исключением является то, что вы можете записывать данные в свою базу данных с помощью команды loaddata административной утилиты Django. Эта утилита часто используется для инициализации набора данных после того, как команда migrate инициализировала схему.

При использовании файла db.sqlite3 вы также можете работать напрямую с базой данных, используя такой инструмент, как браузер SQLite. Можно добавлять или удалять записи в таблицах с помощью такого инструмента, но избегайте внесения изменений в схему базы данных, поскольку в этом случае база данных не будет синхронизирована с моделями вашего приложения.Вместо этого измените модели, запустите makemigrations , затем запустите migrate .

Типы баз данных

По умолчанию Django включает файл db.sqlite3 для базы данных приложения, которая подходит для разработки. Как описано в разделе «Когда использовать SQLite» (sqlite.org), SQLite отлично работает для сайтов с низким и средним трафиком с менее 100 тыс. Обращений в день, но не рекомендуется для больших объемов. Он также ограничен одним компьютером, поэтому его нельзя использовать в любом сценарии с несколькими серверами, например, для балансировки нагрузки и георепликации.

По этим причинам рассмотрите возможность использования хранилища данных производственного уровня, такого как PostgreSQL, MySQL и SQL Server. Для получения информации о поддержке Django других баз данных см. Настройка базы данных. Вы также можете использовать Azure SDK для Python для работы со службами хранения Azure, такими как таблицы и большие двоичные объекты.

Определить модели

Модель Django — это снова класс Python, производный от django.db.model.Models , который вы помещаете в файл models.py приложения. В базе данных каждой модели автоматически присваивается уникальный идентификатор поля с именем id .Все остальные поля определены как свойства класса с использованием типов из django.db.models , таких как CharField (ограниченный текст), TextField (неограниченный текст), EmailField , URLField , IntegerField , Десятичное поле , Логическое поле . DateTimeField , ForeignKey и ManyToMany и другие. (Подробности см. В справочнике по полю Model в документации Django.)

Каждое поле принимает некоторые атрибуты, например max_length .Атрибут blank = True означает, что поле является необязательным; null = true означает, что значение не является обязательным. Существует также атрибут choices , который ограничивает значения значениями в массиве кортежей значений данных / отображаемых значений.

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

  из моделей импорта django.db
из django.utils импортировать часовой пояс

класс LogMessage (models.Модель):
    message = models.CharField (max_length = 300)
    log_date = models.DateTimeField ("дата регистрации")

    def __str __ (сам):
        "" "Возвращает строковое представление сообщения." ""
        дата = timezone.localtime (self.log_date)
        return f "'{self.message}' зарегистрирован {date.strftime ('% A,% d% B,% Y at% X')}"  

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

Перенести базу данных

Поскольку вы изменили свои модели данных, отредактировав models.py , вам необходимо обновить саму базу данных. В VS Code откройте терминал с активированной виртуальной средой (используйте команду Terminal: Create New Integrated Terminal , ⌃⇧` (Windows, Linux Ctrl + Shift + `))), перейдите в папку проекта и выполните следующее команды:

  python manage.py makemigrations
python manage.py миграция  

Загляните в папку migrations , чтобы увидеть сценарии, которые генерирует программа makemigrations .Вы также можете посмотреть на саму базу данных, чтобы увидеть, что схема обновлена.

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

Используйте базу данных по моделям

Установив модели и перенеся базу данных, вы можете сохранять и извлекать данные, используя только свои модели. В этом разделе вы добавляете в приложение страницу формы, с помощью которой вы можете регистрировать сообщение.Затем вы изменяете домашнюю страницу для отображения этих сообщений. Поскольку вы изменяете здесь много файлов кода, помните о деталях.

1. В папке hello (где у вас есть views.py ) создайте новый файл с именем forms.py со следующим кодом, который определяет форму Django, содержащую поле, извлеченное из модели данных, LogMessage :

     из форм импорта django
   из hello.models импортировать LogMessage
   
   класс LogMessageForm (forms.ModelForm):
       класс Мета:
           model = LogMessage
           fields = ("message",) # ПРИМЕЧАНИЕ: запятая в конце обязательна.  

2. В папке templates / hello создайте новый шаблон с именем log_message.html со следующим содержимым, которое предполагает, что шаблону присвоена переменная с именем form для определения тела формы. Затем он добавляет кнопку отправки с меткой «Журнал».

     {% extends "hello / layout.html "%}
   {% заголовок блока%}
       Записать сообщение
   {% endblock%}
   {% блокировать содержание%}
       
   
           {% csrf_token%}
           {{form.as_p}}
            Журнал 
       
   {% endblock%}  

   Примечание : Тег {% csrf_token%} Django обеспечивает защиту от подделок межсайтовых запросов. Дополнительные сведения см. В разделе «Защита от подделки межсайтовых запросов» в документации Django.

3. В файле static / hello / site.css приложения добавьте правило для расширения формы ввода:

     ввод [имя = сообщение] {
       ширина: 80%;
   }  

4. В файле приложения urls.py добавьте маршрут для новой страницы:

     путь ("журнал /", views.log_message, name = "log"),  

5. В views.py определите представление с именем log_message (на которое ссылается URL-маршрут).Это представление обрабатывает случаи HTTP GET и POST. В случае GET ( else: раздел) он просто отображает форму, которую вы определили на предыдущих шагах. В случае POST он извлекает данные из формы в объект данных (сообщение , ), устанавливает метку времени, затем сохраняет этот объект, после чего он записывается в базу данных:

     # Добавьте их к существующему импорту в верхней части файла:
   из django.shortcuts перенаправление импорта
   из hello.forms импортировать LogMessageForm
   от привет.модели импортируют LogMessage
   
   # Добавьте этот код в другое место в файле:
   def log_message (запрос):
       form = LogMessageForm (request.POST или None)
   
       если request.method == "POST":
           если form.is_valid ():
               message = form.save (commit = False)
               message.log_date = datetime.now ()
               message.save ()
               возврат перенаправления ("домой")
       еще:
           возврат рендеринга (запрос, "hello / log_message.html", {"form": form})  

6. Еще один шаг, прежде чем вы будете готовы все попробовать! В шаблонах / hello / layout.html , добавьте ссылку в div «navbar» для страницы регистрации сообщений:

     
    Сообщение журнала   

7. Запустите приложение и откройте в браузере домашнюю страницу. Выберите ссылку Log Message на панели навигации, которая должна отобразить страницу регистрации сообщений:

8. Введите сообщение, выберите Журнал , и вы вернетесь на главную страницу.На домашней странице еще не отображаются зарегистрированные сообщения (что вы исправите в ближайшее время). Не стесняйтесь записывать еще несколько сообщений. Если вы хотите, загляните в базу данных с помощью такого инструмента, как SQLite Browser, чтобы увидеть, что записи были созданы. Откройте базу данных как доступную только для чтения или не забудьте закрыть базу данных перед использованием приложения, в противном случае приложение выйдет из строя, потому что база данных заблокирована.

9. Остановите приложение, когда закончите.

10. Теперь измените домашнюю страницу, чтобы отображать зарегистрированные сообщения.Начните с замены содержимого файла templates / hello / home.html приложения на разметку ниже. Этот шаблон ожидает контекстную переменную с именем message_list . Если он получает один (проверяется с помощью тега {% if message_list%} ), он затем перебирает этот список (тег {% for message in message_list%} ) для создания строк таблицы для каждого сообщения. В противном случае страница указывает, что сообщения еще не были зарегистрированы.

      {% extends "hello / layout.html "%}
    {% заголовок блока%}
        Дом
    {% endblock%}
    {% блокировать содержание%}
        
     Зарегистрированные сообщения 
    
        {% if message_list%}
            <таблица>
                
                
                     Дата 
                     Время 
                     Сообщение 
                
                
                
                {% для сообщения в message_list%}
                    
                         {{сообщение.log_date | date: 'd M Y'}} 
                         {{message.log_date | время: 'H: i: s'}} 
                        
                            {{message.message}}
                        
                    
                {% endfor%}
                
            
        {% еще %}
            
     Сообщения не регистрировались. Воспользуйтесь  формой сообщения журнала .
        {% endif%}
    {% endblock%}  

11. В static / hello / site.css добавьте правило для небольшого форматирования таблицы:

      .message_list th, td {
        выравнивание текста: слева;
        отступ справа: 15 пикселей;
    }  

12. В views.py импортируйте общий класс Django ListView , который мы будем использовать для реализации домашней страницы:

      из django.views.generic импорт ListView  

13. Также в views.py замените функцию home на класс с именем HomeListView , производный от ListView , который привязывается к модели LogMessage и реализует функцию get_context_data для генерации контекст для шаблона.

      # Удалите старую домашнюю функцию, если хотите; он больше не используется
    
    класс HomeListView (ListView):
        "" "Отображает домашнюю страницу со списком всех сообщений."" "
        model = LogMessage
    
        def get_context_data (self, ** kwargs):
            context = super (HomeListView, self) .get_context_data (** kwargs)
            возврат контекста  

14. В приложении urls.py импортируйте модель данных:

      из hello.models import LogMessage  

15. Также в urls.py создайте переменную для нового представления, которое извлекает пять самых последних объектов LogMessage в порядке убывания (то есть запрашивает базу данных), а затем предоставляет имя для данных в шаблоне. контекст ( список_сообщений ) и определяет используемый шаблон:

      home_list_view = просмотры.HomeListView.as_view (
        queryset = LogMessage.objects.order_by ("- log_date") [: 5], #: 5 ограничивает результаты пятью самыми последними
        context_object_name = "message_list",
        template_name = "привет / home.html",
    )  

16. В urls.py измените путь к домашней странице, чтобы использовать переменную home_list_view :

      # Заменить существующий путь на ""
        путь ("", home_list_view, name = "home"),  

17. Запустите приложение и откройте в браузере домашнюю страницу, на которой теперь должны отображаться сообщения:

18. Остановите приложение, когда закончите.

Использовать отладчик с шаблонами страниц

Как показано в предыдущем разделе, шаблоны страниц могут содержать процедурные директивы, такие как {% для сообщения в message_list%} и {% if message_list%} , а не только пассивные декларативные элементы, такие как {% url%} и {% block%} . В результате у вас могут быть ошибки программирования внутри шаблонов, как и с любым другим процедурным кодом.

К счастью, расширение Python для VS Code обеспечивает отладку шаблонов, если в конфигурации отладки указано «django»: true (как вы это уже сделали).Следующие шаги демонстрируют эту возможность:

1. В шаблонах / hello / home.html установите точки останова в строках {% if message_list%} и {% для сообщения в message_list%} , как показано желтыми стрелками на изображении ниже:

2. Запустите приложение в отладчике и откройте в браузере домашнюю страницу. (Если вы уже запускаете отладчик, вам не нужно перезапускать приложение после установки точек останова; просто обновите страницу.Обратите внимание на то, что VS Code взламывает отладчик в шаблоне оператора {% if%} и показывает все контекстные переменные на панели Variables :

3. Используйте команду «Перейти» (F10) для пошагового выполнения кода шаблона. Обратите внимание, что отладчик перебирает все декларативные операторы и приостанавливает выполнение любого процедурного кода. Например, переход по циклам {% for message in message_list%} позволяет вам исследовать каждое значение в message и позволяет переходить к строкам вроде

   {{message.log_date | date: 'd M Y'}}

   .

4. Вы также можете работать с переменными на панели Debug Console . (Однако фильтры Django, такие как и дата , в настоящее время недоступны в консоли.)

5. Когда вы будете готовы, выберите «Продолжить» (F5), чтобы завершить запуск приложения и просмотреть отображенную страницу в браузере. По завершении остановите отладчик.

Дополнительные мероприятия

В следующих разделах описаны дополнительные шаги, которые могут оказаться полезными при работе с Python и Visual Studio Code.

Создайте файл requirements.txt для среды

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

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

Хотя вы можете создать файл вручную, вы также можете использовать команду pip freeze для создания файла на основе точных библиотек, установленных в активированной среде:

1. Выбрав выбранную среду с помощью команды Python: Select Interpreter , запустите команду Terminal: Create New Integrated Terminal (⌃⇧` (Windows, Linux Ctrl + Shift + `))), чтобы открыть терминал с активированной этой средой. .

2. В терминале запустите pip freeze> requirements.txt , чтобы создать файл requirements.txt в папке проекта.

Любой (или любой сервер сборки), который получает копию проекта, должен только запустить команду pip install -r requirements.txt , чтобы переустановить пакеты, от которых приложение зависит в активной среде.

Примечание : pip freeze перечисляет все пакеты Python, которые вы установили в текущей среде, включая пакеты, которые вы в настоящее время не используете.Команда также перечисляет пакеты с точными номерами версий, которые вы, возможно, захотите преобразовать в диапазоны для большей гибкости в будущем. Для получения дополнительной информации см. Файлы требований в документации по командам pip.

Создайте суперпользователя и включите административный интерфейс

По умолчанию Django предоставляет административный интерфейс для веб-приложения, защищенного аутентификацией. Интерфейс реализован через встроенное приложение django.contrib.admin , которое по умолчанию включено в список INSTALLED_APPS проекта (настройки .py ), а аутентификация выполняется с помощью встроенного приложения django.contrib.auth , которое по умолчанию также находится в INSTALLED_APPS .

Выполните следующие шаги, чтобы включить административный интерфейс:

1. Создайте учетную запись суперпользователя в приложении, открыв Терминал в VS Code для вашей виртуальной среды, а затем запустив команду python manage.py createduperuser --username = --email = , заменив и , конечно, с вашей личной информацией.Когда вы запускаете команду, Django предлагает вам ввести и подтвердить пароль.

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

2. Добавьте следующий URL-маршрут на уровне проекта urls.py ( web_project / urls.py в этом руководстве), чтобы указать на встроенный административный интерфейс:

     # Этот путь включен по умолчанию при создании приложения
    путь ("admin /", admin.site.urls),  

3. Запустите сервер, затем откройте в браузере страницу приложения / администратора (например, http://127.0.0.1:8000/admin при использовании сервера разработки).

4. Появится страница входа, предоставленная django.contrib.auth . Введите свои учетные данные суперпользователя.

5. После аутентификации вы увидите страницу администрирования по умолчанию, через которую вы можете управлять пользователями и группами:

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

Создайте контейнер для приложения Django с помощью расширения Docker

Расширение Docker упрощает создание, управление и развертывание контейнерных приложений из Visual Studio Code. Если вам интересно узнать, как создать контейнер Python для приложения Django, разработанного в этом руководстве, ознакомьтесь с руководством по Python в контейнере, в котором вы узнаете, как:

• Создайте файл Dockerfile , описывающий простой контейнер Python.
• Создайте, запустите и проверьте функциональность приложения Django.
• Отладка приложения, работающего в контейнере.

Следующие шаги

Поздравляем с завершением этого пошагового руководства по работе с Django в Visual Studio Code!

Завершенный проект кода из этого руководства можно найти на GitHub: python-sample-vscode-django-tutorial.

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

Чтобы опробовать свое приложение на рабочем веб-сайте, ознакомьтесь с учебным курсом «Развертывание приложений Python в службе приложений Azure с помощью контейнеров Docker». Azure также предлагает стандартный контейнер App Service в Linux, в котором вы развертываете веб-приложения из VS Code.

Вы также можете просмотреть следующие статьи в документации VS Code, относящиеся к Python:

Если вы столкнулись с какими-либо проблемами в ходе этого руководства, не стесняйтесь сообщать о проблеме в репозиторий документации VS Code.

07.03.2019

Quickstart — Django REST framework

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

Создайте новый проект Django с именем tutorial , затем запустите новое приложение с именем quickstart .

  # Создать каталог проекта
mkdir учебник
cd учебник

# Создайте виртуальную среду, чтобы изолировать наши зависимости пакетов локально
python3 -m venv env
source env / bin / activate # В Windows используйте `env \ Scripts \ activate`

# Установите Django и Django REST framework в виртуальную среду
pip установить django
pip установить djangorestframework

# Создайте новый проект с помощью одного приложения
Руководство по запуску проекта django-admin.# Обратите внимание на завершающий '.' персонаж
cd учебник
Быстрый запуск запуска приложения django-admin
CD ..
  

Макет проекта должен выглядеть так:

  $ в сутки
<некоторый путь> / учебник
$ найти.
.
./manage.py
./руководство
./tutorial/__init__.py
./tutorial/quickstart
./tutorial/quickstart/__init__.py
./tutorial/quickstart/admin.py
./tutorial/quickstart/apps.py
./tutorial/quickstart/migrations
./tutorial/quickstart/migrations/__init__.py
./tutorial/quickstart/models.py
./tutorial/quickstart/tests.ру
./tutorial/quickstart/views.py
./tutorial/settings.py
./tutorial/urls.py
./tutorial/wsgi.py
  

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

Теперь синхронизируйте свою базу данных в первый раз:

  python manage.py мигрировать
  

Мы также создадим начального пользователя с именем admin с паролем password123 .Мы аутентифицируемся как этот пользователь позже в нашем примере.

  python manage.py createduperuser --email [email protected] --username admin
  

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

Сначала мы собираемся определить несколько сериализаторов. Давайте создадим новый модуль с именем tutorial / quickstart / serializers.py , который мы будем использовать для наших представлений данных.

  из django.contrib.auth.models импорт пользователя, группы
из сериализаторов импорта rest_framework


класс UserSerializer (сериализаторы.HyperlinkedModelSerializer):
    класс Мета:
        model = Пользователь
        fields = ['url', 'username', 'email', 'groups']


класс GroupSerializer (сериализаторы.HyperlinkedModelSerializer):
    класс Мета:
        model = Группа
        fields = ['url', 'name']
  

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

Хорошо, тогда лучше напишем несколько обзоров. Откройте учебник / quickstart / views.py и начните печатать.

  из django.contrib.auth.models импортировать пользователя, группу
из rest_framework импортных наборов
из разрешений на импорт rest_framework
из tutorial.quickstart.serializers импортировать UserSerializer, GroupSerializer


класс UserViewSet (viewsets.ModelViewSet):
    "" "
    Конечная точка API, позволяющая просматривать или редактировать пользователей.
    "" "
    queryset = User.objects.all (). order_by ('- date_joined')
    serializer_class = UserSerializer
    permission_classes = [разрешения.IsAuthenticated]


класс GroupViewSet (viewsets.ModelViewSet):
    "" "
    Конечная точка API, позволяющая просматривать или редактировать группы.
    "" "
    queryset = Group.objects.all ()
    serializer_class = GroupSerializer
    permission_classes = [permissions.IsAuthenticated]
  

Вместо того, чтобы писать несколько представлений, мы группируем все общее поведение в классы, называемые ViewSets .

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

Хорошо, теперь давайте подключим URL-адреса API. Перейти к руководству по / urls.py …

  из импорта django.urls, путь
из роутеров импорта rest_framework
из представлений импорта tutorial.quickstart

router = routers.DefaultRouter ()
router.register (r'users ', views.UserViewSet)
router.register (r'groups ', views.GroupViewSet)

# Подключите наш API, используя автоматическую маршрутизацию URL.
# Кроме того, мы включаем URL-адреса для входа в доступный для просмотра API.
urlpatterns = [
    путь ('', включить (router.URL-адреса)),
    путь ('api-auth /', include ('rest_framework.urls', namespace = 'rest_framework'))
]
  

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

Опять же, если нам нужен больший контроль над URL-адресами API, мы можем просто перейти к использованию обычных представлений на основе классов и явной записи URL-адреса conf.

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

Разбивка на страницы позволяет вам контролировать количество возвращаемых объектов на страницу. Чтобы включить его, добавьте следующие строки в tutorial / settings.py

  REST_FRAMEWORK = {
    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination',
    'PAGE_SIZE': 10
}
  

Добавьте rest_framework в INSTALLED_APPS .Модуль настроек будет в tutorial / settings.py

  INSTALLED_APPS = [
    ...
    'rest_framework',
]
  

Хорошо, мы закончили.

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

  сервер запуска python manage.py
  

Теперь мы можем получить доступ к нашему API из командной строки, используя такие инструменты, как curl …

  bash: curl -H 'Принять: application / json; indent = 4 '-u admin: password123 http: // 127.0.0.1: 8000 / пользователи /
{
    «count»: 2,
    "следующий": ноль,
    "предыдущий": ноль,
    "полученные результаты": [
        {
            "электронная почта": "[email protected]",
            "группы": [],
            "url": "http://127.0.0.1:8000/users/1/",
            "имя пользователя": "админ"
        },
        {
            "электронная почта": "[email protected]",
            "группы": [],
            "url": "http://127.0.0.1:8000/users/2/",
            "имя пользователя": "том"
        }
    ]
}
  

Или с помощью средства командной строки httpie…

  bash: http -a admin: password123 http://127.0.0.1:8000/users/

HTTP / 1.1 200 ОК
...
{
    «count»: 2,
    "следующий": ноль,
    "предыдущий": ноль,
    "полученные результаты": [
        {
            "электронная почта": "[email protected]",
            "группы": [],
            "url": "http: // localhost: 8000 / users / 1 /",
            "имя пользователя": "пол"
        },
        {
            "электронная почта": "[email protected]",
            "группы": [],
            "url": "http://127.0.0.1:8000/users/2/",
            "имя пользователя": "том"
        }
    ]
}
  

Или напрямую через браузер, перейдя по URL-адресу http: // 127.0.0.1: 8000 / пользователи / …

Если вы работаете через браузер, обязательно войдите в систему с помощью элемента управления в правом верхнем углу.

Отлично, это было просто!

Если вы хотите получить более глубокое представление о том, как фреймворк REST сочетается друг с другом, перейдите к руководству или начните просматривать руководство по API.

Развертывание приложения Django в Elastic Beanstalk

В этом руководстве рассматривается развертывание автоматически созданного веб-сайта Django по умолчанию на
Среда AWS Elastic Beanstalk под управлением Python.Из этого туториала Вы узнаете, как разместить
веб-приложение Python в облаке с помощью среды Elastic Beanstalk.

В этом руководстве вы сделаете следующее:

Предварительные требования

Для использования любого сервиса AWS, в том числе Elastic Beanstalk, у вас должна быть учетная запись AWS.
и полномочия.Чтобы узнать больше и зарегистрироваться, посетите https://aws.amazon.com/.

Чтобы следовать этому руководству, у вас должны быть установлены все общие предварительные требования для Python,
включая следующие пакеты:

• Python 3.6 или новее

• пункт

• виртуальный

• awsebcli

Фреймворк Django устанавливается как часть учебника.

Для создания сред с помощью интерфейса командной строки EB требуется роль службы. Вы можете создать служебную роль, создав
среда в консоли Elastic Beanstalk. Если у вас нет служебной роли,
EB CLI пытается создать его, когда вы запускаете eb create .

Настройте виртуальную среду Python и установите Django

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

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

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

1. Создайте виртуальную среду с именем eb-virt .

   Unix-системы

     ~ $  virtualenv ~ / eb-virt   

   Окна

     C: \>  virtualenv% HOMEPATH% \ eb-virt   

2. Активируйте виртуальную среду.

   Unix-системы

     ~ $  источник ~ / eb-virt / bin / активировать 
   (eb-virt) ~ $  

   Окна

     C: \> % HOMEPATH% \ eb-virt \ Scripts \ активировать 
   (eb-virt) C: \>  

   В начале командной строки вы увидите (eb-virt) , что означает, что вы находитесь в виртуальной среде.

   Остальные инструкции показывают командную строку Linux в вашем домашнем каталоге.
   ~ долларов. В Windows это
   C: \ Users \ ИМЯ ПОЛЬЗОВАТЕЛЯ > , где ИМЯ ПОЛЬЗОВАТЕЛЯ — ваше имя для входа в Windows.

3. Используйте pip для установки Django.

     (eb-virt) ~ $  pip install django == 2.2   

   Устанавливаемая вами версия Django должна быть совместима с версией Python на Elastic
   Конфигурация Beanstalk Python, которую вы выбираете для развертывания своего
   заявление. Для получения информации о развертывании см. Развертывание сайта с помощью интерфейса командной строки EB в этом разделе.

   Для получения дополнительной информации о текущих версиях платформы Python см. Python в AWS Elastic Beanstalk Platforms
   документ.

   Чтобы узнать о совместимости версий Django с Python, см. Какую версию Python можно использовать с
   Джанго?

4. Чтобы убедиться, что Django установлен, введите следующее.

     (eb-virt) ~ 900 долл. США: заморозка пункта 
   Django == 2.2
   ...  

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

Создать проект Django

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

В этом руководстве используется SQLite, ядро ​​базы данных, включенное в Python. База данных
развертывается с файлами вашего проекта. Для производства
средах, мы рекомендуем использовать Amazon Relational Database Service (Amazon
RDS), и что вы отделяете его от своей среды.Дополнительные сведения см. В разделе Добавление экземпляра БД Amazon RDS в среду приложений Python.

Для создания приложения Django

1. Активируйте свою виртуальную среду.

   Unix-системы

     ~ $  источник ~ / eb-virt / bin / активировать 
   (eb-virt) ~ $  

   Окна

     C: \> % HOMEPATH% \ eb-virt \ Scripts \ активировать 
   (eb-virt) C: \>  

   В начале командной строки вы увидите префикс (eb-virt) , указывающий на то, что вы находитесь в виртуальной среде.

   Остальная часть этих инструкций показывает командную строку Linux ~ $ в вашем домашнем каталоге и в домашнем каталоге Linux.
   ~ / . В Windows это C: \ Users \ ИМЯ ПОЛЬЗОВАТЕЛЯ > , где ИМЯ ПОЛЬЗОВАТЕЛЯ —
   ваше имя для входа в Windows.

2. Используйте команду django-admin startproject , чтобы создать проект Django с именем ebdjango .

     (eb-virt) ~  долл. США django-admin startproject ebdjango   

   Эта команда создает стандартный сайт Django с именем ebdjango со следующей структурой каталогов.

     ~ / ebdjango
     | - ebdjango
     | | - __init__.py
     | | - settings.py
     | | - urls.py
     | `- wsgi.py
     `- manage.py  

3. Запустите свой сайт Django локально с помощью сервера запуска manage.py .

     (eb-virt) ~ 900 долл. США 10 cd ebdjango   

     (eb-virt) ~ / ebdjango $  python manage.py runserver   

4. В веб-браузере откройте http://127.0.0.1:8000/ , чтобы просмотреть сайт.

5. Проверьте журнал сервера, чтобы увидеть результат вашего запроса.Чтобы остановить веб-сервер и
   вернитесь в свою виртуальную среду, нажмите
   Ctrl + C .

     Django версии 2.2, используя настройки 'ebdjango.settings'
   Запуск сервера разработки по адресу http://127.0.0.1:8000/
   Закройте сервер, нажав CONTROL-C.
   [07 / сен / 2018 20:14:09] "GET / HTTP / 1.1" 200 16348
     Ctrl + C   

Настройте приложение Django для Elastic Beanstalk

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

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

Чтобы настроить сайт для Elastic Beanstalk

1. Активируйте свою виртуальную среду.

   Unix-системы

     ~ / ebdjango $  источник ~ / eb-virt / bin / активировать   

   Окна

     C: \ Users \  ИМЯ ПОЛЬЗОВАТЕЛЯ  \ ebdjango> % HOMEPATH% \ eb-virt \ Scripts \ activate   

2. Запустите pip freeze , а затем сохраните вывод в файл с именем requirements.txt .

     (eb-virt) ~ / ebdjango $  pip freeze> requirements.txt   

   Elastic Beanstalk использует requirements.txt , чтобы определить, какой пакет установить на экземплярах EC2, на которых выполняется ваше приложение.

3. Создайте каталог с именем .Эбэкстенси .

     (eb-virt) ~ / ebdjango $  mkdir .ebextensions   

4. В каталоге .ebextensions добавьте файл конфигурации с именем django.config с
   следующий текст.

   Пример ~ / ebdjango / .ebextensions / django.config

     option_settings:
     aws: elasticbeanstalk: контейнер: питон:
       WSGIPath: ebdjango.wsgi: приложение  

   Этот параметр, WSGIPath , указывает расположение сценария WSGI, который Elastic Beanstalk использует для запуска вашего
   заявление.

   Если вы используете версию платформы Amazon Linux AMI Python (предшествующую Amazon Linux
   2) замените значение WSGIPath на
   ebdjango / WSGI.py . Значение в примере работает с сервером Gunicorn WSGI, который не поддерживается.
   на платформе Amazon Linux AMI
   версии.

5. Деактивируйте виртуальную среду с помощью команды deactivate .

     (eb-virt) ~ / ebdjango $  деактивировать   

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

Разверните свой сайт с EB CLI

Вы добавили все необходимое для развертывания приложения на Elastic Beanstalk.Каталог вашего проекта теперь должен выглядеть так.

  ~ / ebdjango /
| - .ebextensions
| `- django.config
| - ebdjango
| | - __init__.py
| | - settings.py
| | - urls.py
| `- wsgi.py
| - db.sqlite3
| - manage.py
`- requirements.txt  

Затем вы создадите среду своего приложения и развернете настроенное приложение.
с эластичным бобовым стеблем.

Сразу после развертывания вы отредактируете конфигурацию Django, чтобы добавить домен.
имя, которое Elastic Beanstalk назначил вашему приложению для Django
РАЗРЕШЕННЫЕ_ХОСТЫ . Затем вы повторно развернете свое приложение. Это требование безопасности Django, разработанное
для предотвращения HTTP Host
заголовочные атаки.Для получения дополнительной информации см. Заголовок хоста.
Проверка.

Для создания среды и развертывания приложения Django

В этом руководстве в качестве механизма развертывания используется интерфейс командной строки EB, но вы также можете использовать
Консоль Elastic Beanstalk для развертывания.zip-файл, содержащий файлы вашего проекта
содержание.

1. Инициализируйте репозиторий EB CLI с помощью команды eb init .

     ~ / ebdjango $  eb init -p python-3.6.Учебник по django 
   Создано приложение django-tutorial.  

   Эта команда создает приложение с именем django-tutorial . Он также настраивает ваш локальный репозиторий для создания сред
   с последней версией платформы Python 3.6.

2. (Необязательно) Запустите eb init еще раз, чтобы настроить пару ключей по умолчанию, чтобы можно было использовать SSH для подключения к EC2.
   экземпляр работает
   ваше приложение.

     ~ / ebdjango $  eb init 
   Вы хотите настроить SSH для своих экземпляров?
   (т / п):  л 
   Выберите пару ключей.
   1) my-keypair (моя-пара ключей)
   2) [Создать новую пару ключей]  

   Выберите пару ключей, если она у вас уже есть, или следуйте инструкциям по ее созданию. Если
   вы не видите подсказку или вам нужно изменить настройки позже,
   запустите eb init -i .

3. Создайте среду и разверните в ней свое приложение с помощью eb create .

     ~ / ebdjango $  eb create django-env   

   Если вы видите сообщение об ошибке «Требуется роль службы», запустите eb create в интерактивном режиме.
   (без указания имени среды), и EB CLI создаст роль для вас.

   Эта команда создает среду Elastic Beanstalk с балансировкой нагрузки с именем django-env . Создание окружения занимает около 5 минут. В качестве
   Elastic Beanstalk создает ресурсы, необходимые для запуска вашего приложения, и выводит
   информационные сообщения, которые EB CLI передает на ваш терминал.

4. Когда процесс создания среды завершится, найдите доменное имя вашего нового
   среды, запустив eb status .

     ~ / ebdjango $  Статус eb 
   Сведения о среде для: django-env
     Название приложения: django-tutorial
     ...
     CNAME:  eb-django-app-dev.elasticbeanstalk.com 
     ...  

   Доменное имя вашей среды — это значение свойства CNAME .

5. Откройте настройки .py в каталоге ebdjango . Найдите параметр ALLOWED_HOSTS и
   затем добавьте доменное имя вашего приложения, которое вы нашли на предыдущем шаге, в
   значение настройки. Если вы не можете найти этот параметр в файле, добавьте его
   на новую строку.

    ...
   ALLOWED_HOSTS = [' eb-django-app-dev.elasticbeanstalk.com ']  

6. Сохраните файл, а затем разверните приложение, запустив eb deploy . При запуске eb deploy интерфейс командной строки EB
   объединяет содержимое каталога вашего проекта и развертывает его в вашей среде.

     ~ / ebdjango $  eb развертывание   

7. Когда процесс обновления среды завершится, откройте свой веб-сайт с помощью eb open .

     ~ / ebdjango $  eb открыто   

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

Если вы не видите, что ваше приложение запущено, или получаете сообщение об ошибке, см. Устранение неполадок при развертывании.
для помощи в определении причины ошибки.

Если вы с по видите, что ваше приложение запущено, поздравляю, вы развернули свой первый Django.
приложение с Elastic Beanstalk!

Обновите приложение

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

В этом примере мы включим консоль администратора Django и настроим несколько других параметров.

Измените настройки своего сайта

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

Чтобы изменить часовой пояс вашего сайта

1. Измените параметр TIME_ZONE в settings.py .

   Пример ~ / ebdjango / ebdjango / settings.py

     ...
   # Интернационализация
   LANGUAGE_CODE = 'ru-ru'
   TIME_ZONE =  'США / Тихий океан' 
   USE_I18N = Верно
   USE_L10N = Верно
   USE_TZ = Истина  

   Список часовых поясов см. На этой странице.

2. Разверните приложение в среде Elastic Beanstalk.

     ~ / ebdjango / $  eb развертывание   

Создать администратора сайта

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

Для создания сайта администратор

1. Инициализируйте локальную базу данных вашего приложения Django.

     (eb-virt) ~ / ebdjango $  python manage.py миграция 
   Выполняемые операции:
     Применить все миграции: admin, auth, contenttypes, sessions
   Выполняемые миграции:
     Применение contenttypes.0001_initial ... ОК
     Применение auth.0001_initial ... ОК
     Применяем admin.0001_initial ... ОК
     Применяем admin.0002_logentry_remove_auto_add ... ОК
     Применяем admin.0003_logentry_add_action_flag_choices ... ОК
     Применение contenttypes.0002_remove_content_type_name... OK
     Применение auth.0002_alter_permission_name_max_length ... ОК
     Применение auth.0003_alter_user_email_max_length ... ОК
     Применение auth.0004_alter_user_username_opts ... ОК
     Применение auth.0005_alter_user_last_login_null ... ОК
     Применение auth.0006_require_contenttypes_0002 ... ОК
     Применение auth.0007_alter_validators_add_error_messages ... ОК
     Применение auth.0008_alter_user_username_max_length ... ОК
     Применение auth.0009_alter_user_last_name_max_length ... ОК
     Применение sessions.0001_initial ... ОК
     

2. Запуск , управление.py создает суперпользователя для создания администратора.

     (eb-virt) ~ / ebdjango $  python manage.py создает суперпользователя 
   Имя пользователя:  admin 
   Электронный адрес:  [email protected] 
   Пароль:  ******** 
   Пароль (еще раз):  ******** 
   Суперпользователь успешно создан.  

3. Чтобы указать Django, где хранить статические файлы, определите STATIC_ROOT в настройках .py .

   Пример ~ / ebdjango / ebdjango / settings.py

     # Статические файлы (CSS, JavaScript, изображения)
   # https://docs.djangoproject.com/en/2.2/howto/static-files/
   STATIC_URL = '/ статический /'
     STATIC_ROOT = 'статический'   

4. Запуск , управление.py collectstatic для заполнения каталога static статическими ресурсами (JavaScript, CSS и изображения)
   для админки.

     (eb-virt) ~ / ebdjango $  python manage.py collectstatic 
   119 статических файлов скопировано в ~ / ebdjango / static
               

5. Разверните ваше приложение.

     ~ / ebdjango $  eb развертывание   

6. Просмотрите консоль администратора, открыв сайт в браузере, добавив / admin / к URL-адресу сайта, например, следующим образом.

     http: //  djang-env.p33kq46sfh.us-west-2  .elasticbeanstalk.com / admin /  

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

Вы можете использовать аналогичную процедуру локального обновления / тестирования с последующим развертыванием eb .Elastic Beanstalk обновляет вашу жизнь
серверов, поэтому вы можете сосредоточиться на разработке приложений, а не на администрировании серверов!

Добавить файл конфигурации миграции базы данных

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

Чтобы добавить шаг миграции при развертывании приложения

1. Создайте файл конфигурации с именем db-migrate.config со следующим содержимым.

   Пример ~ / ebdjango / .ebextensions / db-migrate.config

     container_commands:
     01_migrate:
       команда: "django-admin.py migrate"
       leader_only: правда
   option_settings:
     aws: elasticbeanstalk: приложение: среда:
       DJANGO_SETTINGS_MODULE: ebdjango.настройки  

   Этот файл конфигурации запускает команду django-admin.py migrate во время процесса развертывания перед запуском приложения.
   Поскольку он запускается до запуска приложения, вы также должны явно настроить переменную среды DJANGO_SETTINGS_MODULE
   (обычно wsgi.py позаботится об этом во время запуска). Указание leader_only: true в команде гарантирует
   что он запускается только один раз при развертывании в нескольких экземплярах.

2. Разверните ваше приложение.

     ~ / ebdjango $  eb развертывание   

Очистить

Чтобы сэкономить часы работы инстансов и другие ресурсы AWS между сеансами разработки, прекратите
ваша среда Elastic Beanstalk с eb
прекратить .

  ~ / ebdjango $  eb terminate django-env   

Эта команда завершает работу среды и всех ресурсов AWS, работающих в
Это. Однако он не удаляет приложение, поэтому вы можете
всегда создавайте больше сред с той же конфигурацией, снова запуская eb create .Для получения дополнительной информации о командах EB CLI см.
Управление средами Elastic Beanstalk с помощью EB CLI.

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

  ~  $ rm -rf ~ / eb-virt 
~ $  rm -rf ~ / ebdjango   

Следующие шаги

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

Если вы хотите опробовать другую веб-платформу Python, ознакомьтесь с разделом «Развертывание приложения Flask в Elastic Beanstalk».

Учебник по изучению Django в Visual Studio, шаг 1, основы Django

• 19.11.2018
• 13 минут на чтение

В этой статье

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

Из этого руководства вы узнаете, как:

• Создайте базовый проект Django в репозитории Git, используя шаблон «Пустой веб-проект Django» (шаг 1)
• Создайте приложение Django с одной страницей и визуализируйте эту страницу с помощью шаблона (шаг 2)
• Обслуживать статические файлы, добавлять страницы и использовать наследование шаблонов (шаг 3)
• Используйте шаблон веб-проекта Django для создания приложения с несколькими страницами и адаптивным дизайном (шаг 4)
• Аутентификация пользователей (шаг 5)
• Используйте шаблон веб-проекта Django Опросы для создания приложения, которое использует модели, миграции баз данных и настройки административного интерфейса (шаг 6).

• Создайте базовый проект Django в репозитории Git, используя шаблон «Пустой веб-проект Django» (шаг 1)
• Создайте приложение Django с одной страницей и визуализируйте эту страницу с помощью шаблона (шаг 2)
• Обслуживать статические файлы, добавлять страницы и использовать наследование шаблонов (шаг 3)
• Используйте шаблон веб-проекта Django для создания приложения с несколькими страницами и адаптивным дизайном (шаг 4).
• Аутентификация пользователей (шаг 5)

Предварительные требования

• Visual Studio 2017 или более поздней версии для Windows со следующими параметрами:
  • Рабочая нагрузка Python development (вкладка Workload в установщике).Инструкции см. В разделе Установка поддержки Python в Visual Studio.
  • Git для Windows и GitHub Extension для Visual Studio на вкладке Отдельные компоненты в разделе Инструменты кода .

Шаблоны проектов Django также включены во все более ранние версии Python Tools для Visual Studio, хотя детали могут отличаться от того, что обсуждается в этом руководстве (особенно отличается от более ранних версий платформы Django).

Разработка на Python в настоящее время не поддерживается в Visual Studio для Mac. В Mac и Linux используйте расширение Python в Visual Studio Code.

«Проекты Visual Studio» и «Проекты Django»

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

Со своей стороны, проект Visual Studio может содержать проект Django вместе с несколькими приложениями. Для простоты всякий раз, когда в этом руководстве упоминается просто «проект», это относится к проекту Visual Studio. Когда он ссылается на часть веб-приложения «проект Django», он конкретно использует «проект Django».

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

Шаг 1-1: Создайте проект и решение Visual Studio

При работе с Django из командной строки вы обычно запускаете проект с помощью команды django-admin startproject . В Visual Studio использование шаблона «Пустой веб-проект Django» обеспечивает такую ​​же структуру внутри проекта и решения Visual Studio.

1. В Visual Studio выберите File > New > Project , найдите «Django» и выберите шаблон Blank Django Web Project . (Шаблон также находится под Python > Web в левом списке.)

2. В полях внизу диалогового окна введите следующую информацию (как показано на предыдущем рисунке), затем выберите OK :

   • Имя : установите имя проекта Visual Studio на BasicProject .Это имя также используется для проекта Django.
   • Расположение : укажите расположение для создания решения и проекта Visual Studio.
   • Решение : оставьте для этого элемента управления значение по умолчанию Создать новое решение вариант.
   • Имя решения : установите значение LearningDjango , что подходит для решения в качестве контейнера для нескольких проектов в этом руководстве.
   • Создать каталог для решения : оставить заданное (значение по умолчанию).
   • Создать новый репозиторий Git : выберите этот параметр (по умолчанию он снят), чтобы Visual Studio создавала локальный репозиторий Git при создании решения. Если вы не видите этот параметр, запустите установщик Visual Studio и добавьте Git для Windows и GitHub Extension для Visual Studio на вкладке Отдельные компоненты в разделе Инструменты кода .

3. Через мгновение Visual Studio отобразит диалоговое окно с сообщением Для этого проекта требуются внешние пакеты (показаны ниже).Это диалоговое окно появляется, потому что шаблон включает файл requirements.txt , ссылающийся на последний пакет Django 1.x. (Выберите Показать необходимые пакеты , чтобы увидеть точные зависимости.)

4. Выбери вариант Я сам их установлю . Вскоре вы создадите виртуальную среду, чтобы исключить ее из системы управления версиями. (Среда всегда может быть создана из requirements.txt .)

Шаг 1-2: Изучите элементы управления Git и опубликуйте в удаленном репозитории

Поскольку вы выбрали Создать новый репозиторий Git в диалоговом окне Новый проект , проект уже зафиксирован в локальной системе управления версиями, как только процесс создания будет завершен.На этом этапе вы познакомитесь с элементами управления Git Visual Studio и окном Team Explorer , в котором вы работаете с системой управления версиями.

1. Изучите элементы управления Git в нижнем углу главного окна Visual Studio. Слева направо эти элементы управления показывают незафиксированные коммиты, незафиксированные изменения, имя репозитория и текущую ветку:

   Примечание

   Если вы не выбрали Создать новый репозиторий Git в диалоговом окне Новый проект , элементы управления Git покажут только команду Добавить в систему управления версиями , которая создает локальный репозиторий.

2. Нажмите кнопку изменений, и Visual Studio откроет окно Team Explorer на странице Changes . Поскольку вновь созданный проект уже автоматически зафиксирован в системе управления версиями, вы не видите ожидающих изменений.

3. В строке состояния Visual Studio нажмите кнопку «Не нажата кнопка фиксации» (стрелка вверх с 2 ), чтобы открыть страницу Synchronization в Team Explorer .Поскольку у вас есть только локальный репозиторий, на странице представлены простые варианты публикации репозитория в различных удаленных репозиториях.

   Вы можете выбрать любую услугу для своих проектов. В этом руководстве показано использование GitHub, где завершенный образец кода для руководства хранится в репозитории Microsoft / python-sample-vs-learning-django.

4. При выборе любого из элементов управления Publish , Team Explorer запрашивает дополнительную информацию.Например, при публикации образца для этого руководства сначала нужно было создать сам репозиторий, и в этом случае использовалась опция Push to Remote Repository с URL-адресом репозитория.

   Если у вас нет существующего репозитория, варианты Publish to GitHub и Push to Azure DevOps позволяют создать репозиторий непосредственно из Visual Studio.

5. По мере работы с этим учебником приобретите привычку периодически использовать элементы управления в Visual Studio для фиксации и отправки изменений.Этот учебник напоминает вам о соответствующих моментах.

Подсказка

Чтобы быстро перемещаться по Team Explorer , выберите заголовок (который читает Изменения или Нажмите на изображениях выше), чтобы увидеть всплывающее меню с доступными страницами.

Вопрос: Каковы преимущества использования системы контроля версий с самого начала проекта?

Ответ: Во-первых, использование системы управления версиями с самого начала, особенно если вы также используете удаленный репозиторий, обеспечивает регулярное резервное копирование вашего проекта вне офиса.В отличие от поддержки проекта только в локальной файловой системе, система управления версиями также обеспечивает полную историю изменений и легкую возможность вернуть отдельный файл или весь проект к предыдущему состоянию. История изменений помогает определить причину регрессии (неудачных тестов). Кроме того, контроль версий важен, если над проектом работают несколько человек, поскольку он управляет перезаписью и обеспечивает разрешение конфликтов. Наконец, контроль версий, который по сути является формой автоматизации, хорошо настраивает вас на автоматизацию сборки, тестирования и управления выпусками.Это действительно первый шаг в использовании DevOps для проекта, и поскольку входные барьеры настолько низки, на самом деле нет причин не использовать систему управления версиями с самого начала.

Для дальнейшего обсуждения управления версиями как автоматизации см. «Источник истины: роль репозиториев в DevOps», статью в MSDN Magazine, написанную для мобильных приложений, которая также применима к веб-приложениям.

Вопрос: Могу ли я запретить Visual Studio автоматическую фиксацию нового проекта?

Ответ: Да.Чтобы отключить автоматическую фиксацию, перейдите на страницу Settings в Team Explorer , выберите Git > Global settings , снимите флажок Зафиксировать изменения после слияния по умолчанию , затем выберите Update .

Шаг 1-3: Создайте виртуальную среду и исключите ее из системы управления версиями

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

1. В обозревателе решений щелкните правой кнопкой мыши узел Python Environments и выберите Добавить виртуальную среду .

2. Появится диалоговое окно Добавить виртуальную среду с сообщением Мы нашли файл requirements.txt. Это сообщение указывает, что Visual Studio использует этот файл для настройки виртуальной среды.

3. Выберите Создать , чтобы принять значения по умолчанию. (Вы можете изменить имя виртуальной среды, если хотите, что просто изменит имя ее подпапки, но env является стандартным соглашением.)

4. Согласитесь с правами администратора, если будет предложено, затем подождите несколько минут, пока Visual Studio загружает и устанавливает пакеты, что для Django означает расширение нескольких тысяч файлов примерно в таком же количестве подпапок! Вы можете увидеть прогресс в окне Visual Studio Output .Пока вы ждете, обдумайте следующие разделы вопросов.

5. В элементах управления Visual Studio Git (в строке состояния) выберите индикатор изменений (который показывает 99 * ), который открывает страницу Changes в Team Explorer .

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

   Чтобы исключить виртуальную среду, щелкните правой кнопкой мыши папку env и выберите Игнорировать эти локальные элементы .

6. После исключения виртуальной среды остались только изменения в файле проекта и .gitignore . Файл .gitignore содержит добавленную запись для папки виртуальной среды. Вы можете дважды щелкнуть файл, чтобы увидеть разницу.

7. Введите сообщение о фиксации и нажмите кнопку Commit All , затем отправьте фиксации в удаленный репозиторий, если хотите.

Вопрос: Почему я хочу создать виртуальную среду?

Ответ: Виртуальная среда — отличный способ изолировать точные зависимости вашего приложения. Такая изоляция позволяет избежать конфликтов в глобальной среде Python и помогает как при тестировании, так и при совместной работе. Со временем, когда вы разрабатываете приложение, вы неизменно приносите много полезных пакетов Python. Сохраняя пакеты в виртуальной среде конкретного проекта, вы можете легко обновить требования проекта .txt , описывающий среду, включенную в систему управления версиями. Когда проект копируется на любые другие компьютеры, включая серверы сборки, серверы развертывания и другие компьютеры разработки, легко воссоздать среду, используя только requirements.txt (поэтому среда не должна находиться в системе контроля версий). ). Для получения дополнительной информации см. Использование виртуальных сред.

Вопрос: Как удалить виртуальную среду, которая уже привязана к системе контроля версий?

Ответ: Сначала отредактируйте файл .gitignore , чтобы исключить папку: найдите в конце раздел с комментарием # Python Tools for Visual Studio (PTVS) и добавьте новую строку для папки виртуальной среды, например / BasicProject / env . (Поскольку Visual Studio не отображает файл в Solution Explorer , откройте его напрямую с помощью команды меню File > Open > File . Вы также можете открыть файл из Team Explorer : на На странице настроек выберите Настройки репозитория , перейдите в раздел Игнорировать и файлы атрибутов , затем выберите ссылку Изменить рядом с .gitignore .)

Во-вторых, откройте командное окно, перейдите в папку, например BasicProject , которая содержит папку виртуальной среды, например env , и запустите git rm -r env . Затем зафиксируйте эти изменения из командной строки ( git commit -m 'Remove venv' ) или зафиксируйте со страницы Changes в Team Explorer .

Шаг 1-4: Изучите шаблонный код

После завершения создания проекта проверьте шаблонный код проекта Django (который снова совпадает с кодом, сгенерированным командой CLI django-admin startproject ).

1. В корне вашего проекта находится manage.py , административная утилита командной строки Django, которую Visual Studio автоматически устанавливает в качестве файла запуска проекта. Вы запускаете утилиту из командной строки, используя python manage.py [options] . Для обычных задач Django Visual Studio предоставляет удобные команды меню. Щелкните правой кнопкой мыши проект в Solution Explorer и выберите Python , чтобы просмотреть список. Вы встретите некоторые из этих команд в ходе этого руководства.

2. В вашем проекте есть папка с таким же именем, как у проекта. Он содержит основные файлы проекта Django:

   • __init.py : пустой файл, который сообщает Python, что эта папка является пакетом Python.

   • wsgi.py : точка входа для WSGI-совместимых веб-серверов для обслуживания вашего проекта. Обычно вы оставляете этот файл как есть, поскольку он обеспечивает перехватчики для производственных веб-серверов.

   • настроек.py : содержит настройки для проекта Django, которые вы изменяете в процессе разработки веб-приложения.

   • urls.py : содержит оглавление проекта Django, которое вы также изменяете в процессе разработки.

3. Как отмечалось ранее, шаблон Visual Studio также добавляет в проект файл requirements.txt , определяющий зависимость пакета Django. Наличие этого файла — это то, что предлагает вам создать виртуальную среду при первом создании проекта.

Вопрос: Может ли Visual Studio сгенерировать файл requirements.txt из виртуальной среды после установки других пакетов?

Ответ: Да. Разверните узел Python Environments , щелкните правой кнопкой мыши виртуальную среду и выберите команду Generate requirements.txt . Эту команду рекомендуется периодически использовать при изменении среды и фиксировать изменения в requirements.txt в системе управления версиями вместе с любыми другими изменениями кода, которые зависят от этой среды.Если вы настроили непрерывную интеграцию на сервере сборки, вы должны генерировать файл и фиксировать изменения всякий раз, когда вы изменяете среду.

Шаг 1-5: Запустите пустой проект Django

1. В Visual Studio выберите Debug > Start Debugging ( F5 ) или используйте кнопку Web Server на панели инструментов (вид браузера может отличаться):

2. Запуск сервера означает выполнение команды manage.py runserver , который запускает встроенный сервер разработки Django. Если Visual Studio сообщает Не удалось запустить отладчик с сообщением об отсутствии файла запуска, щелкните правой кнопкой мыши manage.py в обозревателе решений и выберите Установить как файл запуска .

3. При запуске сервера открывается окно консоли, в котором также отображается журнал сервера. Visual Studio автоматически открывает браузер по адресу http: // localhost: .Однако, поскольку в проекте Django нет приложений, Django показывает только страницу по умолчанию, чтобы подтвердить, что все, что у вас есть, работает нормально:

4. Когда вы закончите, остановите сервер, закрыв окно консоли или используя команду Debug > Stop Debug в Visual Studio.

Вопрос: Django — это не только фреймворк, но и веб-сервер?

Ответ: Да и нет. Django имеет встроенный веб-сервер, который используется в целях разработки.Этот веб-сервер используется при локальном запуске веб-приложения, например при отладке в Visual Studio. Однако при развертывании на веб-хосте Django вместо этого использует веб-сервер хоста. Модуль wsgi.py в проекте Django заботится о подключении к производственным серверам.

Вопрос: В чем разница между использованием команд меню «Отладка» и команд сервера в подменю Python проекта?

Ответ: В дополнение к командам меню Debug и кнопкам на панели инструментов вы также можете запустить сервер с помощью команд Python > Run server или Python > Run debug server commands в контекстном меню проекта.Обе команды открывают окно консоли, в котором вы видите локальный URL-адрес (localhost: port) для работающего сервера. Однако необходимо вручную открыть браузер с этим URL-адресом, а запуск сервера отладки не приводит к автоматическому запуску отладчика Visual Studio. Вы можете присоединить отладчик к запущенному процессу позже, если хотите, используя команду Debug > Attach to Process command.

Следующие шаги

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

Погрузитесь глубже

Django — полный стек Python

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

Например,
аутентификация,
URL-маршрутизация, a
шаблонизатор,
объектно-реляционный преобразователь (ORM),
и миграции схемы базы данных
все включены в структуру Django.
Сравните эту включенную функциональность с фреймворком Flask, для которого требуется
отдельная библиотека, такая как
Flask-Войти
для аутентификации пользователя.

Философия включения батарей и расширяемости — это просто две разные
способы решения проблемы построения каркаса. Ни одна из философий по своей сути не лучше
чем другой.

Почему Django — хороший выбор веб-фреймворка?

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

Я настоятельно рекомендую фреймворк Django в качестве отправной точки для новой сети Python.
разработчикам, потому что официальная документация и руководства являются одними из
лучше всего в разработке программного обеспечения.Во многих городах также есть Django-specific
такие группы, как Django District,
Джанго Бостон и
Сан-Франциско Джанго
чтобы новые разработчики могли получить помощь, когда они застряли.

Книги и руководства по Django

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

Django видео

Вы ищете видео по Django в дополнение к статьям? Есть специальный
раздел для Django и веб-разработки на
страница лучших видеороликов Python.

Темы Django среднего и продвинутого уровней

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

• 2 шарика Django
  Дэниела Гринфельда и Одри Рой стоит денег на вход, если
  вы серьезно относитесь к тому, чтобы научиться правильно разрабатывать веб-сайты Django.

• Разработка через тестирование с помощью Django, Django REST Framework и Docker
  в курсе подробно рассказывается, как настроить среду разработки с помощью Docker в
  чтобы создать и развернуть RESTful API на базе Python, Django,
  и Django REST Framework.

• Взаимодействие пользователя с формами
  объясняет общий ввод веб-форм, как Django обрабатывает формы через запросы POST,
  различные типы ввода, такие как CharFields, DateFields и EmailFields,
  и проверка этого ввода.

• Это руководство по оптимизации проекта Django, состоящее из трех частей, охватывает широкий спектр
  продвинутые темы, такие как
  Профилирование и настройки Django,
  работа с базами данных
  и кеширование.

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

• ментальных моделей для взглядов, основанных на классах
  предоставляет некоторые точки сравнения между представлениями на основе классов (CBV) и
  представления, основанные на функциях, и мнения авторов о том, как можно лучше
  понимать CBV.

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

• Руководство по ASGI в Django 3.0 и его производительности
  охватывает новый интерфейс асинхронного серверного шлюза (ASGI), который был
  введен в Django 3.0 и объясняет некоторые нюансы и подводные камни
  что вам следует учитывать, если вы решите использовать его для своих веб-приложений.

• REST API с Django: создание мощных веб-API с Python и Django
  Уильям С.Винсент — это книга для тебя
  если вы просто выходите за рамки основ Django и хотите получить
  ускорение с помощью Django REST Framework (DRF)
  и сервис-ориентированная архитектура (SOA). Он также погружается в более продвинутые
  такие темы, как аутентификация на основе токенов и разрешения.

• Учебное пособие по Django Stripe
  подробно описано, как быстро добавить Stripe для приема платежей в веб-приложении Django.

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

• Обновление Django
  предоставляет пошаговое руководство по обновлению ваших проектов Django ‘
  код.

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

• Как создавать собственные команды управления Django
  объясняет, как расширить управление по умолчанию .py список команд с вашим
  собственные пользовательские команды в ваших проектах. В учебнике есть множество замечательных
  примеры с ожидаемым результатом, чтобы упростить изучение и изучение
  пока прорабатываешь пост.

• Люк Плант пишет о
  его подход к классовым представлениям (CBV),
  которые часто вызывают жаркие споры в сообществе Django о том,
  экономят время или «слишком много магии» для фреймворка.

• Контрольный список приложений Django
  дает некоторые передовые правила для создания многоразовых приложений Django.

Миграции Django

• Пол Халлетт написал
  подробное руководство по обновлению приложения Django 1.7
  в блоге Twilio из своего опыта работы с django-twilio
  упаковка.

• Учебник по миграции Real Python
  исследует разницу между миграциями Юга и встроенными
  Миграции Django 1.7, а также то, как вы их используете.

• Серия Эндрю Пинкхэма «Обновление до Django 1.7» — отличное обучение
  материал для понимания того, что изменилось в этом основном выпуске и
  как адаптировать ваш проект Django.Часть 1,
  часть 2 и
  часть 3
  а также
  часть 4
  теперь все доступны для чтения.

• миграции Django без простоев
  показывает один из возможных способов выполнения миграции схемы в режиме онлайн с помощью
  Джанго.

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

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

Каналы Django

Каналы — это новый механизм в Django 1.9, представленный как отдельное приложение.
Они могут быть включены в базовую структуру в версии 2.0+. Каналы предоставляют
полнодуплексная связь в режиме реального времени между браузером и сервером
на основе WebSockets.

Тестирование Django

Django с фреймворками JavaScript MVC

Существуют ресурсы для фреймворков JavaScript MVC, такие как
Angular, React и Vue.js
на соответствующих страницах.

Руководства по Django ORM

Django обычно имеет собственный объектно-реляционный преобразователь (ORM).
называется «Django ORM». Узнать больше о
Django ORM на отдельной странице и в более широком смысле
ORM на
Страница объектно-реляционных сопоставителей Python.

Статические и медиафайлы

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

Шаблоны проектов Django

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

Примеры проектов Django с открытым исходным кодом

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

• Openduty — проверка статуса сайта
  и система оповещения, аналогичная PagerDuty.

• Courtside — это спортивная сеть.
  приложение написано и поддерживается автором PyCoder’s Weekly.

• Эти два веб-приложения системы интерактивного голосового ответа (IVR) Django
  репозитории часть 1 и
  Часть 2 покажет вам, как
  создать действительно крутое приложение Django. Также есть сопутствующий
  Сообщение блога
  с подробными объяснениями каждого шага.

• Тайга — управление проектами
  инструмент, созданный с использованием Django в качестве бэкэнда и AngularJS в качестве интерфейса.

• Chowist — это веб-приложение
  который воспроизводит основные функции Yelp и добавляет еще пару колокольчиков
  и свистки.

Открытый исходный код для изучения Django

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

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

django.apps.config AppConfig

django.conf
настройки,
urls.url

django.contrib.admin
filter.SimpleListFilter,

django.contrib.admin.helpers
ActionForm,
AdminForm

django.contrib.admin.options
IS_POPUP_VAR,
IncorrectLookupParameters,
ModelAdmin,
csrf_protect_m

джанго.contrib.admin.sites
Не зарегистрирован,
регистр,
сайт

django.contrib.auth
get_user_model,
декораторы login_required,
хешеры make_password

django.contrib.staticfiles
искатели,
.finders BaseFinder,
.finders BaseStorageFinder,
.finders найти,
.finders get_finders
.handlers StaticFilesHandler
место хранения
.storage CachedStaticFilesStorage,
.storage HashedFilesMixin,
.storage ManifestStaticFilesStorage,
.storage StaticFilesStorage,
.storage staticfiles_storage
.utils match_patterns

джанго.основной
кеш
чеки,
исключения,
Почта,
mail.send_mail,
mail.messages EmailMessage,
управление,
management.base BaseCommand,
сериализаторы,
сигналы,
подписание
валидаторы

django.core.exceptions
DisallowedRedirect,
FieldDoesNotExist,
FieldError,
Неправильно настроен,
Промежуточное ПО не используется,
NON_FIELD_ERRORS,
ObjectDoesNotExist,
Доступ запрещен,
SuspiciousFileOperation,
SuspiciousMultipartForm,
Ошибка проверки

django.db
DEFAULT_DB_ALIAS,
DataError,
Ошибка базы данных,
IntegrityError,
OperationalError,
ProgrammingError,
связь,
связи,
миграции
роутер
сделка
.бэкэнд-утилиты

django.db.migrations
RunPython,
.autodetector MigrationAutodetector,
.exceptions IrreversibleError,
.executor MigrationExecutor,
.loader MIGRATIONS_MODULE_NAME,
.loader MigrationLoader,
.operations.base Operation,
.state ProjectState

django.db.models
АвтоПоле,
BooleanField,
CharField,
DateField,
DateTimeField,
FileField,
Внешний ключ,
GenericIPAddressField,
ImageField,
IntegerField,
Модель,
PositiveIntegerField,
PositiveSmallIntegerField,
сигнал
SlugField,
SmallIntegerField,
Текстовое поле

джанго.db.models.query
BaseIterable,
EmptyQuerySet,
МодельIterable,
Предварительная выборка,
Q,
QuerySet,
prefetch_related_objects

django.db.models.query_utils
DeferredAttribute,
PathInfo,
Q

django.db.models.signals
post_delete,
post_save,
pre_delete,
pre_save

django.dispatch.dispatcher Сигнал

django.forms
Базовая форма,
BooleanField,
CharField,
CheckboxInput,
CheckboxSelectMultiple,
ChoiceField,
DateField,
DateInput,
DateTimeField,
EmailField,
Поле,
FileInput,
FilePathField,
Форма,
Скрытый ввод,
ImageField,
IntegerField,
СМИ,
MediaDefiningClass,
ModelChoiceField,
МодельФорма,
ModelMultipleChoiceField,
MultipleChoiceField,
Выбирать,
SelectMultiple,
TypedChoiceField,
Ошибка проверки

джанго.http
HttpResponse,
HttpResponseBadRequest,
HttpResponseForbidden,
HttpResponseNotModified,
Http404,
HttpResponsePermanentRedirect,
HttpResponseRedirect

django.shortcuts
get_list_or_404,
get_object_or_404,
перенаправление
оказывать,
resolve_url

django.template.base
Контекст,
FilterExpression,
Узел,
NodeList,
Парсер,
Шаблон,
TemplateSyntaxError,
TextNode,
Токен,
TokenType,
VariableDoesNotExist,
VariableNode,
token_kwargs

django.template.context
Контекст

джанго.template.defaultfilters
побег,
формат файла,
безопасно,
забивать
полоски
заглавие,
truncatechars

django.template.loader
get_template,
render_to_string,
select_template

django.template.loader_tags
BlockNode,
ExtendsNode,
IncludeNode

django.template.loaders.filesystem
Загрузчик

django.template.response
SimpleTemplateResponse,
TemplateResponse

django.urls
URLPattern,
URLResolver,
clear_url_caches,
get_callable,
get_resolver,
get_script_prefix,
включают,
дорожка,
re_path,
register_converter,
решать,
задний ход,
reverse_lazy

джанго.urls.exceptions
NoReverseMatch,
Резольвер404

django.utils
Формат даты,
dateparse,
datetime_safe,
форматы,
module_loading,
termcolors,
часовой пояс,
перевод,
дерево

django.utils.cache
add_ Never_cache_headers,
cc_delim_re,
patch_cache_control,
patch_response_headers,
patch_vary_headers

django.utils.crypto
constant_time_compare,
get_random_string

django.utils.datastructures
MultiValueDict

django.utils.dateparse
parse_datetime,
parse_duration

джанго.utils.dates
МЕСЯЦЫ

django.utils.datetime_safe
дата и время

django.utils.decorators
method_decorator

django.utils.deprecation
Промежуточное ПО
RenameMethodsBase

django.utils.duration
duration_string

django.utils.encoding
DjangoUnicodeDecodeError,
filepath_to_uri,
force_bytes,
force_str,
force_text,
iri_to_uri,
is_protected_type,
smart_bytes,
smart_str,
smart_text,
uri_to_iri

django.utils.formats
get_format,
localize_input,
sanitize_separators

джанго.utils.functional
LazyObject,
Обещать,
SimpleLazyObject,
keep_lazy,
ленивый,
total_ordering,
обертывания

django.utils.html
conditional_escape,
побег,
escapejs,
format_html,
format_html_join,
mark_safe,
smart_urlquote,
strip_tags

django.utils.http
base36_to_int,
http_date,
int_to_base36,
is_safe_url,
не цитировать
url_has_allowed_host_and_scheme,
urlencode,
urlquote,
urlunquote

django.utils.ipv6
clean_ipv6_address

django.utils.itercompat
is_iterable

джанго.utils.module_loading
autodiscover_modules,
import_string,
module_has_submodule

django.utils.numberformat
формат

django.utils.safestring
SafeData,
SafeText,
mark_safe

django.utils.termcolors
раскрашивать

django.utils.text
Truncator,
capfirst
format_lazy,
get_text_list,
get_valid_filename,
забивать

django.utils.timezone
get_current_timezone,
поставить в известность,
Теперь,
timedelta

django.utils.translation
LANGUAGE_SESSION_KEY,
активировать,
deactivate_all,
get_language,
get_language_from_request,
gettext,
gettext_lazy,
ngettext,
переопределить
pgettext,
pgettext_lazy,
ugettext,
ugettext_lazy,
ungettext,
ungettext_lazy

джанго.utils.version
get_complete_version

django.views
csrf
.debug get_default_exception_reporter_filter
.decorators.csrf csrf_exempt
.decorators.debug чувствительные_пост_параметры
.decorators.http require_GET,
.decorators.http require_POST

django.views.generic
CreateView,
DeleteView,
DetailView,
FormView,
Посмотреть список,
RedirectView,
TemplateView,
UpdateView,
Вид

django.views.generic.base
RedirectView,
TemplateResponseMixin,
TemplateView,
Вид

джанго.views.generic.detail
SingleObjectMixin

django.views.generic.edit
CreateView,
DeleteView,
DeletionMixin,
FormMixin,
FormView

django.views.generic.list
Посмотреть список,
MultipleObjectMixin

django.views.i18n
JavaScriptCatalog

django.views.static
обслуживать,
was_modified_since

Что вам нужно узнать дальше для вашего приложения Django?

Мое приложение работает, но выглядит ужасно. Как мне стилизовать пользовательский интерфейс?

Как мне интегрировать существующие веб-API в мое приложение?

Я создал веб-приложение Python, как мне теперь его развернуть?

mdn / django-locallibrary-tutorial: Сайт локальной библиотеки, написанный на Django; пример для модуля Django разработки на стороне сервера MDN: https: // developer.mozilla.org/en-US/docs/Learn/Server-side/Django.

GitHub — mdn / django-locallibrary-tutorial: веб-сайт локальной библиотеки, написанный на Django; пример для модуля Django разработки на стороне сервера MDN: https://developer.mozilla.org/en-US/docs/Learn/Server-side/Django.

Файлы

Постоянная ссылка

Не удалось загрузить последнюю информацию о фиксации.

Тип

Имя

Последнее сообщение фиксации

Время фиксации

Учебник для сайта «Локальная библиотека», написанный на Django.

Для получения подробной информации об этом проекте см. Соответствующую домашнюю страницу руководства по MDN.

Обзор

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

В настоящее время реализованы следующие основные функции:

• Есть макеты книг, книжные копии, жанр, язык и авторы.
• Пользователи могут просматривать список и подробную информацию о книгах и авторах.
• Пользователи с правами администратора могут создавать модели и управлять ими. Оптимизирован админ (базовая регистрация присутствует в admin.py, но закомментирована).
• Библиотекари могут продлевать зарезервированные книги

Быстрый старт

Чтобы запустить этот проект локально на вашем компьютере:

1. Настройте среду разработки Python.
   Мы рекомендуем использовать виртуальную среду Python.
2. Предполагая, что у вас есть установка Python, выполните следующие команды (если вы работаете в Windows, вы можете использовать py или py -3 вместо python для запуска Python):

     pip3 install -r требования.текст
   python3 manage.py makemigrations
   python3 manage.py перенести
   python3 manage.py collectstatic
   python3 manage.py test # Запустить стандартные тесты. Все это должно пройти.
   python3 manage.py createduperuser # Создать суперпользователя
   сервер запуска python3 manage.py
     

3. Откройте в браузере адрес http://127.0.0.1:8000/admin/ , чтобы открыть сайт администратора
4. Создайте несколько тестовых объектов каждого типа.
5. Откройте вкладку http://127.0.0.1:8000 , чтобы увидеть основной сайт с новыми объектами.

Вы не можете выполнить это действие в настоящее время.

Вы вошли в систему с другой вкладкой или окном. Перезагрузите, чтобы обновить сеанс.
Вы вышли из системы на другой вкладке или в другом окне. Перезагрузите, чтобы обновить сеанс.

.