Инструкцией include подключить файл homepage urls py
Обновлено: 04.07.2024
В URL-ах не нужны ни .php , ни .cgi , ни всякая ерунда вроде 0,2097,1-1-1928,00 .
Обзор¶
Для определения URL-ов приложения, создайте модуль Python, неофициально названный URLconf (конфигурация URL-ов). Этот модуль содержит код Python, который отображает URL-шаблоны (регулярные выражения) и связанные функции Python (ваши представления).
Эта конфигурация может быть короткой или длинной настолько, насколько это нужно. Она может ссылаться на другие конфигурации. И, так как это код Python, может создаваться динамически.
Django также предоставляет метод для перевода URL на текущий язык. Обратитесь к документации на интернационализацию для подробностей.
Как Django обрабатывает запрос¶
При запросе к странице вашего Django-сайта, используется такой алгоритм для определения какой код выполнить:
Django загружает модуль конфигурации URL и ищет переменную urlpatterns . Это должен быть список экземпляров django.conf.urls.url() .
Django перебирает каждый URL-шаблон по порядку, и останавливается при первом совпадении с запрошенным URL-ом.
Если одно из регулярных выражений соответствует URL-у, Django импортирует и вызывает соответствующее представление, которое является просто функцией Python(или представление-класс). При вызове передаются следующие аргументы:
Если в результате применения регулярного выражения получили именованные совпадения, они будут переданы как позиционные аргументы.
Именованные аргументы создаются из именованных совпадений. Они могут быть перезаписаны значениями из аргумента kwargs , переданного в django.conf.urls.url() .
Если ни одно регулярное выражение не соответствует, или возникла ошибка на любом из этапов, Django вызывает соответствующий обработчик ошибок. Смотрите `Error handling`_ ниже.
Например¶
Вот пример простого URLconf:
Для получения совпадающего значения из URL, просто добавьте скобки вокруг него.
Не нужно добавлять косую черту в начале, потому что каждый URL содержит его. Например, используйте ^articles , вместо ^/articles .
Запрос к``/articles/2005/03/`` будет обработан третьим элементом списка. Django вызовет функцию views.month_archive(request, '2005', '03') .
/articles/2005/3/ не соответствует ни одному URL-шаблону, потому что третья запись требует две цифры в номере месяца.
/articles/2003/ соответствует первому выражению, не второму, потому что шаблоны проверяются по порядку и берется первый найденный. Не стесняйтесь использовать порядок для обработки различных ситуаций, таких как эта. В данном примере Django вызовет функцию views.special_case_2003(request) .
/articles/2003 не соответствует ни одному регулярному выражению, потому что каждое ожидает, что URL оканчивается на косую черту.
/articles/2003/03/03/ соответствует последнему выражению. Django вызовет функцию views.article_detail(request, '2003', '03', '03') .
Именованные группы¶
Пример выше использует простые, не именованные группы совпадений в регулярных выражениях (то, что в скобках), чтобы получить значения из URL и передать в представление как позиционные аргументы. Но вы можете использовать имена для групп и значения будут передаваться как именованные аргументы.
Вот пример конфигурации URL, переписанный с использованием именованных групп:
Он выполняет то же самое, что и предыдущий пример, с одним небольшим отличием: полученные значения передаются в представление как именованные аргументы, а не позиционные. Например:
Запрос к /articles/2005/03/ вызовет функцию views.month_archive(request, year='2005', month='03') , вместо views.month_archive(request, '2005', '03') .
Запрос к /articles/2003/03/03/ вызовет views.article_detail(request, year='2003', month='03', day='03') .
На практике это означает, что ваша конфигурация URL более понятна и меньше зависит от ошибки в порядке аргументов, также вы можете изменять порядок аргументов в представлении. Конечно, эти преимущества достигаются за счет краткости, некоторые разработчики считают именованные группы уродливыми и слишком многословными.
Алгоритм соответствия/группировки¶
Вот алгоритм, которому следует синтаксический анализатор конфигурации URL, для определения использовать значения именованных или не именованных совпадений:
Если существует именованный аргумент, он будет использован вместо позиционного аргумента.
Иначе все неименованные параметры будут переданы как позиционные аргументы.
В любом случае дополнительные именованные аргументы будут переданы как именованные. Смотрите `Passing extra options to view functions`_ ниже.
Что использует URLconf при поиске нужного шаблона URL¶
URLconf использует запрашиваемый URL как обычную строку Python. Он не учитывает параметры GET, POST и имя домена.
не числом, несмотря на то, что 7 отлавливает только числа.
Значения по умолчанию для аргументов представления¶
Принято указывать значения по-умолчанию для аргументов представления. Пример URLconf и представления:
Производительность¶
Каждое регулярное выражение в urlpatterns будет скомпилировано при первом использовании. Это делает систему невероятно быстрой.
Синтаксис переменной urlpatterns¶
urlpatterns должен быть списком экземпляров url() .
Обработчики ошибок¶
Если Django не может найти подходящий шаблон URL, или было вызвано исключение в процессе обработки запроса, Django вызовет соответствующее представление обрабатывающее ошибку.
Эти представления определены в четырёх переменных. Их значения по-умолчанию должны подойти для большинства проектов, но вы можете их поменять при необходимости.
Эти значения должны быть определены в главном URLconf.
Значение это функции, или полный путь для импорта, которая будет вызвана, если не был найден подходящий URL-шаблон.
Есть следующие переменные:
Комбинирование URLconfs¶
Вот пример URLconf для сайта Django. Он включает множество других конфигураций URL:
Заметим, что регулярные выражения не содержат $ (определитель конца строки), но содержит косую черту в конце. Каждый раз, когда Django встречает include() ( django.conf.urls.include() ), из URL обрезается уже совпавшая часть, остальное передается во включенный URLconf для дальнейшей обработки.
Другой возможностью будет добавление дополнительных URL-шаблонов с помощью списка экземпляров url() . Например, рассмотрим такую схему:
В этом примере URL /credit/reports/ обработан представлением credit_views.report() .
Такой подход может применяться для уменьшения дублирования кода в настройках URL, когда используется один и тот же шаблонный префикс. Например, возьмём такую конфигурацию URL:
Мы можем сделать её проще, указав общий префикс только один раз и сгруппировав различающиеся суффиксы:
Нахождение аргументов в URL¶
Включенный URLconf получает все аргументы найденные родительским URLconfs, поэтому этот пример работает:
В примере выше, найденный аргумент "username" передается во включенный URLconf, как и ожидалось.
Вложенные аргументы¶
Регулярные выражения позволяют использовать вложенные аргументы, и Django может их найти и передать в представление. Во время поиска аргументов Django попытается получить самый внешний аргумент, игнорируя вложенные аргументы. Возьмем следующие шаблоны URL-ов, которые принимает необязательный номер страницы:
Оба шаблона используют вложенные аргументы и могут обрабатывать URL-ы: например, для blog/page-2/ будет найдено представление blog_articles с двумя позиционными аргументами page-2/ и 2 . Второй URL-шаблон для comments для comments/page-2/ найдет именованный аргумент page_number со значеним 2. Внешний аргумент в этом случае не захватываемый из-за (. ) .
При получении URL-а для представления blog_articles необходимо указать самый внешний аргумент( page-2/ ) или ни одного аргумента в данном случае. В то время как для comments необходимо передать значение page_number или не одного аргумента.
Вложенные захватываемые аргументы создают сильную связанность между URL и аргументами представления, как это показано для blog_articles : представление получает часть URL-а ( page-2/ ) вместо значение, которое на самом деле необходимо представлению. Эта связанность особенно заметна при создании URL-а т.к. необходимо передать часть URL-а вместо номера страницы.
Как правило, URL-шаблон должен захватывать только необходимые для представления аргументы.
Передача дополнительных аргументов в представление¶
Конфигурация URL-ов позволяет определить дополнительные аргументы для функции представления, используя словарь Python.
Функция django.conf.urls.url() может принимать третий необязательный элемент. Этот элемент является словарем, который определяет дополнительные именованные аргументы для функции представления.
Например, при запросе к /blog/2005/ , Django вызовет views.year_archive(request, year='2005', foo='bar') .
Такой подход используется в syndication framework для передачи параметров и дополнительных данных в представление.
Если регулярное выражение URL-шаблона выделяет из URL-а аргумент с названием, которое уже используется в дополнительных именованных аргументах, будет использован аргумент из словаря дополнительных аргументов, вместо значения из URL.
Передача дополнительных аргументов в include() ¶
Аналогично вы можете передать дополнительные аргументы в include() . При этом, каждый URL-шаблон включенного URLconf будет дополнен этими дополнительными аргументами.
Например, эти два URLconf работают идентично:
Дополнительные аргументы всегда передаются каждому представлению во включенном URLconf, независимо от того, принимает оно эти аргументы или нет. Поэтому, такой подход полезен только если вы уверенны, что каждое представление принимает передаваемые аргументы.
Поиск URL-а по URL-шаблону¶
Обычной задачей является получение URL-а по его определению для отображения пользователю или для редиректа.
В общем необходимо придерживаться принципа DRY. Немаловажно иметь возможность менять URL-ы в одном месте, а не выполнять поиск и замену по всему проекту.
Для получения URL-а нам необходим его идентификатор, то есть название URL-шаблона, и позиционные и именованные аргументы.
Получая запрошенный URL находит необходимое представление и предоставляет все необходимые аргументы полученные из URL-а.
Получая идентификатор представления и передаваемые ему аргументы, возвращает URL.
Первое это то, что мы уже рассмотрели в предыдущем разделе. Второе называется URL reversing, в общем получение URL-а по его названию.
Django предоставляет инструменты для получения URL-ов в различных компонентах фреймворка:
В шаблонах: Использование шаблонного тега url .
На более высоком уровне для привязки URL-ов к моделям - метод get_absolute_url() .
Примеры¶
Рассмотрим следующий URLconf:
В соответствии с ним архиву nnnn года соответствует URL /articles/nnnn/ .
Вы можете получить его в шаблоне следующим образом:
Если по каким-либо причинам необходимо будет изменить URL, достаточно будет изменить запись в вашем URLconf.
В некоторых случаях URL-ы и представления могут соотноситься как многое-к-одному. В таких случаях название представления не может идентифицировать конкретный URL. Как решить эту проблему читайте в следующем разделе.
Именованные URL-шаблоны¶
Для того, чтобы выполнить обратное разрешение URL, вам потребуется использовать именованные URL шаблоны, как это показано в примерах выше. Строка, использованная для наименования URL, может содержать любые символы. Вы не ограничены только теми именами, что позволяет Python.
При выборе названия для URL-шаблона, убедитесь что оно достаточно уникально. Если вы назовете URL-шаблон comment , и другое приложение сделает аналогичное, нет гарантии что в шаблон будет вставлен правильный URL.
Добавление префикса к названию URL-шаблона, возможного состоящего из названия приложения, уменьшит шанс конфликта. Мы советуем использовать myapp-comment вместо comment .
Пространства имен в конфигурации URL-ов¶
Описание¶
Django приложения, правильно используя пространство имен для URL, могут использоваться в нескольких экземплярах на проекте. Например, django.contrib.admin содержит класс AdminSite , который легко позволяет подключить несколько интерфейсов администратора . Ниже мы опишем как сделать аналогично для нашего приложения опросов, чтобы можно было создать несколько интерфейсов (для авторов и издателей).
Пространство имен состоит из двух частей, каждая из которых это строка:
Пространство имен определяется с помощью оператора ':' . Например, главная страница интерфейса администратора определяется как 'admin:index' . Мы видим пространство имен 'admin' , и название URL-шаблона 'index' .
Пространства имен могут быть вложенными. Название URL-а 'sports:polls:index' означает именованный URL-шаблон с названием 'index' в пространстве имен 'polls' , которое было определенно в другом пространстве имен - 'sports' .
Поиск URL-а по шаблону с пространством имен¶
Если необходимо найти URL по названию с пространством имен (например, 'polls:index' ), Django разбивает название на части и следует такому алгоритму:
Первым делом, Django проверяет название(пространсву имен) приложения (например, polls ). Django получает список экземпляров приложения.
Шаблонный тег url использует пространство имен представления как текущее приложение в RequestContext . Вы можете переопределить его, указав в атрибуте request.current_app .
В предыдущих версиях Django вам требовалось назначать атрибуту current_app класс Context или RequestContext , который использовался при рендеринге шаблона.
Ранее тег url не использовал пространство имен представления и вам приходилось устанавливать атрибут current_app запроса.
Если экземпляр по-умолчанию не найден, Django возьмет последний установленный экземпляр приложения, не обращая внимание на его название.
Если на первом шаге не было найдено приложение по указанному пространству имен, Django попытается найти экземпляр приложения по его названию, используя пространство имен как название экземпляра.
Если пространство имен вложенное, этот процесс будет повторен, пока неопределенным не останется только название представления. URL для названия представления будет искаться среди URL-шаблонов определенных в приложении, найденном через пространство имен.
Например¶
Разберем небольшой пример. У нас есть два экземпляра приложения polls : один назван 'author-polls' , другой - 'publisher-polls' . Предположим, что мы уже изменили код приложения и оно учитывает текущее пространство имен при создании страниц.
Для таких настроек URL-ов возможны следующие варианты поиска URL-а по названию:
Если один из экземпляров указан как текущий - например, мы выполняем шаблон в экземпляре 'author-polls' - поиск URL-а по 'polls:index' вернет URL на главную страницу экземпляра приложения 'author-polls' . То есть мы получим "/author-polls/" для двух, приведенных ниже, примеров.
В методе представления:
Если текущий экземпляр приложения не указан - например, мы ищем URL в другом приложении - поиск по 'polls:index' вернет URL для последнего добавленного экземпляра 'polls' . Т.к. у нас не определен экземпляр приложения по умолчанию (с instance namespace равным 'polls' ), будет использоваться последний добавленный экземпляр polls . Это будет 'publisher-polls' т.к. он последний в urlpatterns .
Поиск по 'author-polls:index' всегда вернет ссылку на главную страницу экземпляра приложения 'author-polls' (аналогично и для 'publisher-polls' ).
Пространства имен в URL -ах и include¶
Название приложения в URLconfs можно определить двумя путями.
URL-ы, определенные в polls.urls , содержат название приложения polls .
Второй, вы можете добавить объект, который содержит все необходимые данные. Если добавить через include() список url() , они будет добавлены в глобальное пространство имен. Однако, в include() можно передать 2-элементный кортеж, который содержит:
Этот код добавляет URL-шаблоны, используя указанное название приложения.
Имя конкретного экземпляра приложения можно указать с помощью аргумента namespace для include() . Если он не указан, будет использовать название приложения.
В предыдущих версиях требовалось указать название приложения и экземпляра приложения, передавая параметрами в include() , или подключая кортеж из 3-х элементов вида (<list of url() instances>, <application namespace>, <instance namespace>) .
Мы собираемся сделать нашу первую веб-страничку — домашнюю страницу твоего блога! Но для начала давай чуть ближе познакомимся с URL-адресами в Django.
Что такое URL-адрес?
Любая страница в Интернете нуждается в собственном URL-адресе. Таким образом ваше приложение точно знает, что показать пользователю, который открывает конкретный URL-адрес. В Django мы используем так называемый URLconf (англ. URL configuration, конфигурация URL). URLconf — это набор шаблонов, которые Django попробует сравнить с полученным URL, чтобы выбрать правильный метод для отображения (view).
Как URL-адреса работают в Django?
Давай откроем файл mysite/urls.py в нашем редакторе и посмотрим, как он выглядит:
Как можешь заметить, Django уже кое-что разместил здесь для нас.
Строки, расположенные между тройными кавычками ( ''' или """ ), называются docstrings — ты можешь добавить их в начале файла, класса или метода для описания их функциональности. Python будет их игнорировать при запуске приложения.
URL-адрес раздела администрирования, который мы посещали в предыдущей главе, уже здесь присутствует:
Таким образом, любому URL-адресу, начинающемуся с admin/ , Django будет находить соответствующее view (представление). В этом случае мы охватываем большое количество различных URL-адресов, которые явно не прописаны в этом маленьком файле — так он становится более аккуратным и удобочитаемым.
Твой первый URL-адрес в Django!
Мы также хотим сохранить файл mysite/urls.py в максимально аккуратном виде, так что мы импортируем URL-адреса для нашего приложения blog в mysite/urls.py .
Вперёд, добавь строку для импорта blog.urls . Обрати внимание, что здесь мы используем функцию include , поэтому тебе придется импортировать её в строке from django.urls. .
Файл mysite/urls.py должен выглядеть следующим образом:
blog.urls
Создай новый пустой файл blog/urls.py . Отлично! Добавь в него следующие две строки:
Так мы импортировали функцию path Django и все views (представления) из приложения blog (у нас их пока нет, но через минуту они появятся!)
После этого мы можем добавить наш первый URL-шаблон:
Последняя часть name='post_list' — это имя URL, которое будет использовано, чтобы идентифицировать его. Оно может быть таким же, как имя представления (англ. view), а может и чем-то совершенно другим. Мы будем использовать именованные URL позднее в проекте, поэтому важно указывать их имена уже сейчас. Мы также должны попытаться сохранить имена URL-адресов уникальными и легко запоминающимися.
Теперь, когда у нас есть рабочее представление, которое было объяснено в предыдущей главе, мы хотим получить к нему доступ через URL. У Django есть свой собственный способ сопоставления URL-адресов, он осуществляется путем редактирования файла urls.py (myproject/urls.py). Данный файл выглядит следующим образом:
Когда пользователь запрашивает страницу вашего веб-приложения, контроллер Django начинает поиск соответствующего представления в файле urls.py, а затем возвращает HTML-ответ или ошибку 404, если она не найдена. В urls.py самым важным является кортеж urlpatterns. В нем вы определяете соответствие между URL-адресами и представлениями. Сопоставление представляет собой кортеж URL-шаблонов, который выглядит следующим образом:
Последняя строка сопоставляет URL “/hello” с представлением приветствия, созданным в файле myapp/views.py. Как вы можете видеть выше, сопоставление URL состоит из трех частей:
- Шаблон — регулярное выражение, соответствующее URL-адресу, который вы хотите разрешить и сопоставить. Все, что может работать с модулем Python “re” подходит в качестве шаблона (полезно, когда вы хотите передать параметры через URL).
- Путь к представлению Python — такой же, как при импорте модуля.
- Имя — необходимо для выполнения реверсирования URL-адреса.
До сих пор мы создавали URL-адреса в файле “myproject/urls.py”, однако, как уже говорилось ранее, лучше всего иметь возможность повторного использования приложения в различных проектах. Вы можете легко увидеть, в чем проблема, если вы сохраните все свои URL в файле “myproject/urls.py”. Поэтому рекомендуется создавать для каждого приложения свой собственный “urls.py” и включать его в основной файл urls.py нашего проекта (ранее мы включили в него URL-адрес для интерфейса администратора).
Нам нужно создать файл urls.py в myapp, используя следующий код:
Тогда myproject/urls.py изменится и станет выглядеть следующим образом:
В нем вы включили все URL из приложения myapp. Файл hello.html, к которому мы обращались через “/hello” теперь будет “/myapp/hello”, что является лучшей и более понятной структурой для веб-приложения.
Теперь давайте представим, что у нас есть другое представление в myapp, которое называется “morning”, и мы хотим сопоставить его в myapp/urls.py, тогда мы изменим наш myapp/urls.py:
Также это может быть сделано следующим образом:
Как видите, теперь мы используем первый элемент нашего кортежа urlpatterns. Это может быть полезно, когда мы захотим изменить имя приложения.
Теперь мы знаем, как сопоставить URL, теперь давайте посмотрим, как отправлять параметры в представления. Классическим примером является статья (вы хотите получить доступ к ней через “/article/article_id”).
Передача параметров осуществляется путем “захвата” их с помощью регулярного выражения в шаблоне URL. Если у нас есть представление подобное следующему в “myapp/view.py”:
И мы хотим сопоставить его с URL-адресом в myapp/urls.py, чтобы мы могли получить к нему доступ через “/myapp/article/articleID”, то нам нужно следующее в “myapp/urls.py”:
Когда Django увидит URL: “/myapp/article/42”, он передаст параметр “42” представлению viewArticle, и в итоге в вашем браузере вы должны получить следующий результат:
Обратите внимание, что порядок параметров здесь важен. Предположим, нам нужен список статей за месяц, давайте добавим представление viewArticles. Файл views.py примет следующий вид:
Соответствующий файл urls.py будет выглядеть так:
Теперь, когда вы перейдете по “/myapp/Articles/12/2006”, вы получите “Displaying articles of: 2006/12”, но если вы измените параметры, вы не получите тот же результат.
В Python очень много полезных функций, библиотек и других элементов, перечислить которые в одном материале очень сложно. Мы поделимся базовой шпаргалкой по Python, которая ориентирована на создание веб-приложений с фреймворком Django. Сохраняйте статью в закладки, чтобы не потерять!
Этот набор инструкций напомнит вам об основных операциях с Django, если вы работаете над веб-проектом. Сюда входят такие действия, как установка Django, запуск проекта, работа с моделями, создание домашней страницы, использование шаблонов и создание учётных записей пользователей.
Шпаргалка предназначена для тех, кто уже знаком с Python, понимает, что такое виртуальное окружение, и имеет начальные знания о веб-разработке.
Что такое Django?
Django — веб-фреймворк для создания интерактивных веб-сайтов на Python. В Django вы определяете тип данных, с которыми ваш сайт должен работать, а затем указываете, как пользователи могут взаимодействовать с этими данными. Все описанные ниже действия актуальны для Django 3.0.
Установка Django
Лучше установить Django в виртуальном окружении — virtualenv или pipenv, где ваш проект будет изолирован от других. Большинство команд, приведённых ниже, предполагают, что вы работаете в виртуальной среде.
Создать виртуальную среду
pipenv:
Активировать среду
venv, macOS and Linux:
venv, Windows:
pipenv:
Установить Django в активную среду
pipenv:
Создание проекта
Чтобы начать работу, мы создадим новый проект и базу данных, а затем запустим веб-сервер. Во всех примерах ниже проект будет называться learning_log .
Создать новый проект
Создать базу данных
Посмотреть проект
Создать новое приложение
Проект Django состоит из одного или нескольких приложений.
Перезапуск сервера разработки
Если вы вносите изменения в свой проект, но ничего не происходит, попробуйте перезапустить сервер:
Работа с моделями
Данные в проекте Django представлены в виде набора моделей — объектов Python, определяющих структуру хранения этих данных.
Определение модели
Чтобы определить модель для вашего приложения, измените файл models.py , созданный в папке приложения. Метод __str __() сообщает Python, как отображать экземпляр модели в строковом представлении. Django использует этот механизм для отображения объектов в формах.
Активация модели
Для использования модели приложение должно быть добавлено в список INSTALLED_APPS , который хранится в файле settings.py проекта.
Миграция базы данных
База данных должна быть модифицирована для хранения данных модели. Вам нужно будет запускать эти команды каждый раз, когда вы создаете новую модель или модифицируете существующую модель.
Создание суперпользователя
Суперпользователь — это учётная запись с доступом ко всем компонентам проекта.
Создание новой модели
Новая модель может использовать существующую модель. Атрибут ForeignKey устанавливает связь между экземплярами двух связанных моделей. Обязательно мигрируйте базу данных после добавления новой модели в ваше приложение.
Определение модели с внешним ключом:
Создание простой домашней страницы
Пользователи взаимодействуют с проектом через веб-страницы. Мы создадим простую домашнюю страницу без данных. Любой странице обычно нужен URL, представление (view) и шаблон (template). Представление — функция Python, которая принимает HTML-запрос и возвращает ответ на него. Шаблон — специальный набор инструкций, позволяющий динамически генерировать HTML.
Сопоставление URL-адресов проекта
Основной файл проекта urls.py сообщает Django, где найти файлы urls.py , связанные с каждым приложением в проекте.
Сопоставление URL-адресов приложения
Файл urls.py в приложении сообщает Django, какое представление использовать для каждого URL-адреса в этом приложении. Вам нужно создать этот файл самостоятельно и сохранить его в папке приложения.
Создание простого представления
Представление берёт информацию из запроса и отправляет данные в браузер, часто через шаблон. Функции представления хранятся в файле views.py . Ниже приведена простая функция, которая не извлекает какие-либо данные, но использует для отображения домашней страницы шаблон .
Написание простого шаблона
Шаблон устанавливает структуру страницы. Создайте папку с именем templates в директории проекта. Внутри templates создайте ещё одну папку с тем же именем, как у приложения. Здесь должны быть сохранены все файлы шаблонов. Шаблон домашней страницы будет сохранён как learning_logs/templates/learning_logs/ .
Наследование шаблонов
Многие элементы повторяются на каждой странице сайта или же в одном из разделов. Написав один родительский шаблон для сайта или раздела, вы можете легко установить внешний вид всего сайта.
Родительский шаблон
Родительский шаблон определяет общие элементы для набора страниц, а также уникальные блоки для отдельных страниц.
Дочерний шаблон
Дочерний шаблон использует тег для извлечения структуры родительского шаблона. Затем он переопределяет содержимое для блоков, указанных в родительском шаблоне.
Отступы в шаблоне
Отступы в Python обычно отбиваются четырьмя пробелами. В шаблонах вы часто можете встретить отступы в два пробела, потому что вложенность кода как правило более глубокая.
Создание страницы с данными
Большинство страниц в проекте должны показывать данные, относящиеся к текущему пользователю.
Параметры URL
URL-адрес часто принимает параметр, сообщающий ему, к каким данным из базы данных обращаться. Показанный ниже шаблон URL ищет идентификатор конкретной темы и присваивает его параметру topic_id .
Использование данных в представлении
Представление использует параметр из URL, чтобы извлечь правильные данные из базы данных. В этом примере представление отправляет контекстный словарь в шаблон, содержащий данные, которые должны отображаться на странице. Вы можете импортировать любую модель, которую используете.
Использование данных в шаблоне
Данные, передаваемые в словаре-контексте, доступны в шаблоне. Доступ к этим данным осуществляется с помощью переменных шаблона, которые обозначены двойными фигурными скобками. Вертикальная линия после шаблонной переменной указывает на фильтр. В нашем примере фильтр с именем date форматирует объекты даты, а фильтр разрыва строки правильно отображает абзацы на веб-странице.
Django Shell
Вы можете работать с проектом Django из командной строки. Это полезно для выполнения запросов и тестирования фрагментов кода.
Начать сеанс оболочки
Доступ к данным из проекта
Пользователи и формы
Большинство веб-приложений позволяют посетителям создавать учётные записи. Это позволяет пользователям работать с собственными данными. Некоторые из этих данных могут быть конфиденциальными, а некоторые — общедоступными. Формы Django позволяют пользователям вводить и изменять свои данные.
Учётные записи пользователей
Учётные записи пользователей можно обрабатывать приложением — ниже оно создаётся под названием users . Пользователи должны иметь возможность зарегистрироваться, войти и выйти из аккаунта. Django автоматизирует большую часть этих действий.
Создание приложения users
После создания приложения обязательно добавьте его в INSTALLED_APPS в файле settings.py проекта.
Добавление URL-адресов приложения users
Добавьте эти строки в файл urls.py проекта, чтобы включить в проект URL-адреса приложения users .
Использование форм в Django
Существует несколько способов создания форм и работы с ними. Вы можете использовать установки Django по умолчанию или настроить свои формы. Наиболее простой способ настроить ввод данных, основанных на ваших моделях — использование класса ModelForm. ModelForm автоматически создаёт форму на основе полей модели.
Создание URL для входа, выхода и регистрации
Пользователи смогут войти, выйти и зарегистрироваться на сайте. Создайте новый файл urls.py в папке приложения users .
Шаблон входа
Тег помогает предотвратить CSRF-атаки с помощью форм. Элемент > отображает форму входа по умолчанию в формате абзаца. Элемент <input> с именем next перенаправляет пользователя на домашнюю страницу после успешного входа в систему.
Отображение текущего статуса входа
Вы можете изменить шаблон base.html , чтобы показать, вошёл ли пользователь на сайт в данный момент, и предоставить ссылку на страницы входа и выхода. Django делает объект user доступным для каждого шаблона.
Тег user.is_authenticated позволяет вам показать конкретный контент пользователям в зависимости от того, вошли они в систему или нет. Свойство > приветствует пользователей, которые вошли в систему. Те же, кто не вошёл в систему, увидят ссылки для регистрации или входа.
Шаблон logged_out
Выход из системы по умолчанию отображается с помощью шаблона logged_out.html , который необходимо сохранить в папке users/templates/registration .
Представление для регистрации должно отображать пустую форму регистрации при первом запросе страницы, а затем обработать заполненные поля. Успешная регистрация сохраняет данные пользователя, и затем выполняется вход в систему и перенаправление на домашнюю страницу.
Шаблон регистрации
Шаблон register.html отображает поля формы регистрации в виде списка тегов <p> .
Данные пользователей
У всех пользователей есть данные, которые относятся только к ним. Любая модель, подключенная напрямую к пользователю, нуждается в поле, связывающем экземпляры модели с конкретным пользователем.
Создание темы, принадлежащей пользователю
Чтобы связать данные с пользователем, импортируйте модель User и добавьте её в качестве внешнего ключа в модель данных.
После изменения модели вам нужно будет мигрировать базу данных и установить user ID для каждого существующего пользователя.
Запрос данных для текущего пользователя
Объект запроса имеет атрибут user в своём представлении. Вы можете использовать этот атрибут для получения данных пользователя — их извлекает метод filter() .
Установка URL перенаправления
Декоратор @login_required отправляет неавторизованных пользователей на страницу входа. Добавьте следующую строку в файл settings.py , чтобы Django знал, как найти страницу входа.
Предотвращение случайного доступа
Некоторые страницы отображают данные на основе параметров URL. Вы можете проверить, что текущий пользователь имеет права на просмотр текущих данных, и вернуть ошибку 404, если это не так.
Формы для редактирования данных
С Django можно создать форму с существующими данными пользователя и возможностью изменять и сохранять их.
Создание формы с исходными данными
Параметр instance позволяет указать начальные данные для формы.
Изменение данных перед сохранением
Аргумент commit = False позволяет вносить изменения перед записью в базу данных.
Django — отличный фреймворк, и мы привели лишь малую часть базовых операций в нём. Если вы хотите поэкспериментировать с Django на настоящем сервере — попробуйте наши Облачные VPS с готовым шаблоном Django и почасовой оплатой от 37 копеек. После заказа сервера Django будет готов к работе уже через минуту.
Пишите в комментариях, шпаргалки по каким языкам или фреймворкам вы хотели бы видеть в нашем блоге.
Читайте также: