Создание приложения в Django для начинающих

В данном уроке мы создадим простой сайт на Django, который будет выводить надпись «Hello World» на домашнюю страницу. Это классический старт изучения нового языка программирования или фреймворка. Мы также впервые поработаем с git и разместим код на GitHub.

Содержание статьи

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

Начальная настройка Django-приложения

Первым делом переместимся в новую директорию. Например, можно создать директорию helloworld на рабочем столе, используя следующие инструкции.

$ cd ~/Desktop
$ mkdir helloworld && cd helloworld

Убедитесь, что в настоящий момент вы не находитесь ни в каком существующем виртуальном окружении. Здесь подсказкой станут скобки () перед знаком доллара ($). Для выхода из окружения наберите exit, после чего нажмите клавишу Enter. Пропавшие скобки — признак деактивации виртуального окружения.

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

$ pipenv install django==3.0.*
$ pipenv shell

Если у вас Ubuntu, то увидите подтверждение изменений прямо сейчас — (helloworld). Название директории теперь взято в скобки и находится в строке перед командой. К сожалению, пользователи Windows на данном этапе не смогут увидеть никаких подтверждений активации.

Создадим новый проект Django под названием helloworld_project. В конце команды поставим точку (.) — тогда проект будет установлен в текущую папку.

(helloworld) $ django-admin startproject helloworld_project .

Используйте команду tree и посмотрите на структуру созданного проекта Django. Если tree не сработала, наберите в командной строке: sudo apt install tree.

(helloworld) $ tree
.
├── Pipfile
├── Pipfile.lock
├── helloworld_project
│ ├── __init__.py
│ ├── settings.py
│ ├── urls.py
│ └── wsgi.py
└── manage.py

1 directory, 7 files

Файл settings.py контролирует настройки проекта, urls.py сообщает Django, какие страницы создать в ответ на запрос браузера или URL-адреса, а wsgi.py, что расшифровывается как Web Server Gateway Interface, помогает Django управлять конечными веб-страницами. Последний файл, manage.py, используется для выполнения различных команд Django. Это может быть запуск локального веб-сервера или создание нового приложения.

Django поставляется со встроенным локальным веб-сервером, который запускается командой runserver.

(helloworld) $ python manage.py runserver

При переходе по адресу http://127.0.0.1:8000/ вам откроется следующая страница:

Приветственная страница Django

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

Watching for file changes with StatReloader
Performing system checks…

System check identified no issues (0 silenced).

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

May 05, 2020 — 13:13:40
Django version 3.0.6, using settings ‘helloworld_project.settings’
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

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

Тем не менее, чтобы предупреждение не мозолило глаза, мы можем удалить его. Для этого нужно остановить локальный сервер комбинацией CTRL+C, а затем выполнить команду python manage.py migrate.

$ python manage.py migrate
Operations to perform:
Apply all migrations: admin, auth, contenttypes, sessions
Running migrations:
Applying contenttypes.0001_initial… OK
Applying auth.0001_initial… OK
Applying admin.0001_initial… OK
Applying admin.0002_logentry_remove_auto_add… OK
Applying admin.0003_logentry_add_action_flag_choices… OK
Applying contenttypes.0002_remove_content_type_name… OK
Applying auth.0002_alter_permission_name_max_length… OK
Applying auth.0003_alter_user_email_max_length… OK
Applying auth.0004_alter_user_username_opts… OK
Applying auth.0005_alter_user_last_login_null… OK
Applying auth.0006_require_contenttypes_0002… OK
Applying auth.0007_alter_validators_add_error_messages… OK
Applying auth.0008_alter_user_username_max_length… OK
Applying auth.0009_alter_user_last_name_max_length… OK
Applying auth.0010_alter_group_name_max_length… OK
Applying auth.0011_update_proxy_permissions… OK
Applying sessions.0001_initial… OK

Здесь Django осуществил миграцию встроенных приложений. Теперь при повторном выполнении python manage.py runserver командная строка выведет следующий чистый результат:

Watching for file changes with StatReloader
Performing system checks…

System check identified no issues (0 silenced).
May 05, 2020 — 13:15:46
Django version 3.0.6, using settings ‘helloworld_project.settings’
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

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

Для сохранения аккуратности и читабельности кода Django использует концепт проектов и приложений. Приложения внутри проекта влияют на производительность главного веб-приложения. Команда для создания нового приложения Django — startproject.

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

То, как и когда распределить функционал по приложениям, является субъективным понятием. Однако, в общем и целом у каждого приложения должна быть ясная функция.

Пришло время для создания первого приложения. Выйдите из командной строки при помощи CTRL+C. Затем наберите команду startapp с последующим названием приложения. В нашем случае это pages.

(helloworld) $ python manage.py startapp pages

Если вы еще раз посмотрите на структуру директории при помощи команды tree, то заметите, что Django создал новую директорию pages, в которой расположены следующие файлы:

(helloworld) $ tree
├── pages
│ ├── __init__.py
│ ├── admin.py
│ ├── apps.py
│ ├── migrations
│ │ └── __init__.py
│ ├── models.py
│ ├── tests.py
│ └── views.py

Посмотрим, за что отвечает каждый файл внутри папки pages:

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

Хотя созданное приложение существует внутри проекта Django, сам Django пока об этом «не знает», и наша задача просветить его. Через текстовый редактор откройте файл settings.py и найдите пункт INSTALLED_APPS, под которым будут указаны шесть изначально встроенных приложений Django. Добавьте новое приложение pages в самый низ.

# helloworld_project/settings.py
INSTALLED_APPS = [
‘django.contrib.admin’,
‘django.contrib.auth’,
‘django.contrib.contenttypes’,
‘django.contrib.sessions’,
‘django.contrib.messages’,
‘django.contrib.staticfiles’,
‘pages.apps.PagesConfig’, # новое приложение
]

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

Некоторым может стать интересно, зачем прописывать такую длинную строчку pages.apps.PagesConfig, почему в список нельзя просто добавить название приложения pages?

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

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

URL, представления (Views), модели (Models) и шаблоны (Templates)

В Django для оптимальной работы одной страницы требуется как минимум три (чаще четыре) файла. Внутри приложения этими файлами являются urls.py, views.py, models.py и HTML шаблон index.html.

Работа в Django строится на взаимодействии упомянутых выше элементов, однако новичков такая система может легко запутать, поэтому будет лучше сперва разобраться с порядком HTTP запросов/ответов. При вводе определенного URL, например, https://python-scripts.com, проект Django осуществляет попытку отыскать URL-паттерн, который бы соответствовал адресу домашней страницы. Данный URL-паттерн уточняет представление (view), которое определяет содержимое страницы (обычно на основании модели (model) базы данных) и в конечном итоге — шаблон (template) для стилей и базовой логики. Финальный результат отправляется пользователю назад в виде HTTP ответа.

Схему завершенного потока можно представить следующим образом:

Цикл работы Django запроса/ответа

URL -> View -> Model (обычно) -> Template

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

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

Когда пользователь запрашивает некую страницу, например, домашнюю страницу, файл urls.py использует регулярное выражение для назначения данного запроса для подходящей функции представления, которая затем возвращает верные данные. Иными словами, наше представление выведет текст «Hello, World» в то время, как url должен будет убедиться в том, что во время всех визитов пользователя на домашнюю страницу отображаемое представление является верным.

Давайте посмотрим, как все работает. Для начала обновим файл views.py в приложении pages:

# pages/views.py
from django.http import HttpResponse

def homePageView(request):
return HttpResponse(‘Hello, World!’)

По существу, здесь мы заявляем, что когда бы функция представления homePageView ни была вызвана, ответом будет текст «Hello, World!». Говоря точнее, мы импортируем встроенный метод HttpResponse, и поэтому можем вернуть ответный объект пользователю. Мы создали функцию под названием homePageView, которая принимает объект запроса request и возвращает ответ response в виде строки «Hello, World!»

Теперь нам нужно настроить все url. Для этого в приложении pages создается новый файл urls.py.

(helloworld) $ touch pages/urls.py

Затем обновляем его при помощи следующего кода:

# pages/urls.py
from django.urls import path
from .views import homePageView

urlpatterns = [
path(», homePageView, name=’home’)
]

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

У нашего URLpatterns есть три составляющие:

• регулярное выражение Python для пустой строки '';
• отсылка к представлению под названием homePageView;
• опциональный именованный URL паттерн 'home'.

Другими словами, если пользователь запрашивает домашнюю страницу, представленную пустой строкой '', тогда используется представление под названием homePageView.

На данный момент мы почти все разобрали. Последним шагом станет обновление файла helloworld_project/urls.py. Для одного проекта Django, в данном случае pages, типично иметь сразу несколько приложений, и у каждого должен быть свой собственный URL.

# helloworld_project/urls.py
from django.contrib import admin
from django.urls import path, include # новое добавление

urlpatterns = [
path(‘admin/’, admin.site.urls),
path(», include(‘pages.urls’)), # новое добавление
]

На второй строке возле path мы импортировали include, а затем создали новый URL-паттерн для приложения pages. Теперь любые визиты пользователя на домашнюю страницу вначале будут направлены к приложению pages, а затем к набору представления homePageView, что расположен в файле pages/urls.py.

Необходимость сразу в двух различных файлах urls.py часто запутывает начинающих. Здесь helloworld_project/urls.py верхнего уровня рассматривается как шлюз для многобразных url паттернов, различных для каждого приложения.

Приложение «Hello World» в Django

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

(helloworld) $ python manage.py runserver

Если вы обновите в браузере страницу http://127.0.0.1:8000/, на экране отобразится текст «Hello, World!»

Домашняя страница Hello world

Использование Git для загрузки кода на Github

Git является системой управления версиями. Сейчас мы ее используем. Первым шагом станет инициализация (или добавление) git в наше хранилище.

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

(helloworld) $ git status
On branch master

No commits yet

Untracked files:
(use «git add <file>…» to include in what will be committed)

Pipfile
Pipfile.lock
db.sqlite3
helloworld_project/
manage.py
pages/

nothing added to commit but untracked files present (use «git add» to track)

Далее мы добавим все изменения, используя команду add -A, затем commit для их подтверждения, а после этого применим (-m) для описания изменений.

(helloworld) $ git add -A
(helloworld) $ git commit -m «initial commit»

Работа с GitHub при создании сайта на Django

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

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

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

Проверка GitHub

Затем требуется подтвердить бесплатную подписку, что является выбором по умолчанию. Нажмите на кнопку «Continue» в нижней части страницы.

Подписка GitHub 

На третьем этапе вас попросят ответить на несколько вопросов для обозначения вашего уровня разработчика и причины работы с GitHub. Отметьте где нужно галочки или же пропустите данный пункт, выбрав «Skip this step» внизу страницы.

Настройка GitHub

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

Создадим наше первое хранилище на https://github.com/new.

Новое хранилище на GitHub

Введите название хранилища hello-world и отметьте его вид — в данном случае это «Private», а не «Public». Затем подтвердите действия, нажав кнопку «Create Repository» внизу страницы.

Ваше первое хранилище создано! Однако оно пока пустое. Пролистайте страницу ниже и найдите “…or push an existing repository from the command line”. Это то, что нам нужно.

Хранилище Hello, World на GitHub

Скопируйте текст под заголовком и вставьте его в командную строку. Я использовал имя пользователя stillriverpress, следовательно вы вписываете свое имя — в противном случае команда не сработает. Данная операция синхронизирует локальную директорию на компьютере с удаленным хранилищем на GitHub.

(helloworld) $ git remote add origin
https://github.com/stillriverpress/hello-world.git

На последнем этапе нам нужно загрузить данные на GitHub при помощи команды push.

(helloworld) $ git push -u origin master

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

Настройка SSH ключей для работы с Github

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

ERROR: Repository not found.
fatal: Could not read from remote repository.

Please make sure you have the correct access rights
and the repository exists.

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

SSH является протоколом, который используется для подтверждения личных связей с удаленным сервером. Рассматривайте его как дополнительный слой защиты поверх системы логина/пароля. Процесс включает в себя генерацию уникальных ключей SSH и последующее хранение их на вашем компьютере, таким образом внешний доступ к ним будет только у GitHub.

Первым делом проверьте, есть ли у вас ключи SSH. У GitHub предусмотрен для этого специальный гид, который работает на Mac, Windows и Linux. Если у вас нет публичных и личных ключей, вам нужно будет сгенерировать их. У GitHub и для этого есть гид.

Теперь по завершении процесса генерирования ключей вы наверняка сможете успешно выполнить команду git push -u origin master.

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

Небольшое видео на Youtube вам может помочь.

Успешно разобравшись с GitHub, двинемся дальше и выйдем и виртуального окружения при помощи команды exit.

О деактивации виртуального окружения сообщит отсутствие скобок в командной строке.

Заключение

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

Создаем небольшой сайт на Django и запускаем его

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

Содержание статьи

Начальная настройка приложения в Django

Начальная настройка приложения Django включает следующие этапы:

• создание директории для кода;
• установка Django в новом виртуальном окружении;
• создание нового проекта в Django;
• создание нового приложения pages;
• обновление файла settings.py.

Будучи в командной строке, убедитесь, что вы сейчас не находитесь в действующем виртуальном окружении. Если перед знаком доллара ($) есть текст в скобках, значит, окружение активно. Выполните команду exit и деактивируйте его.

Создаем новую директорию под названием pages на рабочем столе или в любом другом месте. Главное, чтобы папка была легко доступной и не пересекалась с другими проектами.

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

$ cd ~/Desktop
$ mkdir pages && cd pages
$ pipenv install django==3.0.*
$ pipenv shell
(pages) $ django-admin startproject pages_project .
(pages) $ python manage.py startapp pages

Откройте в вашем текстовом редакторе файл settings.py. В самом низу списка проектов INSTALLED_APPS добавьте приложение pages:

# pages_project/settings.py
INSTALLED_APPS = [
‘django.contrib.admin’,
‘django.contrib.auth’,
‘django.contrib.contenttypes’,
‘django.contrib.sessions’,
‘django.contrib.messages’,
‘django.contrib.staticfiles’,
‘pages.apps.PagesConfig’, # новое
]

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

(pages) $ python manage.py runserver

Затем переходим на http://127.0.0.1:8000/.

Приветственная страница Django 

Шаблоны в Django

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

Вспомним, что в предыдущей уроке на сайте «Hello, World» фраза была вписана сразу в код файла views.py как строка игнорируя какие либо HTML шаблоны. Технически это работает, но масштабируется не очень хорошо. Предпочтительнее будет связать представление (View) с шаблоном (Template), таким образом отделяя информацию из каждого.

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

Для начала нужно определить, где поместить шаблоны внутри структуры проекта Django. Есть два варианта. По умолчанию загрузчик шаблонов Django осмотрит каждое приложение, выискивая связанные шаблоны. Тем не менее, структура остается несколько запутанной: каждое приложение нуждается в новой директории templates, другой директории с таким же названием, как и у приложения, а также в файле шаблона.

Следовательно, рассматривая приложение pages, Django будет ожидать следующую структуру:

└── pages
├── templates
├── pages
├── home.html

Отсюда следует, что нам нужно будет создать новую директорию templates, новую директорию с названием приложения pages и сам шаблон под названием home.html.

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

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

Первым делом покинем запущенный веб-сервер, применив комбинацию CTRL+C. Затем создадим директорию под названием templates и файл HTML под названием home.html.

(pages) $ mkdir templates
(pages) $ touch templates/home.html

После этого нам нужно обновить файл settings.py и указать Django место новой директории templates. Это изменение находятся в одну строчку в настройках 'DIRS' под TEMPLATES.

# pages_project/settings.py
TEMPLATES = [
{
…
‘DIRS’: [os.path.join(BASE_DIR, ‘templates’)], # new
…
},
]

Затем для файла home.html добавляем обычный h2 заголовок.

<!— templates/home.html —>
<h2>Homepage</h2>

Вот и все, шаблон готов! Следующим шагом будет конфигурация нашего URL и файлов представления (views.py).

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

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

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

Классы являются фундаментальной частью Python. В нашем представлении для отображения шаблона мы используем встроенный TemplateView. Обновим файл pages/views.py.

# pages/views.py
from django.views.generic import TemplateView


class HomePageView(TemplateView):
template_name = ‘home.html’

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

Настройка URL для приложений в Django

На последнем этапе необходимо обновить URLConfs. Обновления требуется делать в двух местах. Первым делом обновляем файл самого проекта pages_project/urls.py, чтобы отметить наше приложение pages, а затем внутри приложения pages мы связываем представления (View) с URL-адресами.

Начнем с файла pages_project/urls.py.

# pages_project/urls.py
from django.contrib import admin
from django.urls import path, include # новое

urlpatterns = [
path(‘admin/’, admin.site.urls),
path(», include(‘pages.urls’)), # новое
]

Данный код вам уже знаком. На второй строке мы добавляем include, что нужно для указания существующего URL-адреса для приложения pages. Затем создаем на уровне приложений  файл urls.py.

(pages) $ touch pages/urls.py

И затем добавляем следующий код.

# pages/urls.py
from django.urls import path

from .views import HomePageView

urlpatterns = [
path(», HomePageView.as_view(), name=’home’),
]

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

Вот и все! Теперь запустите веб-сервер через python manage.py runserver, а затем откройте http://127.0.0.1:8000/. Должна открыться новая домашняя страница.

Домашняя страница

Создание новой страницы «О нас» в Django

Процесс добавления страницы «О нас» очень похож на то, что мы только что сделали. Создадим новый файл шаблона, новое представление, а также новый адрес URL.

Закрываем веб-сервер через комбинацию CTRL+C и создаем новый шаблон под названием about.html.

(pages) $ touch templates/about.html

Затем добавляем короткий HTML заголовок.

<!— templates/about.html —>
<h2>About page</h2>

Создаем новое представление для страницы.

# pages/views.py
from django.views.generic import TemplateView

class HomePageView(TemplateView):
template_name = ‘home.html’

class AboutPageView(TemplateView): # новое
template_name = ‘about.html’

Далее связываем его с URL в about/.

# pages/urls.py
from django.urls import path

from .views import HomePageView, AboutPageView # новое

urlpatterns = [
path(‘about/’, AboutPageView.as_view(), name=’about’), # новое
path(», HomePageView.as_view(), name=’home’),
]

Запускаем сервер при помощи python manage.py runserver.

В браузере переходим по адресу http://127.0.0.1:8000/about. У вас должна появиться новая страница — «About page».

Страница «О Нас»

Расширяем возможности шаблона в Django

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

Это возможно! Создадим HTML-файл base.html, у которого будет заголовок с ссылками на две созданные нами страницы. Название для файла можно выбрать любое, в данной случае base.html просто стало традицией. Теперь закрываем веб-сервер CTRL+C и затем создаем новый файл.

(pages) $ touch templates/base.html

В Django, шаблонный язык для добавления ссылок и базовых логических операций минимален. Ознакомиться со встроенным списком шаблонных тегов можно в официальной документации. Шаблонные теги оформляются так {% something %}, где «something» сам по себе является тегом. Вы даже можете создать собственные шаблонные теги.

Для добавления URL-ссылок в проект мы можем использовать встроенный шаблонный тег url, который присваивает себе имя URL паттерна в качестве аргумента. Помните, как мы добавляли опциональные URL названия двум адресам в pages/urls.py? Это было сделано именно по этой причине. Тег url использует эти названия для автоматического создания ссылок.

URL путь для нашей домашней страницы был назван home, поэтому для настройки ссылки к ней мы будем использовать: {% url 'home' %}.

<!— templates/base.html —>
<header>
<a href=»{% url ‘home’ %}»>Home</a> | <a href=»{% url ‘about’ %}»>About</a>
</header>

{% block content %}
{% endblock content %}

Внизу мы добавляем тег-блок под названием content. При наследовании, блоки могут быть переписаны дочерними шаблонами. Закрывающему тегу можно дать название endblock — просто напишите {% endblock %}. Это может стать хорошей подсказкой при ориентировке в крупных файлах шаблонов.

Обновим файлы home.html и about.html для расширения шаблона base.html. Это значит, что мы будем заново использовать код из одного шаблона в другой. Язык шаблонов в Django поставляется вместе с методом extends, который мы сейчас используем.

<!— templates/home.html —>
{% extends ‘base.html’ %}

{% block content %}
<h2>Homepage</h2>
{% endblock content %}

и

<!— templates/about.html —>
{% extends ‘base.html’ %}

{% block content %}
<h2>About page</h2>
{% endblock content %}

Запускаем сервер с python manage.py runserver и открываем страницы http://127.0.0.1:8000/ и http://127.0.0.1:8000/about вновь. Как видите, на обоих страницах появились заголовки.

Неплохо, правда?

Домашняя страница с заголовком

Страница «About» с заголовком

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

Пишем тесты для Django приложений

Наконец-то мы добрались до тестов. Хотя в приложениях это является базовым концептом, очень важно, чтобы добавление тестов в Django вошло у вас в привычку. Цитируя Джейкоба Каплан-Мосса, одного из создателей Django: «Непротестированный код можно считать сломанным«.

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

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

# pages/tests.py
from django.test import SimpleTestCase


class SimpleTests(SimpleTestCase):
def test_home_page_status_code(self):
response = self.client.get(‘/’)
self.assertEqual(response.status_code, 200)

def test_about_page_status_code(self):
response = self.client.get(‘/about/’)
self.assertEqual(response.status_code, 200)

База данных нам пока не нужна, поэтому сейчас можно использовать простой SimpleTestCase. При наличии базы данных нужно обратиться к TestCase. Затем проводится проверка, в результате которой у каждой страницы должен быть код состояния 200 — это успешный ответ на стандартный HTTP запрос. Таким образом, становится понятно, что запрашиваемая страница действительно существует, но при этом не раскрывается ее содержимое.

Для запуска теста остановите веб-сервер, использовав комбинацию CTRL+C, а затем наберите в командной строке python manage.py test:

(pages) $ python manage.py test
Creating test database for alias ‘default’…
System check identified no issues (0 silenced).
..
———————————————————————-
Ran 2 tests in 0.014s

OK
Destroying test database for alias ‘default’…

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

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

Работа с Git и GitHub

Пришло время зафиксировать изменения с git и загрузить данные на GitHub. Начнем с инициализации нашей директории.

Используйте git status для просмотра изменений в коде, а затем git add -A для их добавления. Теперь мы можем добавить первый коммит.

(pages) $ git status
(pages) $ git add -A
(pages) $ git commit -m ‘initial commit’

На GitHub создаем новое хранилище. Назовем его pages-app. Не забудьте отметить тип «Private», а затем нажмите кнопку «Create repository».

На следующей страницы пролистайте вниз до фразы «…or push an existing repository from the command line». Скопируйте текст и вставьте две команды в терминале.

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

(pages) $ git remote add origin https://github.com/wsvincent/pages-app.git
(pages) $ git push -u origin master

Локальный веб-сервер или Продакшн?

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

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

Запускаем сайт на Django через Heroku

Можете бесплатно зарегистрироваться на сайте Heroku. После подтверждения электронной почты вы будете перенаправлены на главную страницу.

Главная страница Heroku

Теперь необходимо установить Heroku Command Line Interface (CLI), необходимый для работы с командной строкой. Нам нужно установить Heroku глабально — таким образом он будет. Откройте новую вкладку командной строки при помощи комбинации CTRL+T, которая подходит как для Mac, так и для Windows.

Работая на Mac, в новой вкладке при помощи Homebrew установите Heroku:

$ brew install heroku/brew/heroku

Пользователям Windows нужно выбрать 32-битную или 64-битную версию установщика на странице загрузки Heroku CLI. Для пользователей Linux на сайте Heroku предусмотрены специальные инструкции для установки.

Установка Heroku на Ubuntu

sudo snap install —classic heroku

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

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

(pages) $ heroku login
Enter your Heroku credentials:
Email: [email protected]
Password: *********************************
Logged in as [email protected]

Дополнительные файлы Django-приложения

Перед размещением кода на Heroku, нам понадобится сделать четыре изменения в нашем проекте Pages:

• обновить Pipfile.lock;
• создать новый файл Procfile;
• установить на нашем веб-сервере Gunicorn;
• изменить строчку в файле settings.py.

Внутри уже существующего файла Pipfile уточним используемую версию Python — в нашем случае 3.8. Для этого добавим в нижней части файла следующие две строчки.

Pipfile

[requires]
python_version = «3.8»

Далее запускаем pipenv lock для генерации подходящего Pipfile.lock.

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

Затем создаем Procfile, который является специфическим файлом конфигурации для Heroku.

Откройте Procfile при помощи текстового редактора и добавьте следующее:

web: gunicorn pages_project.wsgi —log-file —

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

(pages) $ pipenv install gunicorn==19.9.0

Конфигурация для веб-сервера находится в файле wsgi.py, который Django автоматически создает для каждого нового проекта. Он находится в основной папке нашего проекта. Поскольку наш проект называется pages_project, сам файл находится в pages_project/wsgi.py.

Последний шаг — небольшое изменение в файле settings.py. Прокрутите вниз до части ALLOWED_HOSTS и добавьте '*'. Результат должен получиться следующим:

# pages_project/settings.py
ALLOWED_HOSTS = [‘*’]

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

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

Для проверки изменений мы выполним команду git status, добавляем новые файлы и затем коммитим их:

(pages) $ git status
(pages) $ git add -A
(pages) $ git commit -m «New updates for Heroku deployment»

Создаём сайт на Django, используя хорошие практики. Часть 1: создаём проект

Я начинаю серию статей, посвященных разработке сайтов на Django. Информация для этих статей получена из собственного опыта (полтора года коммерческой разработки на Django, несколько мелких фриланс-проектов, часть проекта pythonworld.ru написана на Django).

Django — веб-фреймворк для создания сайтов, написанный на языке Python. Язык и является одним из основных его преимуществ, так как обеспечивает быстрое написание кода. Также Django имеет «батарейки в комплекте», что означает, что для многих распространённых задач уже есть написанная библиотека. На текущий момент Django считается основным фреймворком Python для разработки веб-сайтов и веб-сервисов.

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

У сайта fl.ru есть RSS-ленты (с точки зрения программиста, это XML-файлы, в которых содержится информация о новых проектах). Посему данные будем брать оттуда (впоследствие мы подключим и другие источники данных).

• Linux-based система (Ubuntu 19.10 — прекрасный выбор)
• Python 3.7 (на Ubuntu 19.10 стоит изначально, на более ранние версии необходимо ставить отдельно
• PostgreSQL

Ставим зависимости (PostgreSQL), и создаём директорию для проекта:

sudo apt-get install postgresql-11
mkdir freelance_python
cd freelance_python/

Создаём и активируем виртуальное окружение (изолированное окружение среды Python, которое позволяет нам использовать определенные, не зависящие от системы, версии приложений):

sudo apt-get install python3-venv
python3.7 -m venv myvenv
source myvenv/bin/activate

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

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

pip install cookiecutter
cookiecutter https://github.com/pydanny/cookiecutter-django

При создании проекта необходимо ответить на несколько вопросов

project_name [My Awesome Project]: Python Freelance Projects Scaner
project_slug [python_freelance_projects_scaner]: freelance_python
description [Behold My Awesome Project!]: Python freelance projects scaner, built for pythonworld.ru
author_name [Daniel Roy Greenfeld]: Dmitriy Musin
domain_name [example.com]: freelance.pythonworld.ru
email [[email protected]]: [email protected]
version [0.1.0]:
Select open_source_license:
1 - MIT
2 - BSD
3 - GPLv3
4 - Apache Software License 2.0
5 - Not open source
Choose from 1, 2, 3, 4, 5 (1, 2, 3, 4, 5) [1]: 3
timezone [UTC]: UTC+3
windows [n]:
use_pycharm [n]: y
use_docker [n]:
Select postgresql_version:
1 - 11.3
2 - 10.8
3 - 9.6
4 - 9.5
5 - 9.4
Choose from 1, 2, 3, 4, 5 (1, 2, 3, 4, 5) [1]: 1
Select js_task_runner:
1 - None
2 - Gulp
Choose from 1, 2 (1, 2) [1]:
Select cloud_provider:
1 - AWS
2 - GCP
3 - None
Choose from 1, 2, 3 (1, 2, 3) [1]: 3
custom_bootstrap_compilation [n]:
use_compressor [n]:
use_celery [n]:
use_mailhog [n]:
use_sentry [n]:
use_whitenoise [n]: y
use_heroku [n]:
use_travisci [n]: y
keep_local_envs_in_vcs [y]: n
debug [n]:
 [WARNING]: You chose not to use a cloud provider, media files won't be served in production.
 [SUCCESS]: Project initialized, keep up the good work!

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

Мы будем использовать git и новый репозиторий на github.com.

$ git init
Initialized empty Git repository in /home/d/PycharmProjects/freelance_python/freelance_python/.git/
$ git config --global user.email "[email protected]"
$ git config --global user.name "Musin Dmitriy"
$ git remote add origin https://github.com/musindmitriy/freelance_python.git  # Это репозиторий на github.com, созданный вручную
$ git add .
$ git commit -m "Initial commit"
[master (root-commit) 82ffd0c] Initial commit
 118 files changed, 4313 insertions(+)
 ...
$ git push -u origin master
... Ввод логина-пароля от github ...

Теперь копия нашего кода доступна на странице нашего github-репозитория.

Установим локальные зависимости

pip install -r requirements/local.txt

Создаём базу данных в PostgreSQL

sudo -u postgres psql

CREATE USER myprojectuser WITH PASSWORD 'difficultpassword';
CREATE DATABASE myproject OWNER myprojectuser;
\q

Теперь применим миграции

export DATABASE_URL="postgres://myprojectuser:difficultpassword@localhost/myproject"
./manage.py migrate

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

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

DATABASE_URL="postgres://myprojectuser:difficultpassword@localhost/myproject"

Теперь достаточно сделать

export DJANGO_READ_DOT_ENV_FILE=true
./manage.py migrate

Далее я предполагаю, что каждый раз после активации виртуального окружения вы делаете export DJANGO_READ_DOT_ENV_FILE=true.

Запустим сервер:

./manage.py runserver

Заходим на 127.0.0.1:8000

Как видим, вместо стандартной django-страницы «It works!» cookiecutter предлагает страницу со ссылками на страницы авторизации и регистрации через django-allauth, а также автоматически подключен django-debug-toolbar, показывающий, сколько происходит запросов к различным компонентам и сколько времени они занимают.

Теперь у нас есть начальный django-проект. В следующей части мы напишем обработчик новых проектов с fl.ru для нашего проекта.

Django создание простого блога с нуля

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

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

Python 3.6.3 — высокоуровневый язык программирования.

Django 2.0.2 — фреймворк для веб-приложений.

Visual Code — текстовый редактор c поддержкой плагинов

Установка Python

Перед началом работы вам необходимо установить Python  для дальнейшей работы с django. Для этого переходим на официальный сайт, скачиваем дистрибутив и устанавливаем его (как обычное приложение), поставив галочку напротив «Add Python  to the PATH» (Добавить Python к системной переменной PATH). Если все сделано верно, то прописав в консоли (WIN + R > cmd) python, вы увидите следующее:

Для выхода пропишите exit().

Установка Django

Django установим с помощью менеджера пакетов Python — pip:

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

Для начала создадим папку для проекта в любом удобном месте и назовем ее «djangoProject». Далее Скопируем адрес этой папки и откроем консоль (WIN + R > cmd).

В консоли перейдем в созданную ранее папку. В моем случае папка находится на другом диске, поэтому сначала следует перейти на него — «d:»

cd <путь до папки>

Создадим django проект с произвольным именем «myBlog»

django-admin startproject myBlog

Перейдем в созданную папку и откроем ее в каком-либо текстовом редакторе. Я использую Visual code и запускаю его с помощью команды «code .»

Ненадолго отложим редактор и запустим стандартный проект django (при выполнении команд с обращением к файлу manage.py, например, запуск сервера вы должны находится в непосредственно в папке с этим файлом. В данном случае это D:\djangoProject\myBlog)

python manage.py runserver

Откроем страницу в браузере по адресу https://127.0.0.1:8000/

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

Завершим работу запущенного сервера:

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

Cоздадим суперюзера

python manage.py createsuperuser

Нам будет предложено ввести логин, e-mail почту и пароль.

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

Попробуем залогиниться в админ панели. Для этого запустим сервер:

python manage.py runserver

Зайдем на страницу по адресу 127.0.0.1:8000/admin. Вводим логин и пароль от админки и жмем «Log in».

В итоге откроется админ панель:

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

Для этого завершим работу сервера (Ctrl + C) и пропишем следующую команду:

django-admin startapp blog

Где «blog» — это произвольное название приложения. В итоге в директории djangoProject/myBlog появился новый каталог с именем «blog» и некоторыми .py файлами.

Далее нужно дать понять Django, что нужно использовать в работе наше новое приложение «blog». Для этого в файле settings.py с расположением djangoProject/myBlog/myBlog/settings.py изменяем настройку INSTALLED_APPS следующим образом:

INSTALLED_APPS = [
‘django.contrib.admin’,
‘django.contrib.auth’,
‘django.contrib.contenttypes’,
‘django.contrib.sessions’,
‘django.contrib.messages’,
‘django.contrib.staticfiles’,
‘blog’,
]

Поработаем с обработкой url-запросов. Нам необходимо, чтобы при запросе 127.0.0.1:8000 открывалась главная страница со списком всех статей.

Отредактируем файл djangoProject/myBlog/myBlog/urls.py следующим образом:

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

urlpatterns = [
path(», include(‘blog.urls’)),
path(‘admin/’, admin.site.urls),
]

Если говорить простым языком, то Django сравнивает url-запрос с данными в  urlpatterns. Т.е. открыв страницу с адресом 127.0.0.1:8000/ django выполнит строку path(», include(‘blog.urls’)). На основе которой будет «читать» файл по адресу djangoProject/myBlog/blog/urls.py. Создадим и отредактируем этот файл:

from django.urls import path

from .import views

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

Здесь идет переход «чтения» в файл views.py (в этой же папке), в котором используется функция home

Файл djangoProject/myBlog/blog/views.py

from django.http import HttpResponse
from django.shortcuts import render


def home(request):
return render(request, «partial/home.html»)

С помощью функции render выполняем шаблон home.html. Для этого создаем в папке djangoProject/myBlog новую с именем «templates». В этой папке будут храниться все требуемые шаблоны страниц (главная, шаблон подробного просмотра статьи).

И редактируем в файле djangoProject/myBlog/myBlog/settings.py настройку TEMPLATES:

TEMPLATES = [
{
‘BACKEND’: ‘django.template.backends.django.DjangoTemplates’,
‘DIRS’: [os.path.join(BASE_DIR, ‘templates’)],
‘APP_DIRS’: True,
‘OPTIONS’: {
‘context_processors’: [
‘django.template.context_processors.debug’,
‘django.template.context_processors.request’,
‘django.contrib.auth.context_processors.auth’,
‘django.contrib.messages.context_processors.messages’,
],
},
},
]

В созданной папке templates создаем файл base.html:

<!DOCTYPE html>
<html lang=»en»>
<head>
<meta charset=»UTF-8″>
<meta name=»viewport» content=»width=device-width, initial-scale=1.0″>
<meta http-equiv=»X-UA-Compatible» content=»ie=edge»>
{% block head %}
<title>Title</title>
{% endblock %}
</head>
<body>
{% block body %}
{% endblock %}
</body>
</html>

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

Создадим в папке djangoProject/myBlog/templates новую папку partial, в которой и будут находится .html файлы, расширяющие базовый.

В папке partial создадим файл home.html:

{% extends ‘base.html’ %}
{% block head %}
<title>Главная</title>
<meta name=»description» content=»Главная страница блога»/>
<meta name=»keywords» content=»блог»/>
{% endblock %}

{% block body %}
<h2>Главная</h2>
{% endblock %}

При обращении к файлу home.html содержимое блоков head и body в файле base.html заменится содержимым файла home.html. такая система организации шаблонов добавляет динамику и в разы упрощает работу.

Теперь запустив сервер откроется не стандартная страница django, а наш файл base.html, расширенный файлом partial/home.html

python manage.py runserver

Точно таким же способом добавим страницу для просмотра отдельной статьи, которую назовем partial/single.html:

Отредактируем файл djangoProject/myBlog/blog/urls.py, где <int:id> — указывает, что на этом месте может располагаться число, которое будет считываться в файле djangoProject/myBlog/blog/views в функции single. Это число будет использоваться как номер определенной статьи.

from django.urls import path

from .import views

urlpatterns = [
path(», views.home, name=’home’),
path(‘<int:id>/’, views.single, name=’single’),
]

В файле djangoProject/myBlog/blog/views.py добавим новую функцию для вывода отдельной статьи

from django.http import HttpResponse
from django.shortcuts import render


def home(request):
return render(request, «partial/home.html»)

def single(request, id=None):
return render(request, «partial/single.html»)

Создаем шаблон для вывода отдельной статьи  djangoProject/myBlog/templates/partial/single.html

{% extends ‘base.html’ %}
{% block head %}
<title>Странца статьи</title>
<meta name=»description» content=»Главная страница блога»/>
<meta name=»keywords» content=»блог»/>
{% endblock %}

{% block body %}
<h2>Странца статьи</h2>
{% endblock %}

Теперь после запуска сервера и переходе по ссылке 127.0.0.1:8000/323 откроется нужная страница.

Создадим таблицу в базе данных с помощью моделей. Каждая статья будет содержать следующие поля:

1. Название статьи
2. Описание статьи (для метатега description)
3. Ключевые слова (для метатега keywords)
4. Изображение
5. Текст статьи
6. Параметр видимости статьи (для сохранения статьи без её публикации)
7. Дата изменения
8. Дата создания

Файл djangoProject\myBlog\blog\models.py

from django.db import models

# Create your models here.

class Post(models.Model):
title = models.CharField(max_length=120)
description = models.TextField(default=’Описание’)
keywords = models.CharField(max_length=120, default=’Ключевые слова’)
image = models.FileField(null=True, blank=True)
content = models.TextField()
visible = models.BooleanField(default=1)
updated = models.DateTimeField(auto_now=True, auto_now_add=False)
timestamp = models.DateTimeField(auto_now=False, auto_now_add=True)

def __unicode__(self):
return self.title

def __str__(self):
return self.title

def get_absolute_url(self):
return «/%s/» %(self.id)

class Meta:
ordering = [«-id», «-timestamp»]

Для отображения нашей модели статьи в админ панели отредактируем файл djangoProject\myBlog\blog\admin.py, где list_display — поля, отображающиеся в списке статей; list_display_links — поля, являющиеся ссылками для подробного просмотра полей статьи; list_editable — поля, доступные для редактирования сразу из просмотра списка всех статей; list_filter — фильтры в правой части страницы; search_fields — поля по которым осуществляется поиск.

from django.contrib import admin

# Register your models here.

from .models import Post

class PostModelAdmin(admin.ModelAdmin):
list_display = [«id» ,»title», «updated», «timestamp»]
list_display_links = [«id», «updated»]
list_editable = [«title»]
list_filter = [«updated», «timestamp»]
search_fields = [«title», «content»]
class Meta:
model = Post

admin.site.register(Post, PostModelAdmin)

Укажем папку для сохранения загружаемых изображений (поле image) и паку для хранения статических файлов (например, css файлы, js срипты). Для этого добавим в конце файла djangoProject\myBlog\settings.py следующие 3 строчки

MEDIA_URL = ‘/media/’

STATIC_ROOT = os.path.join(BASE_DIR, «static»)

MEDIA_ROOT = os.path.join(os.path.dirname(BASE_DIR), «media»)

И создадим эти папки со следующим расположением: djangoProject/media и djangoProject/static

Помимо сохранения изображений через админ панель необходимо корректно их загружать в шаблон. Для этого отредактируем файл djangoProject\myBlog\views.py

from django.contrib import admin
from django.urls import path, include
from django.conf import settings
from django.conf.urls.static import static

urlpatterns = [
path(», include(‘blog.urls’)),
path(‘admin/’, admin.site.urls),
]

urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

Запускаем сервер

python manage.py runserver

Заходим в админ панель — 127.0.0.1:8000/admin > переходим в Posts > add Post (в верхнем правом углу). Заполняем текстовые поля, загружаем изображение и оставляем галочку напротив visible (т.е. не скрывать статью). Нажимаем SAVE. Статья добавлена, изображение сохранилось в папку djangoProject/media

Настало время для вывода статей в шаблон home, т.е. на главную страницу.

Изменяем файл djangoProject/myBlog/blog/views.py. Подключаем модули для работы с пагинацией (постраничный вывод новостей) и модель Post. В функции home получаем все записи из таблицы Post и делим их по 4 на каждую страницу. Словарь context содержит ключи и значения, которые будут далее выводиться в шаблон.

from django.http import HttpResponse
from django.shortcuts import render
from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger

from blog.models import Post


def home(request):
postList = Post.objects.filter(visible=’1′)
paginator = Paginator(postList, 4)
page = request.GET.get(‘page’)
querysetGoods = paginator.get_page(page)

context = {
«postList»: postList,
«title»: «Главная страница блога»,
«desc»: «Описание для главной страницы»,
«key»: «ключевые, слова»,
}
return render(request, «partial/home.html», context)

def single(request, id=None):
return render(request, «partial/single.html»)

Файл djangoProject\myBlog\templates\partial\home.html

С помощью тега truncatechars, обрежем строку до 70 первых символов.

{% extends ‘base.html’ %}
{% block head %}
<title>Главная</title>
<meta name=»description» content=»{{ desc }}»/>
<meta name=»keywords» content=»{{ key }}»/>
{% endblock %}

{% block body %}
<h2>Главная</h2>
{% if not posts %}
<b>Статьи не найдены</b>
{% else %}
{% for obj in posts %}
<a href=»{{ obj.get_absolute_url }}»><b>{{ obj.title }}</b></a>
<img src=»{{ obj.image.url }}» alt=»»>
<p>{{ obj.content|truncatechars:70 }}</p>
<span>{{ obj.timestamp }}</span>
<br><br><br>
{% endfor %}
{% endif %}

{% if posts.has_previous %}
<a href=»?page={{ posts.previous_page_number }}»>Назад</a>
{% endif %}
<span>{{ posts.number }} / {{ posts.num_pages }}</span>
{% if posts.has_next %}
<a href=»?page={{ posts.next_page_number }}» >Вперед</a>
{% endif %}
{% endblock %}

В базовый шаблон djangoProject\myBlog\templates\base.html добавим css файл, который следует создать с расположением djangoProject\static\css\style.css

img {
width: 400px;
height: auto;
display: block;
}

Файл djangoProject\myBlog\templates\base.html

<!DOCTYPE html>
<html lang=»en»>
<head>
<meta charset=»UTF-8″>
<meta name=»viewport» content=»width=device-width, initial-scale=1.0″>
<meta http-equiv=»X-UA-Compatible» content=»ie=edge»>
{% load static %}
<link href=»{% static ‘css/style.css’ %}» rel=»stylesheet»>
{% block head %}
<title>Title</title>
{% endblock %}
</head>
<body>
{% block body %}
{% endblock %}
</body>
</html>

Для проверки пагинации добавим еще несколько статей.

Все работает! При переходе на следующую страницу изменяется параметр «page», указывающий на номер текущей страницы.

Займемся выводом отдельной статьи (подробной просмотр). Роутинг (в файле djangoProject\myBlog\blog\urls.py) уже настроен, осталось добавить выводимую информацию, в зависимости от id в адресной строке. Отредактируем файл djangoProject\myBlog\blog\views.py, в котором создадим новую функцию «single». Обратите внимание, в начале файле была подключена вспомогательная функция «get_object_or_404», возвращающая необходимую статью (по id) или же исключение 404, если пользователь введет несуществующий id.

Урок #3 — Создание первого Django приложения

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

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

Каждое Django приложение имеет 3 обязательных файла:

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

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

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

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

from django.conf.urls import path, include # В Django версии 2 и выше используется path, вместо url
# Также не забудьте подключить include ↑
from django.contrib import admin

urlpatterns = [
	# В новой версии Django вместо url используется функция path
	# url(r'^admin/', admin.site.urls),
	# url(r'^webexample/', include('webexample.urls')),
	
	path('admin/', admin.site.urls),
	path('webexample/', include('webexample.urls'))
]

Теперь при переходе по ссылке webexample (можно указать любую ссылку) django будет подключать приложение с названием webexample. При этом он сразу будет смотреть на файл «urls.py» внутри этого приложения. В файле«sebexample/urls.py» вы можете отслеживать различные ссылки. В зависимости от отслеживаемой ссылки вы можете подключать различные HTML шаблоны для отображения на сайте.

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

Django | Введение

Что такое Django

Последнее обновление: 14.02.2018

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

Django был создан в 2005 году, когда веб-разработчики из газеты Lawrence Journal-World стали использовать Python в качестве языка
для создания веб-сайтов. А в 2008 году вышел публичный первый релиз фреймворка. На сегодняшний день он продолжает развиваться. Так, текущей версией фреймворка
на момент написания этой статьи является версия 2.0, которая вышла 3 декабря 2017 года. Ну и также постоянно выходят подверсии.

Django довольно популярен. Он используется на многих сайтах, в том числе таких, как Pinterest, PBS, Instagram, BitBucket,
Washington Times, Mozilla и многих других.

Фреймворк является бесплатным. Он развивается как open source, его исходный код открыт, его можно найти репозитории на
githube.

Фреймворк Django реализует архитектурный паттерн Model-View-Template или сокращенно MVT,
который по факту является модификацией распростаненного в веб-программировании паттерна MVC (Model=-View-Controller).

Схематично мы можем представить архитектуру MVT в Django следующим образом:

Основные элементы паттерна:

• URL dispatcher: при получение запроса на основании запрошенного адреса URL определяет, какой ресурс должен
  обрабатывать данный запрос.

• View: получает запрос, обрабатывает его и отправляет в ответ пользователю некоторый ответ. Если для обработки запроса
  необходимо обращение к модели и базе данных, то View взаимодействует с ними. Для создания ответа может применять Template или шаблоны. В архитектуре
  MVC этому компоненту соответствуют контроллеры (но не представления).

• Model: описывает данные, используемые в приложении. Отдельные классы, как правило, соответствуют таблицам в базе данных.

• Template: представляет логику представления в виде сгенерированной разметки html. В MVC этому компоненту соответствует
  View, то есть представления.

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

Django для начинающих — Полное руководство для Django 3.0

Django для начинающих — Полное руководство для Django 3.0

Пошаговое руководство по созданию веб-приложений с помощью Python и Django 3.0.

Создавайте, тестируйте и развертывайте 5 все более сложных веб-сайтов, включая приложение Message Board, приложение Blog с учетными записями пользователей и надежное приложение Newspaper с комментариями читателей и полным процессом регистрации пользователей.

Охватываемые темы: Django 3.0 и Python 3.7, Pipenv для виртуальных сред, шаблоны, URL-адреса, представления на основе классов, аутентификация пользователей, настраиваемые модели пользователей, разрешения и авторизация, развертывание и тестирование.

• Введение
• Глава 1: Начальная настройка
• Глава 2: Приложение Hello World
• Глава 3: Приложение Pages
• Глава 4: Приложение Messsage Board
• Глава 5. Приложение для блога
• Глава 6: Формы
• Глава 7. Учетные записи пользователей
• Глава 8: Пользовательская модель пользователя
• Глава 9: Аутентификация пользователя
• Глава 10. Загрузочный файл
• Глава 11. Смена и сброс пароля
• Глава 12: Электронная почта
• Глава 13: Газетное приложение
• Глава 14: Разрешения и авторизация
• Глава 15: Комментарии
• Заключение

Q: В каком формате книга?

Книга представлена ​​в форматах PDF, EPUB и MOBI.Это 318 страниц. Версия для печати, а также обзоры доступны на Amazon.

В: Вы писали дополнительные книги?

Да, вообще-то! Я также написал Django для API и Django для профессионалов. Вы можете приобрести все три книги со скидкой 20 долларов.

В: Могу ли я получить счет?

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

В: Предлагаете ли вы скидки для студентов / некоммерческих организаций?

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

В: Дополнительные вопросы?

Если у вас есть вопросы, напишите мне по адресу [email protected].

,

Глава 1: Начальная настройка

В этой главе рассказывается, как правильно настроить компьютер для работы с проектами Django. Начнем с обзора командной строки и того, как установить последнюю версию Django (3.0) и Python 3.7. Затем мы обсудим виртуальные среды, git и работу с текстовым редактором. К концу этой главы вы будете готовы создавать и изменять новые проекты Django всего несколькими нажатиями клавиш.

Командная строка

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

На Mac командная строка находится в программе под названием Terminal , расположенной по адресу / Applications / Utilities . Чтобы найти его, откройте новое окно Finder, откройте каталог Applications, прокрутите вниз, чтобы открыть каталог Utilities, и дважды щелкните приложение под названием Terminal.

На компьютерах с Windows фактически есть две встроенные командные оболочки: оболочка Command и PowerShell .Вам следует использовать PowerShell, который является более мощным из двух.

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

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

• cd (перейти в каталог)
• cd .. (перейти в каталог)
• ls (список файлов в текущем каталоге на Mac)
• dir (список файлов в текущем каталоге в Windows)
• pwd (распечатать рабочий каталог)
• мкдир (каталог создания)
• сенсорный (создать новый файл на Mac)

Откройте командную строку и попробуйте их.Знак доллара ( $ ) — это приглашение командной строки: все команды в этой книге предназначены для ввода после приглашения $ .

Например, если вы работаете на Mac, давайте перейдем в каталог рабочего стола.

Обратите внимание, что наше текущее местоположение, ~ / Desktop , автоматически добавляется перед командной строкой. Чтобы убедиться, что мы находимся в правильном месте, мы можем использовать pwd , который распечатает путь к нашему текущему каталогу.

  ~ / Рабочий стол $ pwd
/ Users / WSv / настольные
  

На моем компьютере Mac это означает, что я использую пользователя wsv , а на настольном компьютере для этой учетной записи.

Теперь давайте создадим новый каталог с mkdir , cd и добавим новый файл index.html с помощью команды touch . Обратите внимание, что машины с Windows, к сожалению, не поддерживают собственную команду touch . В будущих главах, когда вам будет предложено создать новый файл, делайте это в любом текстовом редакторе.

  ~ / Рабочий стол $ mkdir new_folder
~ / Рабочий стол $ cd new_folder
~ / Рабочий стол / новая_папка $ touch index.html
  

Теперь используйте ls , чтобы вывести список всех текущих файлов в нашем каталоге.Вы увидите только что созданный index.html .

  ~ / Рабочий стол / новая_папка $ ls
index.html
  

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

  ~ / Рабочий стол / новая_папка $ cd ..
~ / Рабочий стол $ pwd
/ Users / WSv / настольные
  

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

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

Установить Python 3

Для правильной установки Python 3 на Mac, Windows, Linux или Chromebook требуется некоторая настройка, и существует несколько подходов. Многие разработчики, особенно новички, следуют советам на официальном веб-сайте Python, чтобы загрузить отдельные версии Python прямо на свой компьютер, а затем соответствующим образом настроить переменную PATH.

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

Я размещаю специальный веб-сайт InstallPython3.com с новейшими руководствами по установке Python 3 на компьютеры Mac, Windows или Linux. Пожалуйста, обратитесь туда, чтобы правильно установить Python на ваш локальный компьютер.

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

Виртуальные среды — неотъемлемая часть программирования на Python.Они представляют собой изолированный контейнер, содержащий все программные зависимости для данного проекта. Это важно, потому что по умолчанию программное обеспечение, такое как Python и Django, установлено в том же каталоге . Это вызывает проблему, если вы хотите работать над несколькими проектами на одном компьютере. Что, если ProjectA использует Django 2.1, но ProjectB из прошлого года все еще находится на Django 1.10? Без виртуальных сред это становится очень сложно; с виртуальными средами это вообще не проблема.

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

В этой книге мы будем использовать Pipenv для управления виртуальными средами. Pipenv похож на npm и yarn из экосистемы JavaScript / Node: он создает Pipfile , содержащий программные зависимости и Pipfile.Замок для обеспечения детерминированных сборок. «Детерминизм» означает, что каждый раз, когда вы загружаете программное обеспечение в новую виртуальную среду, у вас будет точно такая же конфигурация .

Себастьян Маккензи, создатель Yarn, который впервые представил эту концепцию в упаковке JavaScript, опубликовал краткое сообщение в блоге, в котором объясняется, что такое детерминизм и почему он важен. В итоге мы создадим новую виртуальную среду с Pipenv для каждого нового проекта Django.

Для установки Pipenv мы можем использовать pip3 , который HomeBrew автоматически установил для нас вместе с Python 3.

Установить Django

Чтобы увидеть Pipenv в действии, давайте создадим новый каталог и установим Django. Сначала перейдите на Рабочий стол, создайте новый каталог django и войдите в него с cd .

  $ cd ~ / Рабочий стол
$ mkdir джанго
$ cd django
  

Теперь используйте Pipenv для установки Django.Обратите внимание на использование ~ = , которое обеспечит обновления безопасности для Django, такие как 3.0.1, 3.0.2 и т. Д.

  $ pipenv установить django ~ = 3.0.0
  

Если вы заглянете в наш каталог, то увидите два новых файла: Pipfile и Pipfile.lock . У нас есть информация, необходимая для новой виртуальной среды, но мы еще не активировали ее. Давайте сделаем это с помощью оболочки pipenv .

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

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

Значит, работает! Создайте новый проект Django с именем config с помощью следующей команды. Не забывайте тот период года. в конце.

  (django) $ django-admin startproject config. 

Здесь стоит остановиться, чтобы объяснить, почему вы должны добавить к команде точку (. ). Если вы просто запустите django-admin startproject config , то по умолчанию Django создаст такую ​​структуру каталогов:

  └── конфиг
    ├── manage.py
    └── конфиг
        ├── __init__.py
        ├── asgi.py
        ├── settings.py
        ├── urls.py
        └── wsgi.py
  

Посмотрите, как он создает новый каталог config , а затем в нем управляет .py файл и config каталог? Мне это кажется излишним, поскольку мы уже создали папку django на нашем рабочем столе и перешли в нее. Запустив django-admin startproject config. с точкой в ​​конце — что означает установку в текущий каталог — вместо этого результат будет следующим:

  ├── manage.py
└── конфиг
    ├── __init__.py
    ├── asgi.py
    ├── settings.py
    ├── urls.py
    └── wsgi.py
  

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

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

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

  (django) $ python manage.py сервер запуска
Наблюдение за изменениями файлов с помощью StatReloader
Выполнение системных проверок ...

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

У вас 17 непримененных миграций. Ваш проект может не работать должным образом, пока
вы применяете миграции для приложений: admin, auth, contenttypes, sessions.
Запустите python manage.py migrate, чтобы применить их.

24 июня 2020 года - 14:52:27
Django версии 3.0, используя настройки config.settings
Запуск сервера разработки по адресу http: // 127.0.0.1: 8000 /
Закройте сервер, нажав CONTROL-C.
  

Если вы посетите http://127.0.0.1:8000/, вы должны увидеть следующее изображение:

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

Чтобы остановить наш локальный сервер, введите Control-c . Затем выйдите из нашей виртуальной среды, используя команду exit .

Мы всегда можем снова активировать виртуальную среду с помощью оболочки pipenv в любое время.

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

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

Установить Git

Git — незаменимая часть современной разработки программного обеспечения. Это система контроля версий, которую можно рассматривать как чрезвычайно мощную версию отслеживания изменений в Microsoft Word или Google Docs. С помощью git вы можете сотрудничать с другими разработчиками, отслеживать всю свою работу с помощью коммитов и возвращаться к любой предыдущей версии вашего кода, даже если вы случайно удалили что-то важное!

На Mac, поскольку HomeBrew уже установлен, мы можем просто ввести brew install git в командной строке:

В Windows вы должны загрузить Git из Git для Windows.Нажмите кнопку «Загрузить» и следуйте инструкциям по установке.

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

  $ git config --global user.name "Ваше имя"
$ git config --global user.email "[email protected]"
  

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

Текстовые редакторы

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

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

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

Заключение

Уф! На самом деле никому не нравится настраивать локальную среду разработки, но, к счастью, это разовая боль. Теперь мы научились работать с виртуальными средами и установили последнюю версию Python и git.Все готово для нашего первого приложения Django.

Перейдите к главе 2: Приложение Hello World.

,

Django Tutorial for Beginner — Изучите основные аспекты Django Framework

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

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

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

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

1. Что такое Django?

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

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

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

2. Учебник Django — История Django Framework

Теперь, в учебнике Django, мы обсудим историю Django. Django был создан двумя веб-разработчиками Адрианом Головати и Саймоном Уиллисоном, работавшими в Lawrence Journal-World Newspaper в 2003 году. Он был выпущен публично как лицензия BSD в июле 2005 года.Фреймворк был назван в честь гитариста Джанго Рейнхардта.

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

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

3. Предварительные условия для изучения Django

Вы должны иметь некоторые предварительные знания Python и иметь некоторое общее представление об интерфейсе командной строки / PowerShell для Windows или Терминале для macOS / Linux .

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

4. Зачем изучать Django?

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

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

Вот несколько важных причин для изучения Django:

i. Django эволюционировал с течением времени

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

ii. Технология с открытым исходным кодом

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

iii. Одно из лучших в мире сообществ разработчиков программного обеспечения.

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

iv.У Django много готовых приложений

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

5. Особенности Django Framework

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

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

i. Стабильность

Часто вы видите, что Django является одним из первых фреймворков, реагирующих на новую уязвимость. Это означает, что Django — это проверенный временем фреймворк, который с течением времени совершенствовался. Не все ошибки, но многие из них исправлены в Django. Как вы, наверное, слышали: «С возрастом люди становятся мудрее; программное обеспечение со временем принимает лучшие решения ».

ii. Отличная документация

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

iii. Высокая масштабируемость

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

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

Например — Instagram и Pinterest используют Django, сохраняя при этом большое количество активных пользователей.

iv. Устраняет проблемы безопасности

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

v. Использует SEO.

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

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

vi. Огромная библиотека пакетов

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

vii. Позволяет прагматичный и надежный дизайн

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

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

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

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

• Модель — Модель — это логическая структура данных, лежащая в основе всего приложения. и представляет собой базу данных (обычно реляционные базы данных, такие как MySQL, Postgres).
• Просмотр — Просмотр — это пользовательский интерфейс, который вы видите в браузере всякий раз, когда посещаете веб-сайт. Они представляют его через файлы HTML / CSS / JavaScript.
• Контроллер — Контроллер — это посредник, который соединяет представление и модель вместе. Это означает, что контроллер передает данные из модели в представление.

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

Например — Пользователь вводит URL-адрес в своем браузере, этот запрос будет проходить через интернет-протоколы (HTTP) на сервер, который вызовет Django.Затем Django обработает указанный URL-адрес, и, если URL-адрес совпадает, он вызовет контроллер, который получит запись из вашей базы данных и затем отобразит представление (веб-страница HTML / CSS / JavaScript).

7. Учебник по Django — Компании, использующие Django

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

Среди крупнейших веб-сайтов, использующих Django, есть:

i.Instagram

Instagram, одно из крупнейших приложений для социальных сетей, очень популярное социальное приложение. Django лежит в основе Instagram, и они только что стали спонсором золотого уровня Django Software Foundation (DSF) .

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

ii. Disqus

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

iii. Spotify

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

iv. YouTube

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

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

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

8. Преимущества Django

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

i. Loose Coupling

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

ii. Lesser Code

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

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

iii. Не повторяется

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

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

iv. Согласованность

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

v. Универсальность

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

На этом руководство по Django подошло к концу. Надеемся, вам понравится наше объяснение.

9. Django Tutorial — Summary

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

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

Есть вопросы или отзывы, связанные с Учебником Django? Не стесняйтесь войти в раздел комментариев.

.

Django Web Framework (Python) — Изучите веб-разработку

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

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

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

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

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

Направляющие

Введение в Django

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

Настройка среды разработки Django

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

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

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

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

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

Учебное пособие по

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

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

Учебное пособие по

Django, часть 4: сайт администратора Django

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

Учебное пособие по Django, часть 5: Создание домашней страницы

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

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

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

Учебник по Django, часть 7: Фреймворк сессий

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

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

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

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

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

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

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

Django Tutorial Part 11: Deploying Django to production

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

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

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

Оценки

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

Сделай сам Django mini blog

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

.