Django основы: Основы использования фреймворка django при построении Web-сайта

Содержание

Основы использования фреймворка django при построении Web-сайта

Александр Деревянко
Опубликовано 13.05.2010

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

Абстрагируясь от низкоуровневого процесса Web-строительства, django позволяет разработчикам быстро создавать основанные на базах данных динамичные Web-сайты. Одним из основных преимуществ django является переносимость созданных на ее основе продуктов в силу переносимости их базиса – языка высокого уровня Python.

Произносится слово django мягко, без выраженного звука «д», как «жан-го».

Django включает в себя Model View Controller (MVC) – инструмент, позволяющий разделить общую архитектуру на отдельные части. При этом управляющая логика разделена на три отдельных компонента так, что модификация одного из них оказывает минимальное воздействие на другие части. К таким компонентам относят разделяемые данные, логику и слои визуализации (view layers). В общем случае такая концепция позволяет разделить разработку информационного наполнения на уровне базы данных и разработку Web-страниц.

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

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

Изменение отображения содержимого в зависимости от принимаемого URL-запроса является многоступенчатым процессом. Когда django-сервер получает URL-запрос, он парсит его и, используя предыдущие установки шаблонов, определяет, какой участок кода Python будет выполняться для требуемого отображения.

Парсер шаблонов в django позволяет самостоятельно настраивать свои шаблоны, которые используют функции отображения Web-страниц при построении ответа на URL-запросы. Это позволяет разработчикам Python сфокусироваться на создании данных, которые будут отображаться, а программистам HTML – сфокусироваться на дизайне Web-страниц.

Конфигурирование settings.py файла

Основным конфигурационным файлом при построении Web-сайта на django является файл settings.py. При создании каждого нового проекта django автоматически добавляет в него новый файл settings.py в корневую директорию проекта. Файл содержит конфигурационные опции для баз данных, установленных приложений и другие многочисленные параметры. Обычно этот файл видоизменяется при задании глобальных конфигурационных свойств Web-сайта.

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

from django.conf import settings.py
if settings.MY_CUSTOM_SETTING:

Примечание. Не надо пытаться редактировать настройки файла settings.py «на лету», путем правки Python кода. Это может иметь непредвиденно плохой или неопределенный результат.

Использование утилиты manage.py

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

startproject – создание нового django-проекта. Создается директория со всеми необходимыми файлами проекта;
startapp – создание нового приложения для django-проекта;
syncdb – синхронизация данных модели проекта с SQL-базой данных, поддерживающей проект;
runserver – старт сервера разработки;
shell – запуск оболочки интерпретатора Python для доступа к данным проекта, включая и базу данных;
dbshell – запуск SQL-клиента командной строки для доступа к базе данных.

Как правило, утилита используется из корневой директории проекта. Более подробно об этой утилите можно узнать на сайте http://www.djangoproject.com/documentation/django-admin.

Сервер разработки django

Django поставляется с встроенным легким HTTP-сервером для тестирования разрабатываемых проектов. После установки django не нужно будет искать и разворачивать какой-либо иной Web-сервер для тестирования кода. Встроенный сервер тратит мало системных ресурсов и очень функционален для апробации нового сайта.

Для старта сервера необходимо, находясь в корневой директории проекта, выполнить команду: python manage.py runserver.

Примечание. Для остановки сервера нажмите комбинацию клавиш Ctrl+Break или Ctrl+C.

Административный интерфейс

Django поставляется с удобным административным интерфейсом, позволяющим создавать, изменять и просматривать данные в административном контексте. Доступ к административному интерфейсу возможен из Web-браузера при введении URL вида: http://127.0.0.1:8000/admin/. При этом открывается окно, как показано на рисунке 4.

Рисунок 4.

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

Установка фреймворка django

До начала установки django необходимо убедиться в том, что в системе установлена версия Python 2.3 или выше. Получить Python можно по адресу http://www.python.org/download. После этого необходимо убедиться, что в системе установлена СУБД MySQL. Наличие какой бы то ни было СУБД в системе не является обязательным условием для установки и настройки django. В этой статье будет использоваться в качестве примера СУБД MySQL, поэтому будем считать, что она уже установлена и настроена.

Django можно получить с сайта разработчиков и воспользоваться либо официальным релизом, либо версией для разработчиков. В первом случае нужно скачать дистрибутив с http://www.djangoproject.com/download, а во втором – воспользоваться SVN следующим образом:

svn co http://code.djangoproject.com/svn/django/trunk django_src

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

import django django.VERSION.

Выполнение последней команды должно показать в консоли интерпретатора вывод информации о версии django, что свидетельствует о правильном процессе установки.

Во втором случае нужно распаковать скачанный тарбол командой:

tar xzvf Django-version.tar.gz

затем выполнить серию команд:

cd Django-version
python setup.py install
sudo python setup.py install (linux)
import django
django.VERSION

В результате в консоли интерпретатора мы должны получить номер версии фреймворка. (рисунок 1), что тоже свидетельствует о нормальном ходе процесса.

Рисунок 1.

Создание первого проекта на django

Рассмотрим создание простого проекта, производя все действия по конфигурированию из командной строки системы Ubuntu Linux.

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

Создайте директорию с именем iFriends (так будет называться проект примера).

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

python django-admin.py startproject iFriends.

Эта команда создаст новый проект и поместит в него все необходимые файлы. Затем следует запустить HTTP-сервер разработки.

Запуск сервера разработки

Для запуска HTTP-сервера, обеспечивающего разработку проекта, исполните команду:

python manage.py runserver

Правильный процесс запуска ознаменуется соответствующей строкой в консоли и записью о нулевом количестве ошибок.

Примечание. Если при выполнении этой команды возникнет ошибка, говорящая о том, что порт для сервера уже занят другим приложением (рисунок 2), то повторите команду, назначив другой порт HTTP-серверу: python manage.py runserver 0.0.0.0:9000, что заставит сервер прослушивать все имеющиеся в системе ip-адреса по порту 9000.

Рисунок 2.

Доступ к серверу можно проверить при переходе в браузере по URL: http://127.0.0.1:8000/ или (в последнем случае) http://127.0.0.1:9000/.

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

Рисунок 3.

Создание и конфигурирование базы данных

До начала конфигурирования БД необходимо обеспечить в MySQL поддержку именования таблиц буквами верхнего регистра. Для этого надо открыть файл <django installation path>/django/db/backends/__init__.py и в него добавить:

uses_case_insensitive_names = True

Конфигурирование БД состоит из ряда SQL-директив, написанных ниже:

CREATE DATABASE iFriendsDB;
USE iFriendsDB;
CREATE USER 'dAdmin'@'localhost' IDENTIFIED BY 'test';
GRANT ALL ON *.* TO 'dAdmin'@'localhost';

После создания пользовательской учетной записи и базы данных для django, нужно сконфигурировать файл settings.py для задания базовых настроек. Этот файл представляет собой скрипт на языке Python, который в процессе своего выполнения сконфигурирует все основные параметры проекта. Задайте в файле settings.py следующие установки:

DATABASE_ENGINE = 'mysql'
DATABASE_NAME = 'iFriendsDB'
DATABASE_USER = 'dAdmin'
DATABASE_PASSWORD = 'test'
DATABASE_HOST = ''
DATABASE_PORT = ''

Синхронизация данных проекта с базой данных

Процесс синхронизации создает в базе данных все необходимые таблицы для поддержки проекта. Внесите в settings.py следующие изменения:

INSTALLED_APPS = (
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.sites',
)

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

Вначале остановите HTTP-сервер разработки. Затем перейдите в рутовую директорию проекта iFriends. Находясь там, введите команду в консоли:

python manage.py syncdb.

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

Установка приложения

Теперь нужно установить приложение, которое будет использовать настроенные и синхронизированные данные в СУБД. В качестве примера зададим имя этому приложению как People. Оно должно хранить данные о пользователях создаваемого сайта.

Находясь в рутовой директории проекта iFriend, выполните команду в консоли:

python manage.py startapp People

Эта команда создаст новое приложение с именем People, что выразится в появлении новой поддиректории People внутри iFriend и серии файлов __init__.py models.py и views.py.

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

from django.db import models

class Person(models.Model):
    name = models.CharField('name', maxlength=200)
    email = models.EmailField('Email', blank=True)
    headshot = models.ImageField(upload_to='img', blank=True)
    text = models.TextField('Desc', maxlength=500, blank=True)
    def __str__(self):
        return '%s' % (self.name)

Активизация модели Person

Для активизации модели Person нужно внести некоторые изменения в файл iFriends\settings.py. В раздел INSTALLED_APPS внести:

	INSTALLED_APPS = (
        'django.contrib.auth',
        'django.contrib.contenttypes',
        'django.contrib.sessions',
        'django.contrib.sites',
        'iFriends.People',
)

затем сохранить файл и выполнить синхронизацию с базой данных:

python manage.py syncdb

процесс синхронизации создаст необходимые таблицы в базе iFriends для приложения People.

Добавление данных, используя API

Здесь будет рассмотрен процесс использования django shell и интерфейса базы данных для объекта Person в таблицу People. Django shell представляет собой Python shell, дающую возможность получить доступ к API базы данных, используя при этом django как посредника.

Нужно перейти в рут-каталог проекта iFriends. Затем открыть django shell командой:

python manage.py shell

после чего импортировать класс Person из People-пакета:

from iFriends.People.models import Person

Затем создать объект Person с именем “p”:

p = Person(name="<your name>", email="<your eMail>")

и сохранить его:

p.save()

Далее, используя функцию Person.objects.all(), проверить факт создания этого объекта:

lst = Person.objects.all()
print lst

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

Конфигурирование URLConfFile

Теперь рассмотрим конфигурирование URLConfFile, который задает порядок доступа к установленному приложению через Web. URLConfFile представляет собой Python-скрипт, который описывает специфические просмотрщики или «вьюхи» (views), доступные через вводимые в браузере URL. Когда django-сервер получает такой URL-запрос, он парсит запрос на шаблоны, содержащиеся в URLConfFile. Потом этот запрос транслируется в специфическую Python-функцию, которая и исполняет views.py-файл.

Местонахождение URLConfFile задается в параметре ROOT_URLCONF файла settings.py. По умолчанию местонахождением является рут-каталог проекта.

Отредактируем файл iFriends\urls.py, внеся в строку с urlpatterns следующий код:

urlpatterns = patterns('',
    (r'^People/$', 'iFriends.People.views.index')
)

Затем файл можно сохранить.

После редактирования URLConfFile нужно добавить «вьюхи» (views) в приложение.

Создание простого view

Откроем для редактирования iFriends/People/views.py. Добавим в этот файл следующий код:

from django.shortcuts import HttpResponse
from iFriends.People.models import Person

def index(request):
    html = "<h2>People</h2><HR>"
    return HttpResponse(html)

После этого файл можно сохранить. Затем надо сменить каталог на корневой для проекта iFriends и там дать команду на запуск HTTP-сервера разработки:

 python manage.py runserver.

В браузере перейти по URL: http://127.0.0.1:8000/People ,где можно будет увидеть Web-страницу, как на рисунке 5.

Рисунок 5.

Таким образом, был создан django-проект с именем iFriends, в рамках которого сконфигурирован доступ в СУБД MySQL. Затем создано приложение с именем People, добавлен класс Person, а в базу был внесен объект Person. Затем было сконфигурировано поведение URL-парсера для поддержки «вьюхи» и добавлен необходимый код, который в рамках этой «вьюхи» отображал список объектов класса Person.

Выводы

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

Ресурсы для скачивания

Django введение — Изучение веб-разработки

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

Требования:	Базовая компьютерная грамотность. Общее понимание server-side website programming, и в частности, механики client-server interactions in websites.
Задача:	Узнать, что такое Django, какие функции он предоставляет, и основные строительные блоки приложения Django.

Что есть Django?

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

Django помогает писать программное обеспечение, которое будет:

Полным

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

Разносторонним

Django может быть (и был) использован для создания практически любого типа веб-сайтов — от систем управления контентом и wiki до социальных сетей и новостных сайтов. Он может работать с любой клиентской средой и может доставлять контент практически в любом формате (включая HTML, RSS-каналы, JSON, XML и т.д.). Сайт, который вы сейчас читаете, создан с помощью Django!

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

Безопасным

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

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

Django, по умолчанию, обеспечивает защиту от многих уязвимостей, включая SQL-инъекцию, межсайтовый скриптинг, подделку межсайтовых запросов и кликджекинг (см. Website security для получения дополнительной информации об этих атаках).

Масштабируемым

Django использует компонентную “shared-nothing” архитектуру (каждая её часть независима от других и, следовательно, может быть заменена, либо изменена). Четкое разделение между частями означает, что Django может масштабироваться при увеличении трафика путем добавления оборудования на любом уровне: серверы кэширования, серверы баз данных или серверы приложений. Одни из самых загруженных сайтов успешно масштабировали Django (например, Instagram и Disqus).

Удобным в сопровождении

Код Django написан с использованием принципов и шаблонов проектирования, которые поощряют создание поддерживаемого и повторно используемого кода. В частности, в нем используется принцип «Don’t Repeat Yourself» (DRY, не повторяйся), поэтому нет ненужного дублирования, что сокращает объем кода. Django также способствует группированию связанных функциональных возможностей в повторно используемые «приложения» и, на более низком уровне, группирует связанный код в модули (в соответствии с шаблоном Model View Controller (MVC)).

Переносным

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

Как он появился?

Django был разработан в период с 2003 по 2005 год командой, которая занималась созданием и обслуживанием газетных веб-сайтов. После создания нескольких сайтов, команда начала повторно использовать множество общего кода и шаблонов проектирования. Этот общий код эволюционировал в веб-фреймворк «Django», как open-source проект в Июле 2005 года.

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

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

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

Насколько популярен Django?

Нет никаких доступных и окончательных оценок популярности серверных фреймворков (хотя сайты, подобные Hot Framework, пытаются оценить популярность, используя такие механизмы, как подсчет количества проектов на GitHub и вопросов на StackOverflow для каждой платформы). Лучший вопрос — «Достаточно ли Django популярен, чтобы избежать проблем непопулярных платформ?». Продолжает ли он развиваться? Можете ли вы получить помощь, если вам это нужно? Найдёте ли вы работу, если вы изучите Django?

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

Django используют такие крупные сайты, как Disqus, Instagram, Knight Foundation, MacArthur Foundation, Mozilla, National Geographic, Open Knowledge Foundation, Pinterest, и Open Stack (источник: домашняя страница Django).

Является ли Django гибким?

Веб-фрейморки часто можно поделить на «гибкие» и «негибкие».

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

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

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

Как выглядит код Django?

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

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

URLs: Хотя можно обрабатывать запросы с каждого URL-адреса с помощью одной функции, гораздо удобнее писать отдельную функцию для обработки каждого ресурса. URL-mapper используется для перенаправления HTTP-запросов в соответствующее представление на основе URL-адреса запроса. URL-mapper также может извлекать данные из URL-адреса в соответствии с заданным шаблоном и передавать их в соответствующую функцию в виде аргументов.
View: Представление (view) — это функция обработчика запросов, которая получает HTTP-запросы и возвращает ответы. View имеет доступ к данным через модели (необходимым для удовлетворения запросов и делегирования ответа в шаблоны).
Models: Модели представляют собой объекты Python, которые определяют структуру данных приложения и предоставляют механизмы для управления (добавления, изменения, удаления) и выполнения запросов в базу данных.
Templates: Template (шаблон) — это текстовый файл определяющий структуру или разметку страницы (например HTML страницы), с полями для подстановки используемыми для представления актуального содержимого. View может динамически создавать HTML страницы, используя HTML шаблоны и заполняя их данными из модели (model). Шаблон может быть использован для определения структуры файлов любых типов, не обязательно HTML.

Заметка: Django реализует уровневую архитектуру «Model View Template (MVT)». Она имеет много общего с более известной архитектурой Model View Controller.

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

Отправка запроса в правильное view (urls.py)

Сопоставитель URL-адресов обычно хранится в файле urls.py. В примере ниже сопоставитель (urlpatterns) определяет список соответствия между определенными URL-шаблонами и соотвествующими функциями отображения (view). Если полученный HTTP запрос подходит под определенный шаблон ( такой как r'^$', ниже), то будет вызвана ассоциированная функция отображения (такая как views.index) и передана в запрос.

urlpatterns = [
    url(r'^$', views.index),
    url(r'^([0-9]+)/$', views.best),
]

Note: Немного Python:

Объект urlpatterns является списком функций url(). В Python, списки определяются с помощью квадратных скобок. Элементы разделены запятыми и могут содержать необязательную завершающую запятую. Например: [item1, item2, item3,].
Странный на вид синтаксис шаблона известен как регулярное выражение (regular expression). Мы о нем поговорим позже!
Второй аргумент функции url() это другая функция, которая будет вызвана, когда шаблон будет удачно сопоставлен. Обозначение views.index обозначает, что будет вызвана функция index(), которая может быть найдена в модуле под названием views (т.е. в файле views.py).

Обработка запроса (views.py)

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

В приведенном ниже примере показана минимальная функция представления index(), которая могла быть вызвана нашим преобразователем URL в предыдущем разделе. Как и все функции представления, она получает объект HttpRequest в качестве параметра (request) и возвращает объект HttpResponse. В этом случае мы ничего не делаем с запросом, и наш ответ просто возвращает жестко запрограммированную строку. Мы покажем вам запрос, который делает что-то более интересное в следующем разделе.

## filename: views.py (Django view functions)

from django.http import HttpResponse

def index(request):
    # Получить HttpRequest - параметр запроса
    # Выполнить операции, используя информацию из запроса.
    # Вернуть HttpResponse 
    return HttpResponse('Hello from Django!')

Заметка: Немного Python:

Модули Python это библиотеки функций, сохраненные в различных файлах, которые мы можем использовать в нашем коде. Здесь мы импортируем только объект HttpResponse из django.http модуля, таким образом мы можем использовать его в нашем отображении (view): from django.http import HttpResponse . Так же есть другие способы импортирования некоторых или всех объектов модуля.
Функции объявляются с помощью ключевого слова def как показано выше, с именованными параметрами, перечисленными в скобках после имени функции; строка завершается двоеточием. Заметьте, что следующие строки содержат отступы. Отступы важны, так как они определяют какие строки кода находятся внутри конкретного блока (обязательные отступы — это ключевая особенность Python и одна из причин, почему код на Python так легко читать).

Отображения (View) обычно сохранены в файле views.py.

Определение данных модели (models.py)

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

В приведенном ниже фрагменте кода показана очень простая модель Django для объекта Team . Класс Team наследуется от класса models.Model. Он определяет имя команды и командный уровень в качестве полей символов и задает максимальное количество символов, которые должны быть сохранены для каждой записи. Team_level может быть одним из нескольких значений, поэтому мы определяем его как поле выбора и предоставляем сопоставление между отображаемыми вариантами и хранимыми данными вместе со значением по умолчанию.

# filename: models.py

from django.db import models 

class Team(models.Model): 
    team_name = models.CharField(max_length=40) 

    TEAM_LEVELS = (
        ('U09', 'Under 09s'),
        ('U10', 'Under 10s'),
        ('U11', 'Under 11s'),
        ...  #список других командных уровней 
    )
    team_level = models.CharField(max_length=3,choices=TEAM_LEVELS,default='U11')

Заметка: Немного Python’а:

Python поддерживает «объектно-ориентированное программирование», стиль программирования, в котором мы организуем наш код в объекты, которые включают связанные данные и функции для работы с этими данными. Объекты также могут наследовать / расширять / выводить из других объектов, позволяя совместное поведение между связанными объектами. В Python мы используем ключевое слово class , чтобы определить «скелет» для объекта. Мы можем создать несколько конкретных экземпляров типа объекта на основе модели в классе.
Так например, мы имеем класс Team, который происходит от класса Model. Это означает, что эта модель будет содержать все методы модели, но мы также можем дать ей специализированные возможности. В нашей модели мы определяем поля нашей базы данных, в которой будем хранить данные, присваивая им конкретные имена. Django использует эти определения, включая имена полей, для создания основной базы данных.

Запросы данных (views.py)

Модель Django предоставляет простой API запросов для поиска в базе данных. Поиск может осуществляться по нескольким полям одновременно с использованием разных критериев (таких как exact, case-insensitive, greater than и т.д.), и может поддерживать сложные выражения (например, вы можете указать поиск в командах U11, у которых есть имя команды, начинающееся с «Fr» или заканчивается на «al»).

Фрагмент кода показывает функцию view (обработчик ресурсов) для отображения всех команд U09. Жирная строка показывет как мы можем использовать модель API запросов для того, чтобы отфильтровать все записи где поле team_level в точности содержит текст ‘U09’ (обратите внимание, как эти критерии передаются функции filter() в качестве аргумента с именем поля и типом соответствия, разделенным двойным подчеркиванием: team_level__exact).

## filename: views.py

from django.shortcuts import render
from .models import Team 

def index(request):
    list_teams = Team.objects.filter(team_level__exact="U09")
    context = {'youngest_teams': list_teams}
    return render(request, '/best/index.html', context)

Данная функция использует функцию render() для того, чтобы создать HttpResponse, который будет отправлен назад браузеру. Эта функция является ярлыком; она создает HTML-файл, комбинируя указанный шаблон HTML и некоторые данные для вставки в шаблон (предоставляется в переменной с именем «context«). В следующем разделе мы покажем как данные вставляются в шаблон для создания HTML-кода.

Отображение данных (HTML templates)

Системы шаблонов позволяют указать структуру выходного документа, используя заполнители для данных, которые будут заполнены при создании страницы. Шаблоны часто используются для создания HTML, но также могут создавать другие типы документов. Django поддерживает как собственную систему шаблонов, так и другую популярную библиотеку Python под названием Jinja2 (она также может быть использована для поддержки других систем, если это необходимо).

Фрагмент кода показывает, как выглядит HTML-шаблон, вызванный функцией render() из предыдущего раздела. Этот шаблон был написан в предположении, что во время рендеринга он будет иметь доступ к переменной списка, называемой youngest_teams (содержащейся в контекстной переменной внутри функции render() выше). Внутри скелета HTML мы имеем выражение, которое сначала проверяет, существует ли переменная youngest_teams, а затем выполняет итерацию в цикле for. На каждой итерации шаблон отображает значение team_name каждой команды в элементе <li>.

## filename: best/templates/best/index.html

<!DOCTYPE html>
<html lang="en">
<body>

 {% if youngest_teams %}
    <ul>
    {% for team in youngest_teams %}
        <li>{{ team.team_name }}</li>
    {% endfor %}
    </ul>
{% else %}
    <p>No teams are available.</p>
{% endif %}

</body>
</html>

Что еще можно сделать?

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

Формы: HTML-формы используются для сбора пользовательских данных для обработки на сервере. Django упрощает создание, проверку и обработку формы.
Аутентификация пользователя и разрешения: Django включает надежную систему аутентификации и авторизации пользователей, которая была построена с учетом безопасности.
Кэширование: Создание динамического контента намного более интенсивно (и медленнее), чем обслуживание статического содержимого. Django обеспечивает гибкое кэширование, чтобы вы могли хранить всю или часть отображаемой страницы, для того, чтобы она не вызывалась повторно, за исключением случаев, когда это необходимо.
Админ-панель: Административная панель в Django включена по умолчанию при создании приложения с использованием основного каркаса. Это упрощает управление админкой администраторам сайта для создания, редактирования и просмотра любых данных на вашем сайте.
Сериализация данных (преобразование в последовательную форму): Django упрощает сериализацию и обслуживание ваших данных в таких форматах как XML или JSON. Это может быть полезно при создании веб-сервисов (веб-сайтов, которые исключительно служат для использования данных другими приложениями или сайтами и сами ничего не отображают) или при создании веб-сайта, на котором клиентский код обрабатывает весь рендеринг данных.

Резюме

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

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

Django — Начало работы с Django

замечания

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

легкий и автономный веб-сервер для разработки и тестирования
система сериализации и проверки формы, которая может переводить между HTML-формами и значениями, подходящими для хранения в базе данных
система шаблонов, использующая концепцию наследования, заимствованную из объектно-ориентированного программирования
структура кэширования, которая может использовать любой из нескольких методов кеширования для классов промежуточного программного обеспечения, которые могут вмешиваться на разных этапах обработки запроса и выполнять пользовательские функции
внутренняя диспетчерская система, которая позволяет компонентам приложения передавать события друг другу через заранее определенные сигналы
система интернационализации, включая перевод собственных компонентов Django на различные языки
система сериализации, которая может создавать и читать XML и / или JSON-представления экземпляров модели Django
система для расширения возможностей механизма шаблонов
интерфейс к встроенной платформе тестирования Python

Версии

Версия	Дата выхода
1,11	2017-04-04
1,10	2016-08-01
1,9	2015-12-01
1,8	2015-04-01
1,7	2014-09-02
1,6	2013-11-06
1,5	2013-02-26
1.4	2012-03-23
1,3	2011-03-23
1.2	2010-05-17
1,1	2009-07-29
1,0	2008-09-03

Полный пример приветствия.

Шаг 1 Если у вас уже установлен Django, вы можете пропустить этот шаг.

pip install Django

Шаг 2 Создайте новый проект

django-admin startproject hello

Это создаст папку с именем hello которая будет содержать следующие файлы:

hello/
├── hello/
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
└── manage.py

Шаг 3 Внутри модуля hello (папка, содержащая __init.py__ ) создайте файл с именем views.py :

hello/
├── hello/
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   ├── views.py  <- here
│   └── wsgi.py
└── manage.py

и добавьте следующее содержание:

from django.http import HttpResponse

def hello(request):
    return HttpResponse('Hello, World')

Это называется функцией просмотра.

Шаг 4 Отредактируйте hello/urls.py следующим образом:

from django.conf.urls import url
from django.contrib import admin
from hello import views

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^$', views.hello)
]

который связывает функцию вида hello() с URL-адресом.

Шаг 5 Запустите сервер.

python manage.py runserver

Шаг 6

Просмотрите http://localhost:8000/ в браузере, и вы увидите:

Привет, мир

Дружественный к развертыванию проект с поддержкой Docker.

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

Вы можете найти подходящий шаблон проекта Django на GitHub .

PROJECT_ROOT
├── devel.dockerfile
├── docker-compose.yml
├── nginx
│   └── project_name.conf
├── README.md
├── setup.py
└── src
    ├── manage.py
    └── project_name
        ├── __init__.py
        └── service
            ├── __init__.py
            ├── settings
            │   ├── common.py
            │   ├── development.py
            │   ├── __init__.py
            │   └── staging.py
            ├── urls.py
            └── wsgi.py

Мне нравится сохранять service каталог с именем service для каждого проекта, благодаря Dockerfile я могу использовать один и тот же Dockerfile во всех моих проектах. Разделение требований и настроек уже хорошо описано здесь:
Использование нескольких файлов требований
Использование нескольких настроек

С предположением, что только разработчики используют Docker (не каждый dev ops доверяет ему в эти дни). Это может быть devel.dockerfile dev:

FROM python:2.7
ENV PYTHONUNBUFFERED 1

RUN mkdir /run/service
ADD . /run/service
WORKDIR /run/service

RUN pip install -U pip
RUN pip install -I -e .[develop] --process-dependency-links

WORKDIR /run/service/src
ENTRYPOINT ["python", "manage.py"]
CMD ["runserver", "0.0.0.0:8000"]

При добавлении только требований будет использоваться кеш докеров при построении — вам нужно будет только перестроить при изменении требований.

Docker compomp пригодится — особенно когда у вас есть несколько сервисов для локального запуска. docker-compose.yml :

version: '2'
services:
  web:
    build:
      context: .
      dockerfile: devel.dockerfile
    volumes:
      - "./src/{{ project_name }}:/run/service/src/{{ project_name }}"
      - "./media:/run/service/media"
    ports:
      - "8000:8000"
    depends_on:
      - db
  db:
    image: mysql:5.6
    environment:
      - MYSQL_ROOT_PASSWORD=root
      - MYSQL_DATABASE={{ project_name }}
  nginx:
    image: nginx
    ports:
      - "80:80"
    volumes:
      - "./nginx:/etc/nginx/conf.d"
      - "./media:/var/media"
    depends_on:
      - web

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

server {
    listen   80;
    client_max_body_size 4G;
    keepalive_timeout 5;

    location /media/ {
        autoindex on;
        alias /var/media/;
    }

    location / {
        proxy_pass_header Server;
        proxy_set_header Host $http_host;
        proxy_redirect off;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Scheme $scheme;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Ssl on;
        proxy_connect_timeout 600;
        proxy_read_timeout 600;
        proxy_pass http://web:8000/;
    }
}

$ cd PROJECT_ROOT
$ docker-compose build web  # build the image - first-time and after requirements change
$ docker-compose up  # to run the project
$ docker-compose run --rm --service-ports --no-deps  # to run the project - and be able to use PDB
$ docker-compose run --rm --no-deps <management_command>  # to use other than runserver commands, like makemigrations
$ docker exec -ti web bash  # For accessing django container shell, using it you will be inside /run/service directory, where you can run ./manage shell, or other stuff
$ docker-compose start  # Starting docker containers
$ docker-compose stop  # Stopping docker containers

Концепции Django

django-admin — это инструмент командной строки, который поставляется с Django. Он поставляется с несколькими полезными командами для начала и управления проектом Django. Команда такая же, как ./manage.py , с той разницей, что вам не нужно находиться в каталоге проекта. DJANGO_SETTINGS_MODULE быть установлена переменная среды DJANGO_SETTINGS_MODULE .

Проект Django представляет собой кодовую базу Python, содержащую файл настроек Django. Проект может быть создан администратором Django с помощью команды django-admin startproject NAME . Обычно проект имеет файл manage.py на верхнем уровне и файл корневого URL-адреса, называемый urls.py manage.py — это версия django-admin конкретного проекта и позволяет запускать команды управления в этом проекте. Например, чтобы запустить проект локально, используйте python manage.py runserver . Проект состоит из приложений Django.

Приложение Django представляет собой пакет Python, содержащий файл моделей (по умолчанию — models.py ) и другие файлы, такие как URL-адреса приложений и представления. Приложение можно создать с помощью команды django-admin startapp NAME (эта команда должна запускаться из вашей директории проекта). Чтобы приложение было частью проекта, оно должно быть включено в список INSTALLED_APPS в settings.py . Если вы использовали стандартную конфигурацию, Django поставляется с несколькими приложениями своих собственных предустановленных приложений, которые будут обрабатывать вас как аутентификацию . Приложения могут использоваться в нескольких проектах Django.

Django ORM собирает все модели баз данных, определенные в models.py и создает таблицы базы данных на основе этих классов моделей. Для этого сначала настройте свою базу данных, изменив параметр DATABASES в settings.py . Затем, как только вы определили свои модели баз данных , запустите python manage.py makemigrations за которым следует python manage.py migrate чтобы создать или обновить схему вашей базы данных на основе ваших моделей.

Пример простого файла Hello World

В этом примере вы покажете минимальный способ создания страницы Hello World в Django. Это поможет вам понять, что django-admin startproject example проекта django-admin startproject example основном создает кучу папок и файлов и что вам не обязательно нужна эта структура для запуска вашего проекта.

Создайте файл с именем file.py

Скопируйте и вставьте следующий код в этот файл.

 import sys
 
 from django.conf import settings
 
 settings.configure(
     DEBUG=True,
     SECRET_KEY='thisisthesecretkey',
     ROOT_URLCONF=__name__,
     MIDDLEWARE_CLASSES=(
         'django.middleware.common.CommonMiddleware',
         'django.middleware.csrf.CsrfViewMiddleware',
         'django.middleware.clickjacking.XFrameOptionsMiddleware',
     ),
 )
 
 from django.conf.urls import url
 from django.http import HttpResponse
 
 # Your code goes below this line.

 def index(request):
     return HttpResponse('Hello, World!')

 urlpatterns = [
     url(r'^$', index),
 ]

 # Your code goes above this line
 
 if __name__ == "__main__":
     from django.core.management import execute_from_command_line
 
     execute_from_command_line(sys.argv)

Перейдите к терминалу и запустите файл с помощью этой команды python file.py runserver .
Откройте браузер и перейдите к 127.0.0.1:8000 .

Запуск проекта

Django — это основа веб-разработки на основе Python. Django 1.11 (последняя стабильная версия) требует установки Python 2.7 , 3.4 , 3.5 или 3.6 . Предполагая, что pip доступен, установка выполняется так же просто, как выполнение следующей команды. Имейте в виду, что, опуская версию, как показано ниже, будет установлена последняя версия django:

$ pip install django

Для установки конкретной версии django предположим, что версия django 1.10.5 , выполните следующую команду:

$ pip install django==1.10.5

Веб-приложения, созданные с использованием Django, должны находиться в проекте Django. Вы можете использовать команду django-admin для запуска нового проекта в текущем каталоге:

$ django-admin startproject myproject

где myproject — это имя, которое однозначно идентифицирует проект и может состоять из цифр , букв и подчеркиваний .

Это создаст следующую структуру проекта:

myproject/
    manage.py
    myproject/
        __init__.py
        settings.py
        urls.py
        wsgi.py

Чтобы запустить приложение, запустите сервер разработки

$ cd myproject
$ python manage.py runserver

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

По умолчанию команда runserver запускает сервер разработки на внутреннем IP- runserver на порту 8000 . Этот сервер будет автоматически перезагружаться при внесении изменений в ваш код. Но если вы добавите новые файлы, вам придется вручную перезапустить сервер.

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

$ python manage.py runserver 8080

Если вы хотите изменить IP-адрес сервера, передайте его вместе с портом.

$ python manage.py runserver 0.0.0.0:8000

Обратите внимание, что runserver работает только для отладки и локального тестирования. Специализированные серверные программы (такие как Apache) всегда должны использоваться в производстве.

Добавление приложения Django

Проект Django обычно содержит несколько apps . Это просто способ структурирования вашего проекта в небольших поддерживаемых модулях. Чтобы создать приложение, перейдите в свою папку проекта (где находится файл manage.py ) и запустите команду startapp (измените myapp на все, что вы хотите):

python manage.py startapp myapp

Это создаст для вас папку myapp и некоторые необходимые файлы, например models.py и views.py .

Чтобы Django узнал о myapp , добавьте его в свой файл settings.py :

# myproject/settings.py

# Application definition
INSTALLED_APPS = [
    ...
    'myapp',
]

Папка-структура проекта Django может быть изменена в соответствии с вашими предпочтениями. Иногда папка проекта переименовывается в /src чтобы избежать повторения имен папок. Типичная структура папок выглядит так:

Виртуальная среда

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

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

Python 3.3+ уже включает стандартный модуль venv , который вы обычно можете назвать pyvenv . В средах, где команда pyvenv недоступна, вы можете получить доступ к тем же функциям, напрямую вызвав модуль как python3 -m venv .

Чтобы создать виртуальную среду:

$ pyvenv <env-folder>
# Or, if pyvenv is not available
$ python3 -m venv <env-folder>

Если вы используете Python 2, вы можете сначала установить его как отдельный модуль из pip:

$ pip install virtualenv

Затем создайте среду, используя команду virtualenv :

$ virtualenv <env-folder>

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

Чтобы «активировать» виртуальную среду (любую версию Python)

Linux:

$ source <env-folder>/bin/activate

Windows:

<env-folder>\Scripts\activate.bat

Это изменяет ваше приглашение, чтобы указать, что виртуальная среда активна. (<env-folder>) $

Отныне все, установленное с помощью pip будет установлено в вашу виртуальную папку env, а не в масштабе всей системы.

Чтобы deactivate виртуальную среду, deactivate :

(<env-folder>) $ deactivate

Вы также можете рассмотреть возможность использования virtualenvwrapper, который делает создание и активацию virtualenv очень удобным, а также отделяет его от вашего кода:

# Create a virtualenv
mkvirtualenv my_virtualenv

# Activate a virtualenv
workon my_virtualenv

# Deactivate the current virtualenv
deactivate

В средах, где вам нужно обрабатывать несколько версий Python, вы можете использовать virtualenv вместе с pyenv-virtualenv:

# Create a virtualenv for specific Python version
pyenv virtualenv 2.7.10 my-virtual-env-2.7.10

# Create a vritualenv for active python verion
pyenv virtualenv venv34

# Activate, deactivate virtualenv
pyenv activate <name>
pyenv deactivate

При использовании virtualenvs часто бывает полезно установить PYTHONPATH и DJANGO_SETTINGS_MODULE в сценарии postactivate .

#!/bin/sh
# This hook is sourced after this virtualenv is activated

# Set PYTHONPATH to isolate the virtualenv so that only modules installed
# in the virtualenv are available
export PYTHONPATH="/home/me/path/to/your/project_root:$VIRTUAL_ENV/lib/python3.4"

# Set DJANGO_SETTINGS_MODULE if you don't use the default `myproject.settings`
# or if you use `django-admin` rather than `manage.py`
export DJANGO_SETTINGS_MODULE="myproject.settings.dev"

Часто также полезно указать путь к проекту в специальном файле .project расположенном в вашей базе <env-folder> . При этом каждый раз, когда вы активируете свою виртуальную среду, она будет изменять активный каталог на указанный путь.

Создайте новый файл с именем <env-folder>/.project . Содержимое файла должно быть ТОЛЬКО в качестве пути к каталогу проекта.

/path/to/project/directory

Теперь инициируйте свою виртуальную среду (используя source <env-folder>/bin/activate или workon my_virtualenv ), и ваш терминал изменит каталоги в каталог /path/to/project/directory .

Django DetailView — основы использования | Статьи о Джанго

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

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

Давайте вернемся к первому из них и познакомимся с общим DetailView.

Базовая модель

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


from django.db import models


class Post(models.Model):
    active = models.BooleanField(verbose_name='активный', default=False)
    title = models.CharField(max_length=255, verbose_name='заголовок')
    slug = models.SlugField(unique=True)
    body = models.TextField(verbose_name='текст')
    lead = models.TextField(verbose_name='кратко')

    def __str__(self):
        return self.title

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

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


from django.views.generic.detail import DetailView

from .models import Post


class PostDetailView(DetailView):
    model = Post

Регистрация представления в urls.py

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


from django.urls import path
from .views import PostDetailView

urlpatterns = [
    ... 
    path('blog/<slug:slug>/', PostDetailView.as_view(), name='post-detail'),
    ...
]

Регистрация представления по полю pk

Представление может быть просто зарегистрировано по полю pk, которое видно ниже.


from django.urls import path
from .views import PostDetailView

urlpatterns = [
    ... 
    path('blog/<int:pk>/', PostDetailView.as_view(), name='post-detail'),
    ...
]

Общий вид DetailView построен настолько умно, что по умолчанию обеспечивает вызов как по pk, так и по slug.

Пользовательский slug_field

Бывает, что вам нужно добавить отображение к существующей модели. Если в этой модели есть поле SlugField, но оно не называется slug, и вы хотите создать адрес по этому полю, вам не нужно паниковать или комбинировать. Просто переопределите атрибут slug_field.


class PostDetailView(DetailView):
    model = Post
    slug_field = 'custom_slug_field'

Шаблон

По умолчанию Django ищет шаблон в каталоге <application_name>/<model_name>_detail.html, т.е. blog/post_detail.html. Давайте создадим этот упрощенный шаблон.


<h2>{{ object.title }}</h2>
<span>{{ object.lead }} </span>
<div>{{ object.body|safe }} </div>

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

Загрузка пользовательских объектов

Иногда вам нужно загрузить пользовательский объект, например, из внешнего API. Это можно сделать очень просто, переписав метод get_object. Давайте рассмотрим простой пример и вручную загрузим объект по полю slug. (В среднем это имеет смысл, потому что такая поддержка встроена, но я не хочу усложнять ее)


from .exceptions import PostDoesNotExist


class PostDetailView(DetailView):

    def get_object(self, queryset=None):
        slug = self.kwargs.get(self.slug_url_kwarg, None)
        try:
            return queryset.get(slug=slug)
        except PostDoesNotExist:
            raise Http404('Ох, нет объекта;)')

Использование пользовательских запросов

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

Давайте посмотрим пример того, как отображать только активные записи. Предположим, у этого объекта есть ссылка на фото.


class PostDetailView(DetailView):
    model = Post
    queryset = Post.objects.filter(active=True).select_related('photo')

Метод get_queryset

Если вы не хотите использовать атрибут по разным причинам, это также возможно. В представлении есть метод get_queryset, который по умолчанию возвращает значение из атрибута, описанного ранее, но вы можете легко перезаписать его и вернуть свой собственный листинг. Это полезно, если вы хотите загружать объекты не из базы данных, а, например, после некоторого API. Ниже приведен пример простого переопределения такого метода.


from .api import PostApi


class PostDetailView(DetailView):
    model = Post
    
    def get_queryset(self):
        api = PostApi()
        return api.get_posts()

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

Практическое переопределение метода get_queryset

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


urlpatterns = [
    ... 
    path('blog/<slug:category_slug>/<slug:slug>/', PostDetailView.as_view(), name='post-detail'),
    ...
]

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

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


class PostDetailView(DetailView):
    model = Post
    
    def get_queryset(self):
        category = self.kwargs.get('category_slug', '')
        q = super().get_queryset()
        return q.filter(category__slug=category).select_related('category')

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

Наименование объекта в шаблоне

Возможно, вы заметили, что объект в шаблоне называется object. Иногда это может сбивать с толку, и вам может понадобиться изменить его. Ничего сложного, просто переопределите атрибут context_object_name. Отныне в шаблоне вы можете использовать новое имя вашего объекта.


class PostDetailView(DetailView):
    model = Post
    context_object_name = 'post'

После такого изменения мы можем улучшить шаблон


<h2>{{ post.title }}</h2>
<span>{{ post.lead }} </span>
<div>{{ post.body|safe }} </div>

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

Альтернативный шаблон

Что, если я хочу иметь два разных представления, например, потому что они поддерживают разную логику, но способ отображения данных идентичен? Я боролся с этим много раз и, поверьте мне, со старыми версиями django, такими как 1.2 (хоть и давно это было), было много путанницы. Однако сегодня просто переопределите атрибут template_name для любого шаблона.


class PostDetailView(DetailView):
    model = Post
    template_name = 'my_template.html'

Декораторы на представлениях-классах

Джанго имеет широкий спектр различных декораторов. От того, который может отключить кеш на определенных страницах, до того, который заставляет вас войти в систему. Чтобы закрепить такой декоратор, поместите его в метод отправки в представлении или в urls.py. Две возможности ниже


from django.views.decorators.cache import never_cache


class PostDetailView(DetailView):
    model = Post

    @never_cache
    def dispatch(self, *args, **kwargs):
        return super(PostDetailView, self).dispatch(*args, **kwargs)

Если вы не хотите перезаписывать какой-либо метод, давайте сделаем это прямо в файле urls.py.


from django.views.decorators.cache import never_cache

urlpatterns = [
    ... 
    path('blog/<slug:slug>/', never_cache(PostDetailView.as_view()), name='post-detail'),
    ...
]

Дополнительные данные в контексте

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

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


from django.views.decorators.cache import never_cache


class PostDetailView(DetailView):
    model = Post
    extra_context = {'latest': Post.objects.all()[:3]}

Давайте напишем последние записи в шаблоне:


<h2>{{ post.title }}</h2>-
<span>{{ post.lead }} </span>
<div>{{ post.body|safe }} </div>

<ul>
{% for post in latest %} <li>{{ post.pk}}. {{ post.title }}</li>{% endfor %}
</ul>

Бонус — загрузка объектов без slug и pk

Чаще всего для извлечения объекта вам нужен ключ, то есть какое-то значение, после которого мы должны определить объект. Но это не всегда так, о чем свидетельствует загрузка чего-либо из сессии или из самого запроса. Хорошим примером является загрузка пользователя, например. Посмотрим на пример:


urlpatterns = [
    ...
    path('blog/', UserDetailView.as_view(), name='user-detail'),
    ...
]

Небольшое обновление в представлении:


from django.views.generic.detail import DetailView
from django.shortcuts import get_object_or_404                                  


class UserDetailView(DetailView):
    
    def get_object(self):
        return get_object_or_404(User, id=self.request.user.id)
        # return get_object_or_404(User, id=self.request.session.get('user'))

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

Итоги

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

Перевод статьи https://ddeby.pl/blog/django-detailview-podstawowy-widok-generyczny

Поделитесь с другими:

краткое руководство по интернационализации / Блог компании RUVDS.com / Хабр

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

Часть того, о чём тут пойдёт речь, применимо к локализации любых Python-проектов. Разобрав основы, мы поговорим об ускорении работ по интернационализации. В частности — о применении платформы Phrase.

Предполагается, что у читателя этого материала имеется работающее Django-приложение, и то, что у него установлен пакет gettext (установить его можно, например, командой pip install gettext). Если вы раньше не пользовались Django (популярным веб-фреймворком, основанным на Python), то вам, возможно, будет полезно сначала взглянуть на это официальное руководство, а потом вернуться к данной статье.

Базовые настройки рабочей среды

Итак, представим, что у вас имеется Django-проект mysite, и приложение, называемое polls. Структура проекта должна выглядеть примерно так:

/
    manage.py
    mysite/
        __init__.py
        settings.py
        urls.py
        wsgi.py
    polls/
        migrations/
        __init__.py
        admin.py
        models.py
        tests.py
        views.py

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

# mysite/settings.py
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'UTC'
USE_I18N = True
USE_L10N = True
USE_TZ = True

Интернационализация шаблонов

Теперь нужно пометить все строки, которые должны быть переведены на разные языки. Представим, что у вас имеется следующий файл шаблона polls/templates/polls/index.html:

<!-- polls/templates/polls/index.html -->
<h2>Welcome to our site!</h2>
<p>Here you find polls.</p>

Этот файл нужно переработать следующим образом:

<!-- polls/templates/polls/index.html -->
{% load i18n %}
<h2>{% trans 'WelcomeHeading' %}</h2>
<p>{% trans 'WelcomeMessage' %}</p>

Здесь мы импортировали пакет для локализации и заменили весь текст на конструкции вида trans 'SomeTranslationKeyName'. Кроме того, в качестве альтернативы такому подходу, можно воспользоваться текстами перевода, применяемыми по умолчанию, в виде ключей перевода. При таком подходе у вас всегда будет хороший текст, задаваемый по умолчанию, в том случае, если для некоего ключа не будет доступного перевода.

Интернационализация в Python-коде

Если требуется локализовать строки, находящиеся внутри Python-кода (например, в файле polls/views.py), нужно импортировать в файл функцию ugettext. Ей, что вполне нормально, можно назначить псевдоним _. Вот как будет выглядеть локализованный вариант простой функции из файла views.py:

# polls/views.py
from django.http import HttpResponse
from django.utils.translation import ugettext as _
def index(request):
    output = _('StatusMsg')
    return HttpResponse(output)

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

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

django-admin makemessage -l de

Здесь de можно заменить на код локали для языка, который планируется добавить в приложение. В нашем примере выполнение этой команды приведёт к созданию gettext-файла polls/locale/de/LC_MESSAGES/django.po следующего содержания:

# polls/locale/de/LC_MESSAGES/django.po
...
#: templates/polls/index.html:3
msgid "WelcomeHeading"
msgstr ""
#: templates/polls/index.html:4
msgid "WelcomeMessage"
msgstr ""

Теперь в этот файл можно ввести переводы строк:

# polls/locale/de/LC_MESSAGES/django.po
...
#: templates/polls/index.html:3
msgid "WelcomeHeading"
msgstr "Willkommen auf unserer Seite!"
#: templates/polls/index.html:4
msgid "WelcomeMessage"
msgstr "Hier findet Ihr Umfragen."

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

$ django-admin compilemessages

Выполнять эту команду нужно, опять же, в директории polls.

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

# mysite/settings.py
LANGUAGE_CODE = 'de'

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

Ускорение процесса локализации приложений с использованием Phrase

Если вы используете Phrase для организации работ по локализации приложений, то вам, на самом деле, не нужно вручную создавать и редактировать *.po-файлы! Вам достаточно создать и перевести ключи WelcomeHeading и WelcomeMessage в Phrase и использовать функцию экспорта для загрузки *.po-файлов.

Если у вас установлено наше средство командной строки Phrase Client, то ваша работа упрощается ещё сильнее. Достаточно создать в корневой директории проекта конфигурационный файл .phraseapp.yml со следующим содержимым:

# .phraseapp.yml
phraseapp:
  access_token: <your access token>
  project_id: <your project's id on PhraseApp>
  file_format: po
  pull:
    targets:
        file: "polls/locale/<locale_code>/LC_MESSAGES/django.po

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

phraseapp pull && django-admin compilemessages

Благодаря этому будут обновлены все переводы проекта.

Кроме того, ещё больше упростить работу может использование в вашем Django-проекте нашего редактора In-Context Editor. Для этого достаточно установить django-phrase с помощью pip:

pip install django-phrase

Затем достаточно отредактировать шаблоны, при работе с которыми вы планируете использовать In-Context-Editor:

<!-- polls/templates/polls/index.html -->
{% load i18n %}
{% load phrase_i18n %}
{% phrase_javascript %}
<h2>{% trans 'WelcomeHeading' %}</h2>
<p>{% trans 'WelcomeMessage' %}</p>

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

И наконец, в конфигурационный файл нужно добавить следующее:

# mysite/settings.py
PHRASE_ENABLED = True
PHRASE_PROJECT_ID = 'YOUR_PROJECT_ID'
PHRASE_PREFIX = '{{__'
PHRASE_SUFFIX = '__}}'

После этого всё будет готово к работе.

Выбор локалей

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

# mysite/settings.py
from django.utils.translation import ugettext_lazy as _
...
MIDDLEWARE_CLASSES = (
    ...,
    'django.middleware.locale.LocaleMiddleware',
    ...,
)
...
LANGUAGE_CODE = 'en-us'
LANGUAGES = (
    ('en-us', _('English')),
    ('de', _('German')),
)

При таком подходе, если у пользователя будет локаль German, он увидит вариант перевода de. В противном случае в качестве перевода по умолчанию будет использоваться en-us. Проверить правильность работы этого механизма можно с помощью curl:

curl http://localhost:8000/polls -H "Accept-Language: de"

Эта команда должна вернуть примерно следующее:

<h2>Willkommen auf unserer Seite!</h2>
<p>Hier findet Ihr Umfragen.</p>

Итоги

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

Уважаемые читатели! Как вы подходите к интернационализации ваших Python-проектов?

основные операции Django, работа с Django

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

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

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

Что такое Django?

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

Установка Django

Лучше установить Django в виртуальном окружении — virtualenv или pipenv, где ваш проект будет изолирован от других. Большинство команд, приведённых ниже, предполагают, что вы работаете в виртуальной среде.

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

venv:

$ python –m venv ll_env

$ python –m venv ll_env

pipenv:

Активировать среду

venv, macOS and Linux:

$ source ll_env/bin/activate

$ source ll_env/bin/activate

venv, Windows:

> ll_env\Scripts\activate

> ll_env\Scripts\activate

pipenv:

Установить Django в активную среду

venv:

(ll_env)$ pip install Django

(ll_env)$ pip install Django

pipenv:

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

Чтобы начать работу, мы создадим новый проект и базу данных, а затем запустим веб-сервер. Во всех примерах ниже проект будет называться learning_log.

Создать новый проект

$ django-admin startproject learning_log .

$ django-admin startproject learning_log .

Создать базу данных

$ python manage.py migrate

$ python manage.py migrate

Посмотреть проект

После выполнения этой команды вы можете просмотреть проект по адресу http://localhost:8000/.

$ python manage.py runserver

$ python manage.py runserver

Создать новое приложение

Проект Django состоит из одного или нескольких приложений.

$ python manage.py startapp learning_logs

$ python manage.py startapp learning_logs

Перезапуск сервера разработки

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

$ python manage.py runserver

$ python manage.py runserver

Работа с моделями

Данные в проекте Django представлены в виде набора моделей — объектов Python, определяющих структуру хранения этих данных.

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

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

from django.db import models
class Topic(models.Model):
«»»Тема, которую изучает пользователь.»»»
text = models.CharField(max_length=200)
date_added = models.DateTimeField(
auto_now_add=True)

def __str__(self):
return self.text

from django.db import models

class Topic(models.Model):

«»»Тема, которую изучает пользователь.»»»

text = models.CharField(max_length=200)

date_added = models.DateTimeField(

auto_now_add=True)

def __str__(self):

return self.text

Активация модели

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

INSTALLED_APPS = [
# Мои приложения.
‘learning_logs’,
# Дефолтные приложения Django.
‘django.contrib.admin’,
]

INSTALLED_APPS = [

# Мои приложения.

‘learning_logs’,

# Дефолтные приложения Django.

‘django.contrib.admin’,

]

Миграция базы данных

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

$ python manage.py makemigrations learning_logs

$ python manage.py migrate

$ python manage.py makemigrations learning_logs

$ python manage.py migrate

Создание суперпользователя

Суперпользователь — это учётная запись с доступом ко всем компонентам проекта.

$ python manage.py createsuperuser

$ python manage.py createsuperuser

Регистрация модели

Вы можете зарегистрировать свою модель в панели администратора Django, чтобы упростить работу с данными в проекте. Для этого измените файл admin.py. Панель администратора находится по адресу http://localhost:8000/admin/.

from django.contrib import admin
from .models import Topic

admin.site.register(Topic)

from django.contrib import admin

from .models import Topic

admin.site.register(Topic)

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

Новая модель может использовать существующую модель. Атрибут ForeignKey устанавливает связь между экземплярами двух связанных моделей. Обязательно мигрируйте базу данных после добавления новой модели в ваше приложение.

Определение модели с внешним ключом:

class Entry(models.Model):
topic = models.ForeignKey(Topic,
on_delete=models.CASCADE)
text = models.TextField()
date_added = models.DateTimeField(
auto_now_add=True)

def __str__(self):
return f»{self.text[:50]}…»

class Entry(models.Model):

topic = models.ForeignKey(Topic,

on_delete=models.CASCADE)

text = models.TextField()

date_added = models.DateTimeField(

auto_now_add=True)

def __str__(self):

return f»{self.text[:50]}…»

Создание простой домашней страницы

Пользователи взаимодействуют с проектом через веб-страницы. Мы создадим простую домашнюю страницу без данных. Любой странице обычно нужен URL, представление (view) и шаблон (template). Представление — функция Python, которая принимает HTML-запрос и возвращает ответ на него. Шаблон — специальный набор инструкций, позволяющий динамически генерировать HTML.

Сопоставление URL-адресов проекта

Основной файл проекта urls.py сообщает Django, где найти файлы urls.py, связанные с каждым приложением в проекте.

Django. Полное руководство | WebForMySelf.com

Урок 1
Введение
12:21

Урок 2
Установка виртуального окружения
13:16

Урок 3
Установка Django
17:04

Урок 4
Приложения в Django
10:22

Урок 5
MVC в Django
10:09

Урок 6
Контроллеры и маршруты
20:34

Урок 7
Модели
29:33

Урок 8
Миграции
18:48

Урок 9
Основы работы с моделями. CRUD. Часть 1
19:12

Урок 10
Основы работы с моделями. CRUD. Часть 2
19:35

Урок 11
Шаблоны
27:17

Урок 12
Админка Django
24:53

Урок 13
Связи моделей
30:06

Урок 14
Внешний вид шаблона
16:19

Урок 15
Директивы, теги и фильтры. Часть 1
27:27

Урок 16
Директивы, теги и фильтры. Часть 2
27:44

Урок 17
Параметры в URL-запросах
19:10

Урок 18
Имена маршрутов
08:18

Урок 19
Наследование шаблонов
22:00

Урок 20
Пользовательские теги шаблона
22:48

Урок 21
Обратное разрешение адресов
26:22

Урок 22
Статические файлы
17:25

Урок 23
Работа с формами. Часть 1
26:36

Урок 24
Работа с формами. Часть 2
37:37

Урок 25
Работа с формами. Часть 3
17:41

Урок 26
Кастомные валидаторы
10:23

Урок 27
Класс ListView. Часть 1
17:53

Урок 28
Класс ListView. Часть 2
11:19

Урок 29
Класс DetailView
09:10

Урок 30
Класс CreateView
12:04

Урок 31
Подключение MySQL
16:57

Урок 32
Django ORM. Часть 1
19:27

Урок 33
Django ORM. Часть 2
11:20

Урок 34
Django ORM. Часть 3
20:25

Урок 35
Django ORM. Часть 4
14:18

Урок 36
Django ORM. Часть 5
11:27

Урок 37
Django ORM. Часть 6
17:45

Урок 38
Django ORM. Часть 7
20:09

Урок 39
Django ORM. Часть 8
14:04

Урок 40
Django Debug Toolbar
16:54

Урок 41
Кастомизация админки
27:57

Урок 42
Миксины
21:41

Урок 43
Постраничная навигация. Часть 1
21:41

Урок 44
Постраничная навигация. Часть 2
21:00

Урок 45
Регистрация. Часть 1
28:15

Урок 46
Регистрация. Часть 2
15:14

Урок 47
Авторизация
20:34

Урок 48
Отправка писем на Email
21:04

Урок 49
Визуальный редактор CKEditor
23:52

Урок 50
Капча
14:17

Урок 51
Кэширование
23:31

Основы Django — GeeksforGeeks

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

Почему именно Django?

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

Архитектура Django

Django основан на архитектуре MVT (модель-представление-шаблон). MVT — это шаблон программного обеспечения для разработки веб-приложений.

Структура

МВТ состоит из трех частей —

Модель : Модель будет действовать как интерфейс ваших данных. Он отвечает за сохранение данных. Это логическая структура данных всего приложения, представленная базой данных (обычно реляционными базами данных, такими как MySql, Postgres).

View : View — это пользовательский интерфейс — то, что вы видите в своем браузере при визуализации веб-сайта. Он представлен файлами HTML / CSS / Javascript и Jinja.

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

Чтобы узнать больше об архитектуре Django, посетите Django Project MVT Structure

Установка Django

Установите python3, если он не установлен в вашей системе (в соответствии с конфигурацией вашей системы и ОС) отсюда.Попробуйте загрузить последнюю версию python, на этот раз это python3.6.4.

Примечание — Установка Django в Linux и Mac аналогична, здесь я показываю это в Windows для Linux и Mac, просто откройте терминал вместо командной строки и выполните следующие команды.

Install pip- Откройте командную строку и введите следующую команду-

 python -m pip install -U pip

Установить виртуальную среду — Введите следующую команду в cmd-

 pip install virtualenv

Установить виртуальную среду — Настройка виртуальной среды позволит вам редактировать зависимости, которые обычно не допускаются в вашей системе.
Выполните следующие действия, чтобы настроить виртуальную среду:
Создайте виртуальную среду, указав эту команду в cmd-
virtualenv env_site
Измените каталог на env_site с помощью этой команды —
cd env_site
Перейдите в каталог сценариев внутри env_site и активируйте виртуальную среду —
cd скрипт
активировать

Установить Django- Установите django, введя следующую команду:
pip install django

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

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

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

Теперь посетите http: // localhost: 8000 /,

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

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

Чтобы создать базовое приложение в своем проекте Django, вам нужно перейти в каталог, содержащий manage.py и оттуда введите команду:
python manage.py startapp projectApp
Теперь вы можете увидеть структуру каталогов, как показано ниже:

Чтобы рассмотреть приложение в своем проекте, вам необходимо указать имя вашего проекта в списке INSTALLED_APPS, как показано ниже в settings.py:

УСТАНОВЛЕННЫЕ ПРИЛОЖЕНИЯ = [
'джанго.contrib.admin ' ,
'django.contrib.auth' ,
'django.contrib.contenttypes' ,
'django.contrib.sessions' ,
'django.contrib.messages' ,
'django.contrib.staticfiles' ,
«ProjectApp»
]

Итак, мы наконец создали приложение, но для рендеринга приложения с использованием URL-адресов нам необходимо включить приложение в наш основной проект, чтобы можно было отображать URL-адреса, перенаправленные на это приложение.Давайте исследуем это.
Перейдите к projectName-> projectName -> urls.py и добавьте ниже код в заголовок
из импорта django.urls включает
Теперь в списке шаблонов URL-адресов необходимо указать имя приложения для включения URL-адресов вашего приложения. Вот его код —
из django.contrib импорт админ
из django.urls import path, включая

шаблоны URL = [
путь ( 'admin /' , admin.site.urls),

путь (', включить ( "projectApp.urls" )),
]

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

Основная особенность Django Apps — независимость, каждое приложение функционирует как независимая единица поддержки основного проекта.Чтобы узнать больше о приложениях в Django, посетите Как создать приложение в Django?

Больше с Django —

Если вам нравится GeeksforGeeks и вы хотели бы внести свой вклад, вы также можете написать статью с помощью provide.geeksforgeeks.org или отправить ее по электронной почте на [email protected]. Посмотрите свою статью на главной странице GeeksforGeeks и помогите другим гикам.

Пожалуйста, улучшите эту статью, если вы обнаружите что-то неправильное, нажав на кнопку «Улучшить статью» ниже.

Теги статей:

.

Основы Django — Установка Django и настройка проекта и приложения

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

Часть 1 — Установка и настройка Django
Часть 2 — Создание модели базы данных
Часть 3 — API Django против сайта администратора
Часть 4 — Шаблоны и представления Django

К каждой части прилагается сопроводительное видео.Вы можете скачать исходный код через Github, который включает все четыре части. Я буду излагать это руководство с точки зрения Windows, но с точки зрения Mac OS X в значительной степени то же самое.

Это руководство следует нескольким первым разделам официального руководства по Django.

Видео — часть 1, часть 2, часть 3, часть 4

GitHub — https://github.com/mjhea0/django-tutorial

Джанго?

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

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

У вас установлен Python 2.7.
У вас установлен PIP. Для установки вам необходимо сначала установить инструменты настройки. Щелкните здесь, чтобы получить краткое руководство о том, как это сделать. Затем вы можете просто запустить команду easy_install pip из командной строки, чтобы установить PIP.

Содержание

Хорошо, приступим…

Часть 1 — Установка Django

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

— для установки Django в каталог пакетов вашего сайта.

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

  python C: \ Python27 \ Lib \ site-packages \ django \ bin \ django-admin.py startproject testproject

Ваш путь к django-admin.py может быть другим, поэтому при необходимости не забудьте изменить его. Также testproject — это имя созданного проекта. Не стесняйтесь называть это как хотите.

Далее вам нужно убедиться, что все настроено правильно. Для этого вы можете запустить сервер Django. Сначала перейдите в свой вновь созданный каталог (в моем случае testproject ), а затем запустите команду

  python manage.py runserver

Откройте новое окно браузера и перейдите по адресу http: // localhost: 8000 /. Если все настроено правильно, вы увидите экран «Добро пожаловать в Django».

Давайте настроим базу данных. Откройте настройки .py в каталоге testproject с помощью текстового редактора. (Я использую Notepad ++.) Добавьте sqlite3 в конец ключа Engine, а затем добавьте путь к ключу имени. Вы можете назвать базу данных как угодно, потому что, если база данных не существует, Django создаст ее на следующем шаге. Результаты должны выглядеть примерно так (в зависимости от вашего пути) —

  'ДВИГАТЕЛЬ': 'django.db.backends.sqlite3',
'ИМЯ': 'C: / Python27 / django / testproject / test.дб»,

(Да, используйте косую черту.)

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

Создайте суперпользователя. Я использовал admin в качестве имени пользователя и пароля.

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

Часть 2 — Создание модели базы данных

Начните с создания приложения.В командной строке перейдите в каталог testproject и введите команду

  python manage.py startapp книги

CD в каталог. Вы должны увидеть файл models.py . Этот файл используется для настройки сущностей и атрибутов вашей базы данных.
Откройте файл models.py в Notepad ++ и добавьте следующий код:

  Класс Книги (модели. Модель):
title = models.CharField (max_length = 150)
автор = модели.CharField (max_length = 100)
read = models.CharField (max_length = 3)

Этот код должен быть относительно понятным. Этот класс определяет поля базы данных — заголовок, автора и чтение. Данные в поле чтения будут либо «да», либо «нет» в зависимости от того, читали вы книгу или нет.

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

Сохраните файл.

Теперь откройте файл settings.py , прокрутите вниз до Installed Apps и добавьте имя приложения, books , к установленным приложениям, чтобы Django знал, как его включить. Раздел ваших установленных приложений должен выглядеть так:

  INSTALLED_APPS = (
    'Django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.sites',
    'django.contrib.messages',
    'django.contrib.staticfiles',
«книги»,
    # Раскомментируйте следующую строку, чтобы активировать админку:
    # 'django.contrib.admin',
    # Раскомментируйте следующую строку, чтобы включить документацию администратора:
    # 'django.contrib.admindocs',
)

Сохраните файл.

CD обратно в основную директорию проекта и запускаем команду —

  python manage.py sql books

— для отображения фактических операторов SQL для создания таблицы. Вы заметили первичный ключ?

Ваш результат должен выглядеть так:

  НАЧАТЬ;
СОЗДАТЬ ТАБЛИЦУ "books_books" (
    "id" целое НЕ NULL ПЕРВИЧНЫЙ КЛЮЧ,
    "title" varchar (150) NOT NULL,
    "автор" varchar (100) NOT NULL,
    "читать" varchar (3) NOT NULL
)
;
COMMIT;

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

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

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

Далее я покажу вам, как получить доступ к Django API для добавления данных в базу данных.

, часть 3 — API Django и сайт администратора

Сначала откройте командную строку, перейдите в каталог проекта и затем запустите команду

Это открывает для нас интерактивную среду.

Далее импортируйте свое приложение с помощью следующей команды —

  из книг.модели импорт Книги

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

  b = Книги (title = "Убить пересмешника", автор = "Харпер Ли", читать = "да")
b.save ()
b = Книги (title = "О дивный новый мир", автор = "Олдос Хаксли", прочтите = "да")
b.save ()
b = Книги (title =

приложений | Документация Django | Django

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

Проекты и приложения¶

Термин проект описывает веб-приложение Django. Проект Python
Пакет определяется в первую очередь модулем настроек, но обычно он содержит
другие вещи. Например, при запуске django-admin startproject mysite
вы получите каталог проекта mysite , который содержит mysite Python
пакет с настройками.py , urls.py , asgi.py и wsgi.py .
пакет проекта часто расширяется за счет включения таких вещей, как фикстуры, CSS и
шаблоны, не привязанные к конкретному приложению.

Корневой каталог проекта (тот, который содержит manage.py ) обычно
контейнер для всех приложений проекта, которые не установлены
по отдельности.

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

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

Важно понимать, что приложение Django — это набор кода.
который взаимодействует с различными частями фреймворка.Нет такой вещи, как
объект Application . Однако есть несколько мест, где Django нужно
взаимодействовать с установленными приложениями, в основном для настройки, а также для
самоанализ. Вот почему реестр приложений хранит метаданные в
Экземпляр AppConfig для каждого установленного приложения.

Нет никаких ограничений, что пакет проекта также не может считаться
приложение и модели и т. д. (для чего потребуется добавить его в
УСТАНОВЛЕННЫЕ ПРИЛОЖЕНИЯ ).

Настройка приложений¶

Чтобы настроить приложение, создайте подкласс AppConfig и поместите
пунктирный путь к этому подклассу в INSTALLED_APPS .

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

Если он определен, это пунктирный путь к AppConfig
подкласс для этого приложения.

Если нет default_app_config , Django использует базу
AppConfig класс.

default_app_config позволяет приложениям, предшествующим Django 1.7, например
django.contrib.admin , чтобы подписаться на функции AppConfig
не требуя от пользователей обновления их INSTALLED_APPS .

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

.

`4. Основы Django — Как танцевать с Django 1.7`

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

`4.1. Тестирование вашей установки`

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

Это напечатает номер версии Python и завершит работу. Если отображаемая версия отличается от 2.7.5, вам нужно будет вернуться к Разделу 3.2 и убедиться, что вы выполнили все необходимые шаги для своей операционной системы.

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

 $ python -c "import django; print (django.get_version ())"
1,7

Команда снова выполняет код в строке, указанной как часть переключателя -c.После импорта Django вы должны увидеть 1.7 внизу. Если вы видите другой набор чисел или встречаетесь с ошибкой Python ImportError, вернитесь к Разделу 3.2 или обратитесь к документации Django по установке Django для получения дополнительной информации. Если вы обнаружите, что у вас другая версия Django, возможно, в какой-то момент вы столкнетесь с проблемами. Определенно стоит убедиться, что у вас установлен Django 1.7.

`4.2. Создание вашего проекта Django`

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

$ django-admin.py startproject tango_with_django_project

Примечание

В Windows вам может потребоваться использовать полный путь к сценарию django-admin.py. т.е. python c: \ python27 \ scripts \ django-admin.py startproject tango_with_django_project, как это предлагается в StackOverflow.

Эта команда вызовет сценарий django-admin.py, который настроит для вас новый проект Django под названием tango_with_django_project.Обычно мы добавляем _project в конец наших каталогов проектов Django, чтобы точно знать, что они содержат, но соглашение об именах полностью зависит от вас.

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

другой каталог с тем же именем, что и ваш проект, tango_with_django_project; и
сценарий Python под названием manage.ру.

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

__init__.py, пустой скрипт Python, присутствие которого указывает интерпретатору Python, что каталог является пакетом Python;
settings.py, место для хранения всех настроек вашего проекта Django;
URL.py, скрипт Python для хранения шаблонов URL для вашего проекта; и
wsgi.py, скрипт Python, используемый для запуска вашего сервера разработки и развертывания вашего проекта в производственной среде.

Примечание

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

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

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

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

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

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

Проверка системы не выявила проблем (0 отключено).

У вас есть непримененные миграции; ваше приложение может не работать должным образом, пока они не будут применены.
Запустите python manage.py migrate, чтобы применить их.

01 октября 2014 года - 19:49:05
Django версии 1.7c2, используя настройки tango_with_django_project.настройки
Запуск сервера разработки по адресу http://127.0.0.1:8000/
Закройте сервер, нажав CONTROL-C.

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

Выполняемые операции:
  Применить все миграции: admin, contenttypes, auth, sessions
Выполняемые миграции:
  Применение contenttypes.0001_initial ... ОК
  Применение auth.0001_initial ... ОК
  Применяем admin.0001_initial ... ОК
  Применение sessions.0001_initial ... OK

#TODO (leifos): добавить описание команды migrate: из учебника django: команда migrate проверяет параметр INSTALLED_APPS и создает все необходимые таблицы базы данных в соответствии с настройками базы данных в вашем mysite / settings.py и миграции базы данных, поставляемые с приложением (мы рассмотрим их позже). Вы будете видеть сообщение для каждой применяемой миграции. Если вам интересно, запустите клиент командной строки для своей базы данных и введите dt (PostgreSQL), SHOW TABLES; (MySQL) или .schema (SQLite) для отображения таблиц, созданных Django.

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

Рисунок 1. Снимок экрана начальной страницы Django, который вы увидите при первом запуске сервера разработки.

Вы можете остановить сервер разработки в любое время, нажав CTRL + C в окне терминала. Если вы хотите запустить сервер разработки на другом порту или разрешить доступ к нему пользователям с других машин, вы можете сделать это, указав необязательные аргументы. Рассмотрим следующую команду:

$ python manage.py runserver : 5555

Выполнение этой команды заставит сервер разработки отвечать на входящие запросы через TCP-порт 5555. Вам нужно будет заменить на IP-адрес вашего компьютера.

При настройке портов маловероятно, что вы сможете использовать TCP-порт 80, поскольку он традиционно зарезервирован для HTTP-трафика. Кроме того, любой порт ниже 1024 считается вашей операционной системой привилегированным.

Хотя вы не будете использовать облегченный сервер разработки для развертывания приложения, иногда приятно иметь возможность продемонстрировать свое приложение на компьютере коллеги. Запуск сервера с IP-адресом вашего компьютера позволит другим пользователям вводить http: // : / и просматривать ваше веб-приложение.Конечно, это будет зависеть от того, как настроена ваша сеть. Могут быть прокси-серверы или брандмауэры, которые необходимо настроить, прежде чем это будет работать. Уточните у администратора сети, которую вы используете, если вы не можете просматривать сервер разработки удаленно.

Примечание

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

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

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

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

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

Для начала создайте новое приложение под названием Rango . Из каталога вашего проекта Django (например, / tango_with_django_project) выполните следующую команду.

 $ python manage.py startapp rango

Команда startapp создает новый каталог в корне вашего проекта.Неудивительно, что этот каталог называется rango — и в нем находятся еще пять скриптов Python:

еще один __init__.py, служащий той же цели, что обсуждался ранее;
models.py, место для хранения моделей данных вашего приложения, где вы указываете сущности и отношения между данными;
tests.py, где вы можете хранить ряд функций для тестирования кода вашего приложения; и
views.py, где вы можете хранить ряд функций, которые принимают запросы клиентов и возвращают ответы.
admin.py, где вы можете зарегистрировать свои модели, чтобы вы могли пользоваться некоторыми механизмами Django, которые создают для вас интерфейс администратора (см. #TODO (leifos): добавить ссылку на главу администратора)

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

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

 INSTALLED_APPS = (
    'Django.contrib.admin',
    «Django.contrib.авт»,
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    «Ранго»,
)

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

`4.4. Создание представления`

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

В вашей любимой среде IDE откройте файл views.py, расположенный в недавно созданном каталоге приложения rango. Удалите комментарий # Создайте здесь свои просмотры. так что теперь у вас есть пустой файл.

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

 из django.http import HttpResponse

def index (запрос):
    return HttpResponse («Ранго говорит: привет, мир!»)

Разбив три строки кода, мы рассмотрим следующие моменты создания этого простого представления.

Сначала мы импортируем объект HttpResponse из модуля django.http.
Каждое представление существует в файле views.py как набор отдельных функций. В этом случае мы создали только одно представление — index.
Каждое представление принимает по крайней мере один аргумент — объект HttpRequest, который также находится в модуле django.http. Соглашение гласит, что это именованный запрос, но вы можете переименовать его как хотите, если хотите.
Каждое представление должно возвращать объект HttpResponse.Простой объект HttpResponse принимает строковый параметр, представляющий содержимое страницы, которую мы хотим отправить клиенту, запрашивающему представление.

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

`4.5. Сопоставление URL-адресов`

Теперь в каталоге приложения rango нам нужно создать новый файл с именем urls.py. Содержимое файла позволит вам сопоставить URL-адреса вашего приложения (например,$ ‘, views.index, name =’ индекс ‘))

Этот код импортирует соответствующий механизм Django, который мы используем для создания сопоставлений URL-адресов. Импорт модуля представлений из rango также предоставляет нам доступ к нашему простому представлению, реализованному ранее, что позволяет нам ссылаться на представление в сопоставлении URL-адресов, которое мы создадим.

Для создания отображений мы используем кортеж. Чтобы Django мог выбрать ваши сопоставления, этот кортеж должен называться urlpatterns. Кортеж urlpatterns содержит серию вызовов django.$, что соответствует пустой строке. Любой URL-адрес, предоставленный пользователем, который соответствует этому шаблону, означает, что представление views.index () будет вызываться Django. Представлению будет передан объект HttpRequest в качестве параметра, содержащий информацию о запросе пользователя к серверу. Мы также используем необязательный параметр функции url () name, используя строку index в качестве связанного значения.

Примечание

Вы могли подумать, что сопоставление пустого URL-адреса довольно бессмысленно — какая польза от этого? Когда выполняется сопоставление с шаблоном URL, учитывается только часть исходной строки URL.Это связано с тем, что наш проект Django сначала обрабатывает исходную строку URL-адреса (например, http://www.tangowithdjango.com/rango/). После обработки он удаляется, а оставшееся передается для сопоставления с образцом. В этом случае ничего не останется — значит, будет соответствовать пустая строка!

Примечание

Параметр name является необязательным для функции django.conf.urls.url (). Это предусмотрено Django, чтобы вы могли отличать одно отображение от другого. Вполне вероятно, что два отдельных выражения сопоставления URL-адресов могут закончить вызов одного и того же представления.name позволяет вам различать их — что полезно для обратного сопоставления URL . Дополнительную информацию можно найти в официальной документации Django по этой теме.

Возможно, вы видели, что в каталоге конфигурации вашего проекта уже существует файл urls.py. Зачем делать еще одну? Технически, вы можете поместить в этот файл и URL-адресов приложений вашего проекта. Однако это считается плохой практикой, поскольку увеличивает взаимосвязь между вашими отдельными приложениями.Отдельный файл urls.py для каждого приложения позволяет вам устанавливать URL-адреса для отдельных приложений. С минимальным связыванием вы можете позже присоединить их к основному файлу urls.py вашего проекта.

Это означает, что нам нужно настроить urls.py нашего проекта tango_with_django_project и подключить наш основной проект к нашему приложению Rango.

Как мы это делаем? Все очень просто. Откройте файл urls.py проекта, который находится в каталоге конфигурации вашего проекта. В качестве относительного пути от каталога вашей рабочей области это будет файл / tango_with_django_project / tango_with_django_project / urls.Ранго /. Когда обнаруживается совпадение, оставшаяся часть строки URL передается и обрабатывается rango.urls (который мы уже настроили). Это делается с помощью функции include () из django.conf.urls. Думайте об этом как о цепочке, которая обрабатывает строку URL-адреса, как показано на рисунке. В этой цепочке домен удаляется, а оставшаяся часть строки URL-адреса (rango /) передается в проект tango_with_django, где он находит совпадение и удаляет rango / leave и пустую строку для передачи в rango приложения.Rango теперь пытается сопоставить пустую строку, что он и делает, а затем отправляет созданное нами представление index ().

Перезапустите сервер разработки Django и посетите http://127.0.0.1:8000/rango. Если все прошло хорошо, вы должны увидеть текст, который Ранго здоровается, мир !. Он должен выглядеть так, как на снимке экрана, показанном на рисунке.

Рисунок 2: Иллюстрация URL-адреса, показывающая, как разные части URL-адреса отвечают за разные файлы url.py.

Рисунок 3. Снимок экрана Google Chrome, на котором показана наша первая веб-страница на базе Django.Привет, Ранго!

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

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

`4.6. Основные рабочие процессы`

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

`4.6.1. Создание нового проекта Django`

Чтобы создать проект, запустите python django-admin.py startproject , где — это имя проекта, который вы хотите создать.

`4.6.2. Создание нового приложения Django`

Чтобы создать новое приложение, запустите $ python manage.py startapp , где — это имя приложения, которое вы хотите создать.
Сообщите своему проекту Django о новом приложении, добавив его в кортеж INSTALLED_APPS в файле settings.py вашего проекта.
В файле urls.py вашего проекта добавьте сопоставление с приложением.
В каталоге вашего приложения создайте URL-адреса.py для направления входящих строк URL в представления.
В файле view.py вашего приложения создайте необходимые представления, гарантируя, что они возвращают объект HttpResponse.

`4.7. Упражнения`

Поздравляем! У вас есть Rango. Это важный этап в работе с Django. Создание представлений и сопоставление URL-адресов с представлениями — это первый шаг на пути к разработке более сложных и удобных веб-приложений. Теперь попробуйте выполнить следующие упражнения, чтобы закрепить то, что вы узнали.

Измените процедуру и убедитесь, что вы следуете тому, как URL-адреса сопоставляются с представлениями.
Теперь создайте новое представление с именем about, которое возвращает следующее: Ранго говорит, что это страница about.
Теперь сопоставьте это представление с / rango / about /. На этом этапе вам нужно только отредактировать urls.py приложения rango.
Измените HttpResponse в представлении индекса, чтобы включить ссылку на страницу с информацией.
В HttpResponse в представлении о программе добавьте ссылку на главную страницу.
Если вы еще этого не сделали, это хороший момент, чтобы завершить первую часть официального руководства по Django.

`4.7.1. Подсказки`

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

Ваше представление индекса должно быть обновлено, чтобы включить ссылку на представление about. Пока не усложняйте — что-то вроде того, что Ранго говорит: Привет, мир! Примерно хватит.about / ‘- это будет удобно, когда вы думаете о своем шаблоне URL.
HTML-код для обратной ссылки на страницу индекса — Индекс . Ссылка использует ту же структуру, что и ссылка на страницу с информацией, показанную выше.

Сноски

,