Python django с нуля: Создаем свое первое веб-приложение при помощи Django

Эффективный Django. Часть 1 / Хабр

Представляю вам перевод статей о Django с сайта effectivedjango.com. Наткнулся я на этот сайт во время изучения данного фреймворка. Информация размещенная на этом ресурсе показалась мне полезной, но так как нигде не нашел перевода на русский, решил сделать сие доброе дело сам. Этот цикл статей, как мне думается, будет полезен веб-разработчикам, которые делают только первые шаги в изучении Django.

• Введение
• Эффективный Django. Руководство
• Тестирование в Django
• Понимание Middleware’ов
• Базы данных и модели
• Представления-классы (CBV)
• Формы

Django — это популярный, мощный фреймворк на языке Python. Он имеет множество «батареек«, и позволяет сразу начать разработку. Однако вся эта мощь означает, что вы можете написать низкопробный код, который будет казаться рабочим. Так что же подразумевается под Эффективным Django? Под Эффективным Django будем понимать использование Django таким образом, чтобы написанный код был связным, тестируемым и масштабируемым. Что же каждое из этих слов значит?

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

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

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

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

Эти документы являются сочетанием заметок и примеров подготовленных для PyCon 2012, PyOhio 2012, и PyCon 2013, а также для web-разработки Eventbrite. Я все еще работаю над объединением их в один документ, но надеюсь вы найдете их полезными.

Примеры кода для этого руководства доступны на github’е. Отзывы, предложения и вопросы можете присылать на [email protected].

Этот документ доступен на сайте, а также в форматах PDF и EPub.

Видео этого руководства с PyCon можно посмотреть на YouTube.

1.1. Ваша среда разработки

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

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

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

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

1.1.1. Изоляция

• Мы хотим избежать использования неизвестных зависимостей или неизвестных версий.
• virtualenv предоставляет простой путь для работы над проектом, без использования системных site-packages.

1.1.2. Предопределенность

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

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

1.1.3. Сходство

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

1.2. Настройка вашего окружения

1.2.1. Создание чистого рабочего пространства

Примечание переводчика:
Для начала создадим каталог (tutorial), в котором будем работать:

~$ mkdir tutorial
~$ cd tutorial
~/tutorial$ mkdir venv project

В каталоге venv будет находится наше виртуальное окружение, а в каталоге project — Django-проект

~/tutorial$ virtualenv --prompt="(venv:tutorial)" ./venv/

New python executable in ./venv/bin/python
Installing setuptools............done.
Installing pip...............done.

~/tutorial$ source ./venv/bin/activate
(venv:tutorial)~/tutorial$

1.2.2. Создание файла зависимостей

Создайте файл requirements.txt в директории tutorial с единственной строкой (зависимостью) в нем:

Django==1.6.7

Примечание переводчика:
В случае, если вы хотите использовать последнюю версию Django (1.7 — на момент написания перевода) — вместо строки Django==1.6.7 оставьте просто Django — pip установит последнюю доступную версию.

1.2.3. Установка зависимостей

А теперь мы можем использовать pip для установки зависимостей:

(venv:tutorial)~/tutorial$ pip install -U -r requirements.txt

Downloadping/unpacking Django==1.6.7 (from -r requirements.txt (line 1))
  Downloading Django-1.6.7.tar.gz (6.6MB): 6.6MB downloaded
  Running setup.py egg_info for package Django

    warning: no previously-included files matching ’__pycache__’ found under directory ’*’
    warning: no previously-included files matching ’*.py[co]’ found under directory ’*’
Installing collected packages: Django
  Running setup.py install for Django
    changing mode of build/scripts-2.7/django-admin.py from 644 to 755

    warning: no previously-included files matching ’__pycache__’ found under directory ’*’
    warning: no previously-included files matching ’*.py[co]’ found under directory ’*’
    changing mode of /home/nathan/p/edt/bin/django-admin.py to 755
Successfully installed Django
Cleaning up...

1.3. Начало проекта Django

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

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

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

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

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

Примечание переводчика:
Перейдем директорию ~/tutorial/project/ и в дальнейшем будем работать только из этой директории (под $ далее будем подразумевать ~/tutorial/project/$):

(venv:tutorial)~/tutorial/$ cd project

(venv:tutorial)$ django-admin.py startproject addressbook .

Созданный проект имеет следующую структуру

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

1.3.2. Скаффолдинг проекта

• manage.py — является ссылкой на скрипт django-admin, но с уже предустановленными переменными окружения, указывающими на ваш проект, как для чтения настроек оттуда, так и для управления им при необходимости;
• settings.py — здесь находятся настройки вашего проекта. Файл уже содержит несколько разумных настроек, но база данных не указана;
• urls.py — содержит URL’ы для маппирования (отображения) представлений: мы вскоре (в дальнейших главах) поговорим об этом подробнее;
• wsgi.py — это WSGI обёртка для вашего приложения. Этот файл используется сервером разработки Django и возможно другими контейнерами, такими как mod_wsgi, uwsgi и др. на «боевом» сервере.

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

(venv:tutorial)$ python ./manage.py startapp contacts

Созданное приложение имеет следующую структуру:

./contacts
    __init__.py
    models.py
    tests.py
    views.py

• Начиная с Django 1.4, приложения размещаются внутри пакета с проектом. Это замечательное улучшение, особенно когда приходит время разворачивать проект на «боевом» сервере;
• models.py будет содержать Django ORM-модели для вашего приложения;
• views.py будет содержать код представлений;
• tests.py будет содержать написанные вами модульные и интеграционные тесты.
• Django 1.7: admin.py будет содержать модель для административного интерфейса.
• Django 1.7: migrations/ содержит файлы миграций

Примечание переводчика:
На текущий момент наша директория ~/tutorial/ содержит файл зависимостей (requirements.txt), директорию с виртуальным окружением (venv/), один проект (project/addressbook), одно приложение (project/contacts) и имеет следующее содержание:

~/tutorial/
	requirements.txt
	venv/
		...
	project/
		manage.py
		addressbook/
			__init__.py
			settings.py
			urls.py
			wsgi.py
		contacts/
			__init__.py
			models.py
			tests.py
			views.py

2.1. Конфигурирование базы данных

Django поддерживает «из коробки» MySQL, PostgreSQL, SQLite3 и Oracle. SQLite3 входит в состав Python начиная с версии 2.5, так что мы будем использовать его в нашем проекте (для простоты). Если вы хотите, к примеру, использовать MySQL, то нужно добавить mysql-python в ваш requirements.txt.

Для того чтобы в качестве базы данных использовать SQLite, отредактируйте определение DATABASES в файле addressbook/settings.py. Файл settings.py содержит настройки Django для нашего проекта. В нем есть несколько настроек, которые вы обязаны указать — например DATABASES — а так же другие, необязательные, настройки. Django устанавливает некоторые настройки сам, когда генерирует проект. Документация содержит полный список настроек. К тому же вы можете добавить свои собственные настройки, если это необходимо.

Для использования SQLite нам нужно указать движок (ENGINE) и имя базы (NAME). SQLite интерпертирует имя базы как имя файла для базы данных:

DATABASES = {
    'defaults': {
	    'ENGINE': 'django.db.backends.sqlite3,' # ’postgresql_psycopg2’, ’mysql’, ’sqlite3’ or ’oracle'.
		'NAME': os.path.join(BASE_DIR, 'address.db'),
		'USER': '',     # Not used with sqlite3.
		'PASSWORD': '', # Not used with sqlite3.
		'HOST': '',     # Set to empty string for localhost. Not used with sqlite3.
		'PORT': '',     # Set to empty string for default. Not used with sqlite3.
	}
}

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

Вам редко придется непосредственно импортировать файл настроек: Django импортирует его за вас, и делает настройки доступными как django.conf.settings. Вы, как правило, импортируете настройки из django.conf:

from django.conf import settings

2.2. Создание модели

Модели Django отображают (грубо говоря) таблицы базы данных, и предоставляют место для инкапсулирования бизнес-логики. Все модели являются наследниками базового класса Model и содержат поля определений. Давайте создадим простую модель Contacts для нашего приложения в файле contacts/models.py:

from django.db import models

class Contact(models.Model):

    first_name = models.CharField(
        max_length=255,
    )
    last_name = models.CharField(
        max_length=255,
    )
	
    email = models.EmailField()

	def __str__(self):

	    return ' '.join([
            self.first_name,
            self.last_name,
        ])

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

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

Примечание переводчика:

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

Примечание переводчика:

С версии Django 1.7 во фреймворк добавлена нативная поддержка миграций и команда syncdb объявлена устаревшей. Так что будьте так любезны, воспользуйтесь командой migrate вместо syncdb.

(venv:tutorial)$ python ./manage.py syncdb

Creating tables ...
Creating table django_admin_log
Creating table auth_permission
Creating table auth_group_permissions
Creating table auth_group
Creating table auth_user_groups
Creating table auth_user_user_permissions
Creating table auth_user
Creating table django_content_type
Creating table django_session

You just installed Django's auth system, which means you don't have any superusers defined.
Would you like to create one now? (yes/no): yes
Username (leave blank to use 'bjakushka'):
Email address: 
Password:
Password (again):
Superuser created successfully.
Installing custom SQL ...
installing indexes ...
Installed 0 object(s) from 0 fixture(s)

(venv:tutorial)$

Примечание переводчика:

Если вы используете Django версии 1.7 и выше — вывод будет следующий:

(venv:tutorial)$ python ./manage.py migrate

Opperation to perform:
    Apply all migrations: admin, contenttypes, auth, sessions
Running migrations:
    Applying contenttypes.0001_initial... OK
    Applying auth.0001_initial... OK
    Applying admin.0001_initial... OK
    Applying sessions.0001_initial... OK

(venv:tutorial)$ 

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

Настройка INSTALLED_APPS содержит список приложений, используемых в проекте. Этот список содержит в себе строки, которые отображают пакеты Python. Django будет импортировать каждый из указанных пакетов, а потом смотреть модуль models. Давайте добавим наше приложение contacts в настройки проекта (addressbook/settings.py):

INSTALLED_APPS = (
  'django.contrib.admin',
  'django.contrib.auth',
  'django.contrib.contenttypes',
  'django.contrib.sessions',
  'django.contrib.messages',
  'django.contrib.staticfiles',
  
  'contacts',
)

После этого запустите syncdb снова:

Примечание переводчика:

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

(venv:tutorial)$ python ./manage.py syncdb

Creating tables ...
Creating table contacts_contact
Installing custom SQL ...
Installing indexes ...
Installed 0 object(s) from 0 fixture(s)

(venv:tutorial)$

Примечание переводчика:

Вывод для Django 1.7 и выше:

(venv:tutorial)$ python ./manage.py makemigrations

Migrations for 'contacts':
    0001_initial.py:
        - Create model Contact

(venv:tutorial)$ python ./manage.py migrate

Opperation to perform:
    Apply all migrations: admin, contenttypes, sessions, auth, contacts
Running migrations:
    Applying contacts.0001_initial... OK

(venv:tutorial)$ 

Заметьте, что Django создает таблицу с именем contacts_contact: по умолчанию Dj ango дает таблицам имена используя комбинацию имени приложения и имени модели. Вы можете изменить это с помощью опций модели Meta.

2.3. Взаимодействие с моделью

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

(venv:tutorial)$ python ./manage.py shell
Python 2.7.3 (default, Mar 14 2014, 11:57:14)
[GCC 4.7.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
(InteractiveConsole)
>>> from contacts.models import Contact
>>> Contact.objects.all()
[]
>>> Contact.objects.create(first_name='Nathan', last_name='Yergler')
<Contact: Nathan Yergler>
>>> Contact.objects.all()
[<Contact: Nathan Yergler>]
>>> nathan = Contact.objects.get(first_name='Nathan')
>>> nathan
<Contact: Nathan Yergler>
>>> print nathan
Nathan Yergler
>>> nathan.id
1

Здесь использовалось несколько новых штук. Во-первых, команда manage.py shell запускает для нас интерактивную оболочку Python’а с правильно установленными путями для Django. Если вы попробуете запустить интерпретатор Python и просто импортировать ваше приложения, будет выброшено исключение, потому что Django не знает, какие настройки использовать, и не может отобразить экземпляры модели на базу данных.

Во-вторых, здесь использовалось свойство objects нашей модели. Это менеджер модели. Так, если один экземпляр модели является аналогией для строки в базе, то менеджер модели — аналогией для таблицы. По умолчанию менеджер модели предоставляет функциональность запросов и может быть настроен. Когда мы вызываем all(), filter() или сам менеджер, возвращается объект QuerySet. QuerySet является итерируемым объектом и загружает данные из базы по необходимости.

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

2.4. Написание тестов

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

from django.test import TestCase

from contacts.models import Contact

class ContactTests(TestCase):
    """Contact model tests."""
	
    def test_str(self):
	
        contact = Contact(first_name='John', last_name='Smith')
        self.assertEquals(
            str(contact),
            'John Smith',
        )

Вы можете запустить тесты для вашего приложения используя команду manage.py test:

(venv:tutorial)$ python ./manage.py test

Если вы запустите это, то увидите что выполнилось около 420 тестов. Это удивляет, так как мы написали только один. Произошло это потому, что по умолчанию Django запускает тесты для всех установленных приложений. Когда вы добавляли приложение contacts в наш проект, то могли увидеть, что там по умолчанию были добавлены несколько встроенных приложений Django. Дополнительные 419 тестов были взяты оттуда.

Примечание переводчика:
В нашем случае (при использовании версии Django 1.6.7) предыдущий абзац несколько устарел: запустится только один тест — тот который мы создали. Вывод команды будет такой как указано ниже.

Если же вы захотите запустить тесты для определенного приложения — укажите имя приложения в команде:

(venv:tutorial)$ python manage.py test contacts

Creating test database for alias ’default’...
.
----------------------------------------------------------------------
Ran 1 tests in 0.001s

OK
Destroying test database for alias ’default’...

(venv:tutorial)$

Еще одна интересная вещь на заметку, прежде чем двигаться дальше — первая и последняя строка вывода: Creating test database и Destroying test database. Некоторым тестам необходим доступ к базе данных, и поскольку мы не хотим мешать тестовые данные с «реальными» (по разным причинам, не последней из которых является предопределенность), Django услужливо создает тестовую базу для нас, прежде чем запускать тесты. По существу, создается новая база данных, и потом запускается syncdb для нее. Если тестовый класс является потомком класса TestCase (как у нас), Django так же сбросит данные в значения по умолчанию после запуска каждого теста, так что изменения в одном из тестов не затронут другие.

2.5. Резюме

• Модель определяет поля в таблице, и содержит бизнес-логику.
• Команда syncdb создает таблицы в вашей базе данных из моделей. В Django версии 1.7 и выше вместо команды syncdb необходимо использовать сначала команду makemigrations — для создания миграций, а после этого команду migrate — для внесение изменений в базу.
• Менеджер модели позволяет вам оперировать коллекциями экземпляров: запросы, создание и т. д..
• Пишите модульные тесты для методов, которые вы добавили в модель.
• Команда управления test запускает модульные тесты на выполнение.

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

(venv:tutorial)$ python ./manage.py runserver 0.0.0.0:8080

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

Я использую для разработки домашний сервер с внутренним IP 192.168.1.51. Так что для того что-бы увидеть результат работы сервера разработки в браузере я захожу по адресу http://192.168.1.51:8080/. Вы же должны подставить адрес своего сервера.

Как думаете, нужно ли продолжать перевод остальных глав? Оказался ли перевод для Вас полезен?

Буду рад конструктивной критике в комментариях.

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

Использованное в начале поста изображение создано как вариация изображения пользователя MaGIc2laNTern

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.

from django.http import HttpResponse
from django.shortcuts import render, get_object_or_404
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, 2)
page = request.GET.get(‘page’)
posts = paginator.get_page(page)

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

def single(request, id=None):
post = get_object_or_404(Post, id=id)

context = {
«post»: post,
}
return render(request, «partial/single.html», context)

И файл djangoProject\myBlog\templates\partial\single.html

{% extends ‘base.html’ %}
{% block head %}
<title>{{ post.title }}</title>
<meta name=»description» content=»{{ post.description }}»/>
<meta name=»keywords» content=»{{ post.keywords }}»/>
{% endblock %}

{% block body %}
{% if post.visible %}
<h2>{{ post.title }}</h2>
<img src=»{{ post.image.url }}» alt=»»>
<p>{{ post.content }}</p>
{% else %}
<p>Страница не найдена</p>
{% endif %}
{% endblock %}

Руководство по Django

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

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

1. Глава 1. Введение в Django

   1. Что такое Django

   2. Установка и настройка Django

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

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

2. Глава 2. Представления и маршрутизация

   1. Обработка запроса

   2. Определение маршрутов и функции path и re_path

   3. Параметры представлений

   4. Параметры строки запроса

   5. Переадресация и отправка статусных кодов

3. Глава 3. Шаблоны

   1. Создание и использование шаблонов

   2. Передача данных в шаблоны

   3. Статические файлы

   4. TemplateView

   5. Конфигурация шаблонов

   6. Расширение шаблонов

   7. Встроенные теги

4. Глава 4. Формы Django

   1. Определение форм

   2. Типы полей формы

   3. Настройка формы и ее полей

   4. Валидация данных

   5. Детальная настройка полей формы

   6. Стилизация полей форм

5. Глава 5. Модели

   1. Создание моделей и миграции базы данных

   2. Типы полей моделей

   3. CRUD. Операции с моделями

   4. Создание и получение объектов модели

   5. Редактирование и удаление объектов модели

   6. Отношение один ко многим (One to Many)

   7. Отношение многие ко многим (Many to Many)

   8. Отношение один к одному (One to one)

Django уроки — курс создания сайта на Django с нуля

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

Информация про Джанго

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

Зачем нужен Джанго?

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

Джанго создан на основе языка Питон. За счёт Django вы можете намного проще и быстрее создавать как легкие, так и сложные веб сайты.

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

Преимущества Джанго

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

В Джанго используется схема MVC. Это схема позволяет удобно разбить файлы на одну из трех категорий: HTML шаблоны, файлы модели для работы с базой данных и файлы контроллеры для связи моделей и HTML шаблонов между собой.

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

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

Сайты на Джанго

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

1. Google — крупнейшая поисковая система;
2. YouTube — крупнейший видеохостинг;
3. Instagram — популярное приложения для обмена фото и видео;
4. Pinterest — крупнейший социальный интернет-сервис;
5. The Washington Times — популярная всемирная газета.

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

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

Какие знания нужны?

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

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

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

План курса

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

Программа обучения

Также на нашем сайте есть более углубленная программа по изучению языка Питон и его библиотек. Ознакомится с программой обучения можно по этой ссылке.

Самый полный видеокурс по Django от установки до проекта

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

Вас интересует фреймворк Django? Тогда вы по адресу. Оставим библиотеки, модули и трюки позади. Разберем Django по косточкам 😉

Эта лекция является вступительной в видеокурс по Django, в ней будет рассматриваться установка необходимого софта для работы с Python и Django. Автор показывает: процесс установки Python, настройки всех переменных, установки Django через pip, а также установку IDE PyCharm и его тестовый запуск.

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

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

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

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

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

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

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

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

https://www.youtube.com/watch?&v=PF1hh5ePcKI

Допиливание и переделка кода происходит на протяжении всего видеокурса, а в этом ролике происходит создание и добавление страницы товара. Автор показывает, как по id из url можно работать с товаром.

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

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

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

Это последнее видео из серии про Ajax и jQuery, в котором вы узнаете, как происходит удаление товаров из корзины.

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

На прошлом уроке был создан фронтенд, а здесь создается бекенд страницы чекаута для интернет-магазина. Вы научитесь пересохранять данные из модели «Товары» в корзине в модель «Товары» в заказе.

Этот видеокурс по Django посвящен запуску проекта на сервере в интернете. В качестве ОС была выбрана Ubuntu. Весь процесс подробно описан от регистрации до запуска.

Заключительная лекция курса и последняя часть по работе с удаленным сервером с рабочим проектом. Автор рассказывает, как запустить Django на сервере при помощи связки nginx + gunicorn.

А с какими трудностями столкнулись вы, работая с Django framework?

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

Я начинаю серию статей, посвященных разработке сайтов на 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 11.

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

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

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

sudo apt-get install python3.7-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]: Europe/Moscow
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 DATABASE myproject;
CREATE USER myprojectuser WITH PASSWORD 'difficultpassword';
ALTER ROLE myprojectuser SET client_encoding TO 'utf8';
ALTER ROLE myprojectuser SET default_transaction_isolation TO 'read committed';
ALTER ROLE myprojectuser SET timezone TO 'UTC';
GRANT ALL PRIVILEGES ON DATABASE myproject TO myprojectuser;
\q

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

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

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

Есть способ хранения всех относящихся к проекту переменных окружения в специальном .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 для нашего проекта.

8 обучалок Django | GeekBrains

Познаем главный Python-фреймворк.

https://d2xzmw6cctk25h.cloudfront.net/post/1117/og_cover_image/4c23b8cd2388064be2907eb878606172

Django является одним из самых популярных фреймворков для языка Python. Он использовался при разработке таких ресурсов, как Instagram, YouTube, Google, Mozilla и многих других. Django поддерживает массу инструментов и шаблонов для быстрого и эффективного создания современного веба любой сложности.

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

Курс GeekBrains

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

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

Tango With Django

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

Writing your first Django app

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

Django Girls Tutorial

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

Django Weekly

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

Ultimate Django

Руководство, начинающееся с очень привлекательных слов о зарплате Django -специалистов в США. Не смущайтесь, в остальном, это достаточно качественная онлайн книга, содержащая не только step-by-step уроки по созданию своего первого приложения, но и дальнейшее развитие в виде создания функционала и деплоя.

TaskBuster Django Tutorial

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

Django на русском

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

Запуск проекта Django — Настоящий Python

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

В этом руководстве мы ответим на вопрос «Как мне настроить проект Django (1.5, 1.6, 1.7 или 1.8) с нуля?» Другими словами, вы узнаете, как установить Django и как настроить структуру проекта Django.

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

1. Прочтите разделы «Введение» и «Настройка».
2. Затем выберите свой яд — Django 1.5, 1.6, 1.7, 1.8 — для установки проекта Django.
3. После первоначальной настройки проекта перейдите к разделу «Создание приложения», чтобы настроить красивое и простое приложение.
4. Затем просмотрите сводный рабочий процесс, чтобы получить краткое руководство по проекту Django.

Обновление : мы указали домен realdjango.com на это сообщение, чтобы вы могли легко найти его снова.

Введение

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

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

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

Хотя эти видео относятся к Django 1.5, они помогут вам понять базовый рабочий процесс для Django 1.6, 1.7 и 1.8.

Требования к руководству

Вы должны иметь некоторый опыт работы с Python и знать основные команды Unix bash. Если вы никогда раньше не использовали командную строку, ознакомьтесь со следующими командами: pwd , cd , ls , rm и mkdir .

Для простоты во всех примерах используется приглашение в стиле Unix:

  $ python manage.py runserver
  

(Знак доллара не является частью команды.)

Эквивалент Windows:

  C: \> сервер запуска python manage.py
  

Настройка

Что вам понадобится для базовой среды разработки Django:

1. Python 2.7.x или 3.4.x
2. easy_install и Pip
3. Git
4. virtualenv
5. Джанго

База данных

6. (SQLite, MySQL, PostgreSQL, MongoDB

.

python — как создать дерево категорий в Django с нуля?

Переполнение стека

1. Около

2. Продукты

3. Для команд

1. Переполнение стека
   Общественные вопросы и ответы

2. Переполнение стека для команд
   Где разработчики и технологи делятся частными знаниями с коллегами

3. Вакансии
   Программирование и связанные с ним технические возможности карьерного роста

4. Талант
   Нанимайте технических специалистов и создавайте свой бренд работодателя

5. Реклама
   Обратитесь к разработчикам и технологам со всего мира

6. О компании

.