Django — Что нужно коммитить, а что не нужно (Django)


Содержание

Почему Django — лучший фреймворк для разработки сайтов

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

Прошлое и будущее фреймворка Django: краткий экскурс в историю

Django создали разработчики издания Lawrence-Journal World. Этой газете понадобился сайт, чтобы публиковать новости в интернете. Программисты Эдриан Головатый и Саймон Виллисон создали веб-приложение и сделали его публичным.

Вокруг Django быстро сформировалось активное сообщество. Фреймворк стал стремительно развиваться усилиями волонтёров. Значительную роль в успехе Django сыграли несколько известных сайтов, которые использовали этот фреймворк. В их число входят Pinterest, Dropbox, Spotify, сайт The Washington Post. В настоящее время сообщество Django включает более 11 тыс. разработчиков из 166 стран мира.

Эти сайты используют Django

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

В Django реализован принцип DRY (don’t repeat yourself). Благодаря этому сокращается время создания сайтов. То есть при использовании Django вам не нужно несколько раз переписывать один и тот же код. Фреймворк позволяет создавать сайт из компонентов. Это можно сравнить со строительством крепости с помощью Lego.

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

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

Фреймворк Django написан на языке программирования Python, поэтому его структура соответствует особенностям языка. Создатели реализовали в Django паттерн MVC, и он применяется в текущей версии фреймворка.

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

Схема архитектуры MVT в Django

Документация Django определяет модель (model) как «источник информации о данных, в которых содержатся ключевые поля и поведение данных». Обычно одна модель указывает на одну таблицу в базе данных. Django поддерживает базы данных PostgreSQL, MySQL, SQLite и Oracle.

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

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

Представление (view) решает три задачи: принимает HTTP-запросы, реализует бизнес-логику, определённую методами и свойствами, отправляет HTTP-ответ в ответ на запросы. То есть представление получает данные от модели и предоставляет шаблонам (templates) доступ к этим данным или предварительно обрабатывает данные и затем предоставляет к ним доступ шаблонам.

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

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

Какие задачи можно решать с помощью Django: движки для сайтов, CRM, machine learning

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

Справка: название фреймворка подчёркивает его многогранность. Он назван в честь известного джазового гитариста Джанго Рейнхардта. Этот музыкант виртуозно играл на гитаре, хотя два пальца на его левой руке не функционировали после травмы, полученной во время пожара. То есть музыканту приходилось брать аккорды тремя пальцами.

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

  • CRM-систем.
  • CMS.
  • Коммуникационных платформ.
  • Сервисов бронирования номеров.
  • Платформ управления документооборотом.

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

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

Почему Django — отличный фреймворк для веб-разработки: экосистема, SEO, библиотеки

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

Развитая экосистема

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

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

Зрелость

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

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

Административная панель

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

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

SEO-дружественность

Написанный на Python код получается читабельным и понятным даже неподготовленным людям. Это один из факторов, благодаря которым веб-приложения на Python считаются SEO-дружественными. Django генерирует семантические URL. Их также называют человеко-понятными URL или ЧПУ. В приложениях на Django легко реализуются другие функции, необходимые для поисковой оптимизации.

Расширяемость

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

Библиотеки

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

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

  • Django REST Framework, который упрощает работу с API.
  • Django CMS — удобный инструмент для управления контентом.
  • Django-allauth — с его помощью реализуются функции регистрации, авторизации, управления учётными записями.

В Django реализовано объектно-реляционное отображение (ORM), которое обеспечивает взаимодействие приложения с базами данных (БД). ORM автоматически передаёт данные из БД, например, PostgreeSQL или MySQL, в объекты, которые используются в коде приложения.

Схема работы ORM

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

Также ORM позволяет быстро переключаться между базами данных с минимальными изменениями кода. Например, вы можете использовать SQLite на локальном сервере, а потом переключиться на MySQL на production-сервере. Однако для минимизации ошибок лучше использовать одну базу данных во время разработки и в продакшене.

Недостатки Django: не для маленьких проектов, не всегда предсказуемое поведение

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

Не подходит для небольших проектов

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

Нет поддержки WebSocket по умолчанию

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

Монолитность

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

Непредсказуемость поведения некоторых компонентов

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


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

Альтернативы Django

Фреймворки ускоряют разработку веб-приложений. И в экосистеме Python есть несколько фреймворков, которые можно рассматривать в качестве альтернативы Django. В их число входят Pyramid, Flask и Tornado. Все три инструмента подходят для работы как с масштабными проектами, так и с небольшими приложениями.

Также в качестве альтернативы можно рассматривать PHP-фреймворки, например, Laravel, Symphony или CakePHP. Например, Laravel подходит для работы с масштабными и маленькими проектами, и в этом фреймворке есть мощный движок шаблонов.

Если для вашего проекта критически важна безопасность, Laravel можно считать инструментом первого выбора. В нём реализованы мощные инструменты шифрования. Этот PHP-фреймворк работает с базами данных MySQL, PostgreSQL, SQL Server, SQ Lite.

Ещё одна достойная альтернатива — фреймворк Ruby on Rails. Этот инструмент ускоряет создание веб-приложений и позволяет разработчикам сфокусироваться скорее на бизнес-логике, чем на коде. Кстати, наш сайт создан на Ruby on Rails.

Смотрите также: стрим с Кириллом Мокевниным «Создание сайта на Rails с нуля».

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

Заключение: почему стоит выбрать Django

Разработчики выбирают Django благодаря таким характеристикам:

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

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

Адаптированный перевод статьи Why Django is the best web framework for your project by Ekaterina Zublenko and Angela Beklemysheva. Мнение авторов может не совпадать с мнением администрации «Хекслета».

В чем разница между django-tastypie и djangorestframework? [закрытый]

Почему бы вам использовать один над другим, для предоставления API для вашего приложения Django?

7 ответов:

Как автор django-rest-framework, у меня есть очевидная предвзятость ;) но мое, надеюсь, довольно объективное мнение об этом что-то вроде:

TastyPie

  • как отметил Торстен, вы не собираетесь идти далеко не так с чем-то написанным теми же хевами, что и awesome Джанго-сена. Из того, что я видел в их списке рассылки Daniel Lindsey et al, они очень полезны, а Tastypie стабильна, всеобъемлюща и хорошо документально
  • превосходит в предоставлении вам разумный набор поведения по умолчанию и делает создание API с этим стилем невероятно легко.

Django REST framework

  • дает вам HTML обзор-возможность самоописания API. (Например, см. учебник API.) Возможность навигации и взаимодействия с API непосредственно в браузере-это большая победа в юзабилити.
  • пытается оставаться рядом с Джанго идиомы во всем-построен на вершине Представления на основе классов Django и т. д. (В то время как TastyPie появился до того, как CBVs Django существовал, поэтому использует собственную реализацию представлений на основе классов)
  • Я хотел бы думать, что базовая архитектура очень красивая, развязкой и т. д.

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

очевидно, что есть также Почему TastyPie?- раздел в нем README, и ‘REST framework 2 объявление’.

см. также сообщение в блоге Даниэля Гринфельда на выбор платформы API для Django, С мая 2012 (стоит отметить, что это было еще за несколько месяцев до большой Rest framework 2.0 release).

также несколько потоков на Reddit с людьми, задающими этот же вопрос, от декабрь 2013 и июль 2013.

последнее обновление февраль 2014

оба являются хорошим выбором.

для фильтров, tastypie является более мощным из коробки. Если у вас есть представление, которое предоставляет модель, вы можете сделать фильтры неравенства в стиле Django:

или или запросах:

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

для tracebacks, я был более впечатлен django-rest-framework. Tastypie пытается отправить по электронной почте settings.ADMINS об исключениях, когда DEBUG = False . Когда DEBUG = True ,сообщение об ошибке по умолчанию сериализованный в JSON, что труднее читать.

EDIT устаревший ответ, tastypie на самом деле больше не поддерживается. Используйте Django Rest framework, если вам нужно выбрать фреймворк для отдыха.

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

Я лично склонен к tastypie, хотя. Кажется, его легче настроить. Это сделано из тех же людей, которые создали Джанго-сена что является удивительным и в соответствии с django-пакеты он используется больше, чем Django Rest framework.

стоит отметить, что с тех пор, как это было впервые задано, DRF перешел от силы к силе.

Это более активный из двух на github (как с точки зрения коммитов, звезд, вилок и участников)

ФПИ имеет поддержку протокола OAuth 2 и API доступны для просмотра.

честно говоря, для меня это последняя функция-убийца. Возможность указать все мои интерфейсные разработчики на просматриваемый API, когда они не уверены, как что-то работает, и сказать «Go play; find out» — это фантастический.

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

использовав оба, одна вещь, которая мне понравилась (предпочтительно) о Django Rest Framwork, это то, что очень согласуется с Django.

написание модельных сериализаторов очень похоже на написание модельных форм. Встроенные общие представления очень похожи на общие представления Django для HTML.

Ну, Tastypie и DRF оба являются отличным выбором. Ты просто Не могу пойти не так с любым из них. (Я никогда не работал над Piston; и его вид больше не в тренде теперь дни, поэтому не будет / не может прокомментировать его. Как само собой разумеющееся.). По моему скромному мнению: выбор должен быть сделан на ваших (и вашей технической команды) навыков, знаний и возможностей. вместо того, что предлагает TastyPie и DRF, если только вы не строите что-то действительно большое, как Quora, Facebook или Google.

лично я в конечном итоге начал работать сначала на TastyPie в то время, когда я даже не знал Джанго должным образом. В то время все это имело смысл, только зная REST и HTTP очень хорошо, но почти не зная или мало зная о django. Потому что мое единственное намерение состояло в том, чтобы построить RESTful API в кратчайшие сроки, которые должны были быть использованы в мобильных устройствах. Так что если вы просто, как ‘я случайно в то время называется django-new-bie»,Не думаю, что больше пойти TastyPie.

но если у вас много лет опыта работы с Django, знает его наизнанку и очень удобно использовать передовые концепции (например, представления на основе классов, формы, валидатор модели, QuerySet, менеджер и экземпляры модели и как все они взаимодействуют друг с другом), **перейти на DRF. ** DFR основан на представлениях на основе классов django. DRF-это идиоматический Джанго. Его, как вы пишете типовые формы, валидаторы и т. д. (Ну, идиоматический django не где рядом идиоматический питон. Если вы являетесь экспертом по python, но не имеете опыта работы с Django, то вам может быть трудно изначально вписаться в идиоматическую философию django и, если на то пошло, DRF). DRF поставляется с большим количеством встроенных магических методов, таких как django. Если вы любите Джанго магические методы и философию * * DRF * * это только для вас.

Цукерберг рекомендует:  Галерея с линейкой предварительного просмотра в стиле Полароид

теперь, чтобы точно ответить вопрос:

Tastypie:

  1. легко начать работу и обеспечить основные функциональные возможности OOB (из коробки)
  2. большую часть времени вы не будете иметь дело с передовыми концепциями Django, такими как CBVs, формы и т. д.
  3. более читаемый код и меньше магии!
  4. если ваши модели не-ОРМ, то пойдите для оно.
  1. строго не следует идиоматическому Django (разум хорошо python и философии django совершенно разные)
  2. вероятно, немного трудно настроить API, как только вы идете большой
  3. Нет O-Auth

DRF:

  1. следуйте идиоматический django. (Если вы знаете, Джанго наизнанку, и очень удобно с ЦБВ, форм и т. д. без всяких сомнений пойти на это)
  2. предоставляет стандартную функциональность остальных, используя ModelViewSets. В то же время, обеспечивает больший контроль для настройки с помощью CustomSerializer, APIView, GenericViews и т.д.
  3. лучше аутентификация. Проще писать пользовательские классы разрешений. Работа очень хорошо и, что немаловажно, очень легко заставить его работать с библиотеками 3rd party и OAuth. DJANGO-REST-AUTH стоит упомянуть библиотеку для аутентификации / социальной аутентификации / регистрации. (https://github.com/Tivix/django-rest-auth)


  1. если вы не знаете Джанго очень хорошо, не идите на это.
  2. магия! Некоторое время очень трудно понять магию. Потому что он был написан поверх CBV django, которые, в свою очередь, довольно сложны по своей природе. (https://code.djangoproject.com/ticket/6735)
  3. имеет крутое обучение кривая.

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

теперь я больше не поклонник магии и готовых функций. Потому что все они приходят по *большой цене. * Предполагая, что у меня есть все варианты и контроль над временем и бюджетом проекта, я бы начал с чего-то легкого, как беспокойный (https://github.com/toastdriven/restless) (создано создателем TastyPie и django-haystack (http://haystacksearch.org/)). и по тому же вопросу, вероятно,/определенно выберите легкий веб-фреймворк, например фляга.

но почему? — Более читаемый, простой и управляемый идиоматический код python (он же pythonic). Хотя больше кода, но в конечном итоге обеспечивают большую гибкость и возможности настройки.

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

Что делать, если у вас нет выбора, кроме Django и одного из TastyPie и DRF?

  • теперь, зная Джанго достаточно хорошо, я пойду с **DRF. **
  • почему? — идиоматический джагно! (Я не люблю его, Хотя). Лучшая интеграция OAuth и 3rd party (django-rest-auth-мой любимый).

тогда почему вы выбрали DRF / TastyPie на первом месте?

  • в основном я работал со стартапами и небольшими фирмами, которые ограничены в бюджете и времени; и нужно доставить что-то быстрое и полезное. Джанго служат этой цели очень хорошо. (я вовсе не говорю, что django не масштабируется. Есть такие сайты, как Quora, Disquss, Youtube и т. д. работают на нем. Но все это требует времени и более чем средних навыков)

Я надеюсь, это поможет вам принять лучшее решение.

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

в настоящее время вы должны использовать django-rest-framework с django, если вы готовы предоставить свой API.

крупные корпорации используют его. django-rest-framework является основным членом команды django, и он получает финансирование для поддержания django-rest-framework.

django-rest-framework также имеют огромное количество постоянно растущих 3-х арт пакеты тоже, которые помогут вам построить свой API более легко с меньшим количеством неприятностей.

некоторая часть drf также будет объединена в собственно django.

drf обеспечивает более лучшие шаблоны и инструменты, чем django-tastypie.

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

Алексей Лавриненко | Oleksiy Lavrynenko

Привет всем! Сегодня мы познакомимся с темой, которая звучит как: Django — как пользоваться: начало ��

Собственно, рассказывать о том, что такое Django не буду (пришли вы сюда по поисковому запросу, а значит искали не просто так от скуки �� ). Подробности как всегда в Wikipedia, или на сайте проекта.

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

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

Итак, начнем с установки. Как всегда — установить библиотеку можно двумя путями либо через pip, либо через PyCharm.
Установка через pip (используется командная строка): pip install django
Установка через PyCharm:
FileSetting for projectProject interpreter — кнопочка Плюс (выделена красным):
установка Django в PyCharm

и в открывшемся окошке вводим название библиотеки Django:
установка Django в PyCharm — 2

после чего устанавливаем библиотеку:
установка Django в PyCharm — 3

ВАЖНО: никакого ярлыка Django у вас на рабочем столе или в меню ПУСК не появится. Следуйте дальнейшим инструкциям �� (данный комментарий написан под влиянием вопроса, который был получен с помощью Telegram от одного из читателей блога)

С установкой разобрались, начинаем творить ��
Самое интересное, что бОльшую часть работы в Django делается с помощью командной строки. А значит — открываем ее: cmd

Теперь переходим в папку, в которой будем разворачивать сайт. В моем случае это будет папка на диске С под названием DjangoProject. Переходим в нее:
Запуск Django в Windows

Теперь нам нужно произвести начальную установку Django в эту папку. Для этого используем команду: django-admin startproject name_project, где name_project — имя вашего проекта (сайта). В моем случае это будет TestSite, а значит команда для начальной установки будет выглядеть следующим образом:
django-admin startproject TestSite
django-admin startproject name_project

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

внутри которой будет папка с именем проекта (внутри будут еще несколько файлов, о которых мы поговорим чуть позднее), и файл manage.py:
Django новый проект-2

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

Как видно — итогом выполнения команды является файл с названием db.sqlite3, который является базой данных нашего сайта.

Основные подготовительные работы — закончены. Что бы убедиться в том, что установка прошла успешно запускаем встроенный в Django веб-сервер. Для этого используем команду python manage.py runserver:
python manage.py runserver

после чего открываем в браузере адрес: 127.0.0.1:8000. Если вы видите нечто подобное:
python manage.py runserver

— поздравляю, вы только что успешно установили Django, создали проект (каркас сайта), создали базу сайта �� Кстати, вы наверняка заметили, что все запросы к сайту отображаются в командной строке, в которой вы ранее запустили веб-сервер �� Но это так — лирическое отступление. Выключаем веб-сервер с помощью Ctrl+C, и…

Переходим к созданию страниц в нашем сайте. Как и договаривались — мы создадим две страницы:
— главная
— контакты

Для начала уточню, что с точки зрения логики Django — каждая страница сайта является отдельной аппликацией. Создаются они очень просто — с помощью команды python manage.py startapp name_page, где name_page — название вашей страницы:
python manage.py startapp page (Главная страница)
python manage.py startapp page2 (страница Контакты)
python manage.py startapp

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

Многостраничные формы в Django

Введение

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

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

Итак, давайте сделаем это. В посте ниже мы рассмотрим пошаговую процедуру создания многостраничной формы заявки на работу. Мы начнем с самой простой функциональности, а затем сделаем ее (немного) более сложной. Наиболее важные модули («models.py», «forms.py» и «views.py») будут воспроизведены здесь, но рабочий, автономный проект доступен на GitHub.

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

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

Требования

  • Python 3
  • Django 2.2
  • Некоторые базовые знания о том, как разрабатываются сайты на Django

Модель


Мы будем работать с формой модели, поэтому первое, что нам нужно, это модель, которая будет представлять поданную заявку на работу. Следует помнить одну вещь: распределение формы на несколько страниц означает, что экземпляры модели должны быть сохранены в базе данных, прежде чем все будет завершено. В конце концов, поля на странице 2 еще не будут иметь значений при отправке страницы 1. Поэтому некоторые поля в вашей модели должны быть определены с null = True и/или blank = True , даже если вы обычно этого не хотите. Не беспокойтесь — мы все равно сможем потребовать, чтобы пользователь отправил непустое значение, но мы будем делать это на уровне формы, а не на уровне модели (базы данных).

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

models.py

(Обратите внимание, что этот модуль относится к модулю под названием «constants», который определяет значения для «stage» и используется как здесь, так и в «views.py». Этот модуль не воспроизводится в этом сообщении в блоге, но если вы загрузите полный проект от Github, вы найдете его там.)

Одним из полей, необходимых для этой многостраничной формы, является stage , которая позволяет нам определить, какое подмножество полей отображать на странице 1 формы, какое на странице 2 и так далее. Затем поля данных ( first_name , last_name , prior_experience и all_is_accurate ) будут обрабатывать значения, представленные пользователем.

Но давайте поговорим о поле session_hash . Ключом к созданию многостраничной формы является то, что при отправке данных со страницы 2 (например) вы сохраняете их в той же модели, которую использовали для страницы 1. Поскольку html по своей природе не имеет состояния, мы храним хэш-код в сеанс, чтобы связать отдельные запросы GET и POST вместе. Каждый экземпляр модели получает свой собственный уникальный хэш SHA-1, который будет сохранен в модели при первом действительном запросе POST. Более поздние запросы от браузера пользователя будут включать этот хеш, что позволит нам получить правильный экземпляр модели.

Методы create_session_hash() и __init __() в модели поддерживают это. Обратите внимание на использование цикла while для защиты от исчезающей крошечной вероятности того, что мы случайным образом сгенерируем хеш, который уже существует в модели. Поскольку существует 2^160 различных 40-символьных шестнадцатеричных хеш-кодов, мы не будем долго зацикливаться на этом цикле (и почти наверняка не на всех).

Наконец, нам нужно что-то, чтобы разделить поля модели на группы, которые будут отображаться на странице 1, странице 2 и странице 3 формы. Метод get_fields_by_stage() делает это для нас. Этот метод не требует экземпляра JobApplication для работы, поэтому я сделал его статическим методом.

Форма

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

Но многостраничная форма — это динамическая форма. Поля должны быть определены во время выполнения, в зависимости от состояния, в котором находится конкретный экземпляр. Вот самый минимальный «forms.py» для нашего проекта:

forms.py

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

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

Вот последний большой кусок этого проекта: «views.py»:

views.py

(Обратите внимание, что этот модуль ссылается на шаблон «job_application.html» и второе представление, называемое «thank_you». Его использование метода reverse() также подразумевает существование «urls.py». Эти элементы не воспроизводятся в этом в блоге, но если вы загрузите полный проект с Github, вы найдете их там.)

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

  • Метод dispatch() пытается найти существующий экземпляр JobApplication , чье поле session_hash соответствует текущему сеансу пользователя.
  • Выполнение метода form_valid() означает, что все поля получили допустимые значения, и мы можем перейти к следующему этапу, который может быть другой частью формы или страницей «Спасибо».
  • Метод get_form_class() вернет класс формы с полями, соответствующими стадии текущего приложения.
  • Метод get_form_kwargs() является критическим, потому что, если мы не указываем «экземпляр», поведение Django по умолчанию заключается в создании нового объекта Form для каждого запроса.

Обязательные поля и проверка

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

Итак, давайте рассмотрим эти проблемы сейчас:

Проверка ввода

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

forms.py

Обязательные поля и скрытые поля

Нам нужно, чтобы поле stage было скрытым полем, но, поскольку stage — это CharField в модели JobApplication , Django по умолчанию использует TextInput для соответствующего поля в форме. Предположим также, что мы хотим сделать обязательными поля first_name , last_name и all_is_accurate . Нам нужен способ сообщить нашей динамической форме, что определенные поля должны быть обязательными и что другие поля должны отображаться как скрытые входные данные.

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

models.py

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

И снова мы изменим класс BaseApplicationForm в «forms.py». Добавьте метод __init __() , чтобы он выглядел так:

forms.py

Теперь поле stage должно быть скрыто, а поля first_name , last_name и all_is_accurate обязательны для заполнения на уровне формы. Теперь у нас есть рабочая многостраничная форма.

Заключение

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

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

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

models.py

(Рабочий пример в GitHub также реализует эту функцию).

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

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

Плюсы и минусы Django

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

Почему Django?

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

Django в центре внимания

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

Цукерберг рекомендует:  Психология цвета и Web дизайн

Python и его популярность

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

  • Простота в изучении
  • Чистота и читаемость
  • Разносторонность
  • Быстрота написания
  • Цельный дизайн

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

Плюсы Django

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

  • Быстрота: Django был разработан, чтобы помочь разработчикам создать приложение настолько быстро, на сколько это возможно. Это включает в себя формирование идеи, разработку и выпуск проекта, где Django экономит время и ресурсы на каждом из этих этапов. Таким образом, его можно назвать идеальным решением для разработчиков, для которых вопрос дедлайна стоит в приоритете.
  • Полная комплектация: Django работает с десятками дополнительных функций, которые заметно помогают с аутентификацией пользователя, картами сайта, администрированием содержимого, RSS и многим другим. Данные аспекты помогают осуществить каждый этап веб разработки.
  • Безопасность: Работая в Django, вы получаете защиту от ошибок, связанных с безопасностью и ставящих под угрозу проект. Я имею ввиду такие распространенные ошибки, как инъекции SQL, кросс-сайт подлоги, clickjacking и кросс-сайтовый скриптинг. Для эффективного использования логинов и паролей, система пользовательской аутентификации является ключом.
  • Масштабируемость: фреймворк Django наилучшим образом подходит для работы с самыми высокими трафиками. Следовательно, логично, что великое множество загруженных сайтов используют Django для удовлетворения требований, связанных с трафиком.
  • Разносторонность: менеджмент контента, научные вычислительные платформы, даже крупные организации – со всем этим можно эффективно справляться при помощи Django.

PHP против Python

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

  1. Лучший дизайн: PHP был разработан специально для веб разработки, но Django базируется на более надежном языке. Хороший код проще написать в Python, в сравнении с PHP.
  2. Python и долгосрочность: PHP очень хорош в краткосрочной перспективе. Однако, когда вы проходите начальную фазу, вам может понадобиться язык с более глубокими возможностями. Здесь Python выступает в роли явного фаворита.
  3. Лучший Веб Фреймворк: Рынок наполнен великим множеством замечательных фреймворков. Однако это не касается долгосрочной ценности. И Django в данном случае является явным победителем. Хотя и PHP может похвастаться со своими Laravel, Yii, Symfony.
  4. Фактор читаемости: PHP следует классическому подходу, но у Python более строгие правила идентификации. Отсюда выбирайте, что лучше.
  5. Простой синтаксис: написание кода в Python происходит намного проще и быстрее.
  6. Инструменты для лечения багов: пакеты Python содержат все необходимые инструменты для исправления неполадок.
  7. Управление пакетам: в Python это реализовано весьма эффективно: вы можете писать, читать и делиться пакетами таким образом, что другие разработчики могут использовать их в других приложениях.
  8. Говорим Python, подразумеваем «Общее Назначение»: В то время как PHP используется для веб разработки, Python может быть использован для различных целей, также стоит отметить, что вы можете работать как онлайн, так и оффлайн.


Минусы

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

  • Использование шаблона маршрутизации с указанием URL
  • Django слишком монолитный
  • Все базируется на ORM Django
  • Компоненты развертываются совместно
  • Необходимо умение владеть всей системой для работы

Подведем итоги

Существует очень много плюсов и минусов Django, не упомянутых в данной статье, однако, когда рассматривается проект с дедлайном, использование Django для решения поставленной задачи – грамотное решение. Более того, для ускорения рабочего процесса, есть возможность установить пользовательскую кастомную конфигурацию. Ранее, когда разработка кода требовала большого количества времени, такая возможность позволила заметно упростить этот процесс. Стоимость разработки снизилась практически на 80%, а необходимость в аутсорсинге вообще отпала. Но погодите, делает ли это Django лучшим? Что-ж, в некоторых странах определенно попытаются передать Django на аутсорс. Кому? Скорее всего, низкоквалифицированным и дешевым разработчикам.

О моем опыте использования Django Framework¶

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

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

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

Больше всего хлопот доставляет Django ORM, поэтому мы начнем с него.

Проблемы Django Models и способы их решения¶

Семантическое сопряжение валидации моделей¶

Принцип “Защитного программирования” [2] требует делать невозможным создание невалидного объекта. Для валидации должны использоваться сеттеры объекта. В Django Model мы должны явно вызвать метод Model.full_clean() перед сохранением объекта, что, конечно же, часто никто не делает, и это часто приводит к различным проблемам. Эта проблема известна как “семантическое сопряжение” а также “G22: Make Logical Dependencies Physical” [1] and “G31: Hidden Temporal Couplings” [1]. Можно решить эту проблему технически, но обычно достаточно просто соблюдать дисциплину разработки.

Active Record¶

Django Model реализует паттерн ActiveRecord, который создает простоту использования за счет нарушения принципа Single responsibility principle (SRP), из-за чего его часто называют антипаттерном. Этот паттерн смешивает в одном классе бизнес-логику и служебную логику доступа к данным. К сожалению, эта простота уместна только в простых случаях. В более-менее серьезном приложении от этого больше проблем, чем достоинств.

Поскольку Django не использует слоя Repository, было бы желательно сокрыть реализацию доступа к источнику данных посредством Сервисного Слоя, см. статью “ Проектирование Сервисного Слоя и Логики Приложения ”. Это необходимо потому, что возможностей Django ORM не всегда достаточно для построения сложных запросов или для создания сложных моделей. Тогда приходится подменять Django ORM сторонними инструментами или реализацией в голом виде паттерна DataMapper, к этому вопросу мы еще вернемся. В любом случае, реализация доступа к данным должна быть сокрыта от приложения, и это одна из обязанностей Сервисного Слоя.

В статье “Clean Architecture in Django” вы можете найти пример использования паттерна Repository для сокрытия источника данных в Django-приложении.

Identity Map¶

Django ORM не реализует паттерна Identity Map, и, как результат этого, возникает много дублируемых запросов. Частично этот недостаток смягчается наличием prefetch_related(). Существуют реализации этого паттерна в виде сторонних библиотек, django-idmapper, django-idmap. Но они никаких функций кроме кэширования не выполняют, и за транзакционной согласованностью данных не следят. Правда, вы вряд-ли заметите эту проблему, так как Django приложение обычно обрабатывает HTTP-запрос одной транзакцией.

Транзакционная согласованность данных¶

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

Django ORM поддерживает транзакции, но не поддерживает транзакционной согласованности данных (ACID, Two-phase transaction), в отличии от Storm ORM / SQLAlchemy. Вы должны самостоятельно заботиться о состоянии экземпляров моделей в памяти в момент фиксации (отката) транзакции.

Так например, если Вы используете уровень изоляции транзакции “Repeatable read”, то после фиксации транзакции состояние Ваших экземпляров моделей в памяти может утратить актуальность. Соответственно, при откате транзакции вы должны вернуть им начальное состояние.

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

Вы должны также самостоятельно заботиться о предотвращении взаимных блокировок (Deadlock), так как Django ORM не реализует паттерна Unit of Work и не использует топологической сортировки.

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

Кроме того, следует внимательно ознакомиться со всеми предостережениями метода iterator(), использование которого не гарантирует отсутствия утечки памяти, если Вы не используете SSCursor для MySQL.

Сервисный слой и django.db.models.Manager¶

Широко распространенная ошибка — использование класса django.db.models.Manager в качестве сервисного слоя. Этот вопрос детально был рассмотрен в статье “ Проектирование Сервисного Слоя и Логики Приложения ”.

Композитные внешние ключи и Django Models¶

Как видно из тикета #373 и обсуждения “Multi-Column Primary Key support”, Django Model пока не поддерживает композитные связи.

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

Скажу честно, я этими библиотеками не пользовался. Я в таком случае просто не использовал Django ORM. Но у Вас есть выбор.

Выполнение сложных SQL-запросов c Django ORM¶

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

В моей практике был случай когда нужно было в Django admin panel реализовать выборку пользователей с поиском по шаблону (LIKE ‘%keyword%’) как по строкам в таблице пользователей так и в присоединенной (LEFT JOIN) таблице профилей, причем критерии поиска должны были сочетаться условием ИЛИ (OR), что приводило к полному проходу по присоединенной таблице на каждую строку таблицы пользователей. Записей в БД MySQL было несколько миллионов, и это работало очень медленно. В той версии MySQL еще не поддерживался ngram FULLTEXT index. Для оптимизации запроса нужно было присоединять уже профильтрованную выборку из таблицы профилей, а не всю таблицу профилей, переместив критерий выборки в подзапрос. Подобный пример Вы можете найти в книге «High Performance MySQL» [4]. Для решения проблемы моему коллеге пришлось сделать адаптер для sqlbuilder Storm ORM наподобие sqlalchemy-django-query. В результате была достигнута возможность выразить SQL-запрос любого уровня сложности в интерфейсе django.db.models.query.QuerySet.

Реализация сложных моделей в Django Framework¶

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

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

Механизм аннотаций в Storm ORM / SQLAlchemy реализован более удачно, чем в Django ORM, который лучше не использовать вообще в пользу голого паттерна Data Mapper. Дело в том, что схема модели постоянно эволюционирует, и в нее постоянно добавляются новые поля. И нередко случается так, что имя нового поля уже используется аннотацией, из-за чего возникает конфликт в пространстве имен. Решением проблемы может быть разделение пространства имен, используя для аннотаций отдельную модель или обертку (Wrapper) над экземпляром модели.

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

Вот почему важно скрывать детали реализации доступа к данным посредством слоя Repository или Service Layer. В таком случае я просто выполняю реализацию в виде голого паттерна DataMapper и чистой Domain Model.

Как показывает практика, обычно такие случаи не превышают 10% (редко они достигают 30%), что не настолько существенно для отказа от Django ORM, ибо привлекательность легкого поиска специалистов все равно перевешивает.

Сторонние инструменты¶

SQLAlchemy¶

Django Framework имеет несколько приложений для интеграции SQLAlchemy:

SQLBuilder¶

Для создания сложных запросов с Django Model я обычно использую sqlbuilder.

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

Storm ORM¶

Вопрос интеграции Storm ORM уже рассматривался, поэтому я просто приведу ссылки:

Тестирование¶

Если используется несколько технологий доступа к данным, то стоит упомянуть генератор файковых данных mixer, который поддерживает несколько ORM. Другие генераторы можно найти, как обычно, на djangopackages.org.

Очистка кэша¶

Реализация Django Model в виде ActiveRecord вынуждает нас напрямую вызывать метод Model.save(). Проблема в том, что сигналы post_save и pre_delete часто используются разработчиками для инвалидации кэша. Это не совсем правильно, так как Django ORM не использует паттерна Unit of Work, и время между сохранением и фиксацией транзакции оказывается достаточным чтобы параллельный поток успел воссоздать кэш с устаревшими данными.

В интернете можно найти библиотеки которые позволяют послать сигнал во время фиксации транзакции (используйте поиск на pypi.python.org по словам “django commit signal”). Django 1.9 и выше позволяет использовать transaction.on_commit(), что частично решает проблему если не используется репликация.

Версионирование данных¶

Для Django существует множество библиотек для версионирования объектов, смотрите “Model Auditing and History” и “Versioning”. Однако, такого зрелого и совершенного решения как sqlalchemy-continuum мне отыскать среди Django-библиотек так и не удалось.


В результате пришлось писать библиотеку для версионинга (реализующую Slowly Changing Dimensions (SCD) — Type 4) самостоятельно (её нет в открытом доступе, так как все права принадлежат компании), которая позволила бы воссоздавать состояние агрегата (т.е. структуру взаимосвязанных объектов) для заданной версии, даже если какой-то из объектов агрегата был удален. Поскольку границы агрегата одновременно являются и границами транзакции, вопрос реализации версионированных связей был легко решен с помощью уже упомянутой библиотеки django-composite-foreignkey, которая позволяет организовать композитные (включая номер версии объекта) связи между экземплярами моделей.

Информационно мне помогли библиотеки и статьи:

Как вариант, для версионирования агрегата можно использовать JSON-patch на уровне сериализатора Django REST Framework. Однако, сериализаторы могут иметь разные версии, и тогда для версионирования потребуется создать отдельный сериализатор. В таком случае, правда, возникает вопрос относительно создания diff для списка с измененным порядком следования объектов, чтобы в diff не попадало содержимое перемещенных объектов целиком.

Смотрите так же:

Django REST framework¶

Если мы до этого рассматривали недостатки Django ORM, то Django REST framework удивительным образом превращает его недостатки в достоинства, ведь интерфейс создания запросов Django ORM великолепно подходит для REST.

Если Вам посчастливилось использовать на стороне клиента Dstore, то на стороне сервера Вы можете использовать django-rql-filter или pyrql.

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

Главным Техническим Императивом Разработки ПО является управление сложностью. Управлять сложностью будет гораздо легче, если при проектировании вы будете стремиться к простоте. Есть два общих способа достижения простоты: минимизация объема существенной сложности, с которой приходится иметь дело в любой конкретный момент времени, и подавление необязательного роста несущественной сложности.

Software’s Primary Technical Imperative is managing complexity. This is greatly aided by a design focus on simplicity. Simplicity is achieved in two general ways: minimizing the amount of essential complexity that anyone’s brain has to deal with at any one time, and keeping accidental complexity from proliferating needlessly. («Code Complete» [2])

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

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

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

Суффиксирование внешних ключей Django REST framework¶

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

SQLAlchemy¶

Огромным преимуществом Django REST framework является то, что он ORM agnostic. Он имеет прекрасную интергацию с Django Models, но он легко может работать с голой реализацией паттерна Data Mapper который будет возвращать namedtuple для Data Transfer Object. Также он имеет хорошую интеграцию с SQLAlchemy в виде стороннего приложения djangorest-alchemy (документация). См. обсуждение интеграции.

MongoDB и MongoEngine¶

Так же Django REST framework имеет интеграционное приложение для поддержки MongoDB и Mongoengine django-rest-framework-mongoengine. Пример использования можно посмотреть в django-rest-framework-mongoengine-example с описанием в статье “Django + MongoDB = Django REST Framework Mongoengine”.

Стороннее приложение django-rest-framework-gis для поддержки GeoJSON.

OpenAPI и Swagger¶

Django REST framework позволяет генерировать схему в формате OpenAPI и интегрируется с swagger с помощью библиотеки django-rest-swagger.

Цукерберг рекомендует:  Вакансии BlackVR - Студия по разработке VR&AR

Это открывает неограниченные возможности по генерированию стабов для клиента и позволяет использовать один из существующих генераторов стабов для swagger. Что, в свою очередь, позволяет тестировать client-side без использования server-side, разграничить ответственность между разработчиками client-side и server-side, быстро диагностировать причину проблем, фиксировать протокол обмена, а главное, позволяет вести параллельную разработку client-side даже если server-side еще не готов.

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

Мой товарищ работает над библиотекой python-easytest, которая избавляет от необходимости написания интеграционных тестов и тестирует приложение на основании схемы OpenAPI.

Проблема JOIN-ов¶

Django REST framework часто используется вместе с django-filter. И тут возникает проблема, которая отражена в документации как:

“To handle both of these situations, Django has a consistent way of processing filter() calls. Everything inside a single filter() call is applied simultaneously to filter out items matching all those requirements. Successive filter() calls further restrict the set of objects, but for multi-valued relations, they apply to any object linked to the primary model, not necessarily those objects that were selected by an earlier filter() call.”

Решается эта проблема легко, в классе FilterSet() следует использовать обертку с ленивым вычислением вместо реального django.db.models.query.QuerySet, которая будет полность повторять его интерфейс, но вызвать оригинальный метод filter() однократно, передавая ему все накопленные критерии выборки.

Генерация *.csv, *.xlsx¶

Django и Django REST framework имеет огромное количество расширений. Это то главное преимущество, ради которого есть смысл терпеть их недостатки. Можно даже генерировать *.csv, *.xlsx файлы:

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

Graphql¶

  • graphene-django — a Django integration for graphene.

Плюсы и минусы Django Framework¶

Плюсы¶

Django framework написан на прекрасном языке программирования Python.

Джанго имеет удачный View, который представляет собой разновидность паттерна Page Controller, достаточно удачные формы и шаблонизатор (если использовать django.template.loaders.cached.Loader).

Несмотря на все недостатки Django Models, его интерфейс построения запросов хорошо подходит для REST API.

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

Существуют ORM для работы с MongoDB, которые в значительной степени воспроизводят интерфейс Django ORM, например MongoEngine. Так же существуют бэкенды для нативного Django ORM c поддержкой MongoDB, например, djongo (source code). Другие решения смотрите в документации MongoDB.

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

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

Django имеет огромное сообщество с огромным количеством готовых приложений. Находить специалистов (и аутсорсинговые компании) для Django и Django REST framework очень легко.

Django декларирует такой способ разработки, который не требователен к уровню квалификации разработчиков.

Django способен сэкономить много времени и финансовых ресурсов при правильном использовании.

Минусы¶

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

Если Вам нужно адаптировать Django ORM для своих потребностей, то сделать это с последним релизом будет, пожалуй, сложнее, чем адаптировать SQLAlchemy. При том что в адаптации он нуждается чаще чем SQLAlchemy. Простота больше не является главной прерогативой Django, как это было в ранних версиях. Практически во всех проектах, с которыми мне приходилось иметь дело, Django ORM дополнялся (или заменялся) сторонними инструментами либо голой реализацией паттерна Data Mapper.

В кругу моих друзей Django framework используется в основном в силу привычки и по инерции.

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

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

Заключение¶

Использовать или не использовать Django framework зависит от того, какие цели Вы перед собой ставите, и командой какой квалификации Вы располагаете.

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

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

Никто не обязывает Вас использовать Django всегда и везде. Django REST framework позволяет Вам абстрагироваться от Django ORM и даже от своего сериализатора.

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


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

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

Как и почему мы используем Django

Первоначально howchoo был напсиан на PHP и Codeigniter, затем, в феврале 2015 года, мы полностью переключились на Django. Недавно на Reddit я отвечал на вопрос как раз об этой конкретной ситуации: «Мое приложение построено на PHP/Codeigniter, что будет если я перепишу его на Python/Django ?». Я дал краткий ответ, но решил немного подробнее объяснить, почему howchoo использует Django. Или, точнее, за что особенно мы любим Джанго.

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

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

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

Быстрая загрузка страниц

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

Масштабируемость

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

Чистый Код как благочестие

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

Ох, а теперь о мясе.

За что мы любим Джанго:

Модели и базы данных

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

[add fields to model] ./manage.py makemigrations ./manage.py migrate

И если вы беспокоитесь о том, что придется на самом деле самому это делать, вы можете запустить это после makemigrations, чтобы просто распечатать SQL, который будет запущен (не запускать его).

Кроме того, Django делает запрос к базе данных очень простым.

И обновление это проходит довольно весело.

user.first_name = «Tyler» user.save()

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

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

Шаблонирование

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

Маршрутизация

URL-маршрутизация в Django — отличное сочетание мощного и простого функционала. Самое главное, мне нравится, как в Джанго строятся urlpatterns. Файлы urls легко читаются и быстро реагируют на различные действия. Это огромное преимущество для такой неотъемлемой части приложения. Я видел некоторые фреймворки, где маршруты скрыты и немного загадочны. Это не хорошо.

Кэширование

Как говорилось ранее: howchoo изначально был встроен в PHP/Codeigniter. И да, Codeigniter обеспечивает встроенное кэширование страниц, но в конечном итоге это было причиной, по которой я начал пересаживаться на Django. Я знал, что кэширование страниц будет ОГРОМНОЙ частью нашей стратегии по сокращению времени загрузки страницы, и я хотел что-то мощное. С Django вы можете кэшировать части шаблона или всего представления с очень небольшими настройками. Это прекрасно.

Формы и ModelForm

Классы Django Form и ModelForm не красивые, но они достаточно просто и понятно работают. В самом простом случае, если вы используете ModelForm, вы получите работающую форму всего за несколько (менее 10) строк кода. Это включает в себя создание формы HTML, проверку и сохранение. Конечно, большинство форм не являются базовыми, но классы форм очень настраиваемы. Наши guide tool максимально расширяют классы форм, и мы прекрасно с ними работаем.

Простой django: что не так с этим кодом?

у меня есть этот код:

и когда я запускаю его, я получаю ошибку о том, как это бред. Ошибка не говорит о том, что, конечно, она говорит:

Поймано NoReverseMatch при рендеринге: обратное для ‘django.contrib.auth.views.account’ с аргументами ‘()’ и ключевыми словами-аргументами ‘<>‘ не найдено.

Это только для опции «account», опция «logout» работает сама по себе. Естественно, я искал SO на предмет ошибки, и это что-то из-за того, что «аккаунт» нигде не существует — но я супер новичок в django и понятия не имею, как исправить!

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

имя пользователя, возможность изменить пароль и т.д.) что мне нужно сделать?

Нужно ли что-то в моем urls.py? Что-то в моих формах?

ОБНОВЛЕНИЕ, хорошо, так как <% url 'django.contrib.auth.views.XYZ'%>указывает на член класса представлений, который называется XYZ, если бы я хотел добавить страницу «учетные записи», я бы подкласс классы просмотров и добавить туда функциональность? Или я был бы более разумным, просто добавив новое представление (‘/ accounts /’) и добавив в представление все это?

Эта функция / представление ( account ) не существует. Посмотрите на код:

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

Отвечая на то, что вы спросили в своем комментарии (это другой вопрос, кстати)

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

Я собирался показать вам, как это сделать, но лучше указать вам правильное место. Начните с учебника по Django:

Через час вы поймете весь процесс.

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

Python → Использование Django ORM отдельно от Django

Понадобилось использовать Django ORM вне контекста самой Django. Конечно, проще и правильнее было бы использовать SQLAlchemy т.к. она рассчитана на такое использование, но мне нужно было написать паука, сохраняющего данные в БД и веб-интерфейс к этим данным. Веб-интерфейс точно решил делать на Django, а в пауке использовать те-же самые модели, чтобы не проделывать одну и ту же работу дважды. Т.к. паук был первым этапом работ а админка — вторым, появилась необходимость создавать таблицы из моделей без использования «syncdb».

В качестве основы использовалкод модуля django-standalone истатью Django ORM без Джанги -эта статья практически полностью решает проблему, но есть и несколько недостатков:

  • Модели для создания таблиц нужно перечислять вручную
  • Не создаются внешние ключи
  • По — мелочи — нужно каждой модели вручную задавать app_label

Попытаемся исправить эти недостатки.

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

sudo pip install Django

Собственно, приведу сразу код с комментариями

Большая часть содержимого create_table() скопировано из файла django/core/management/commands/syncdb.py. По сравнению с оригинальной статьей отпала необходимость вручную указывать для каждой модели app_label и вручную передавать список моделей для создания. Но появилась необходимость прописывать __metaclass__ . Успокаивает то, что он один и тот же для всех классов. Ну и необходимо всем прописывать class Meta: pass . Можно это поправить, если создать базовый класс абстрактной модели с этими атрибутами и наследовать все модели от него.

Ну и общее впечатление — Django ORM не самое удачное решение для использования отдельно от Django. Если есть возможность, стоит использовать более подходящие библиотеки, например SQLAlchemy. Она хоть и более сложна для освоения, но и более мощная, поддерживает пуллинг соединений, более управляемая и рассчитана на такое использование.

Что такое Django?

Django (/ˈdʒæŋɡoʊ/ джанго) — бесплатный и свободный фреймворк для веб-приложений, написанный на Python. Фреймворк — это набор компонентов, которые помогают разрабатывать веб-сайты быстро и просто.

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

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

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

Зачем нам нужен фреймворк?

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

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

Что происходит, когда кто-то запрашивает веб-сайт у твоего сервера?

Когда на сервер приходит запрос, он переадресуется Django, который пытается сообразить, что же конкретно от него просят. Для начала он берет адрес веб-страницы и пробует понять — что же нужно сделать. Эту часть процесса в Django выполняет urlresolver (адрес веб-сайта называется URL — Uniform Resource Locator — Единый указатель ресурсов, так что название urlresolver, resolver == распознаватель, имеет определенный смысл). Он не слишком умён, поэтому просто берет список шаблонов и пытается сопоставить их с URL. Django сверяет шаблоны сверху вниз и, если что-то совпадает, он переправляет запрос соответствующей функции (которая называется view).

Представь себе почтальона с письмом. Она идет вниз по улице и сверяет номера домов с адресом на письме. Если они совпадают, то она оставляет письмо. Так же работает и urlresolver!

Но самые интересные вещи происходят в функции view: мы, например, можем обращаться к базе данных за определенной информацией. Может быть пользователь попросил изменить какую-нибудь информацию? Как будто в письме написано: «Пожалуйста, поменяйте описание моей работы.» Функция view может проверить, имеете ли вы разрешение делать это, а затем обновит описание работы и отправит обратно ответ: «Готово!». Затем функция view сгенерирует ответ, и Django сможет отправить его веб-браузеру пользователя.

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

Так что вместо погружения в пучины нюансов мы просто начнем работать с Django и познакомимся со всеми важными особенностями по мере продвижения!

Понравилась статья? Поделиться с друзьями:
Все языки программирования для начинающих