Разное

Django install pip: Установка Django в Windows с помощью pip

Содержание

Установка Django в Windows с помощью pip

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

Шаг 1. Установка Python

Перед установкой Django, вам необходимо установить на ваш компьютер Python. О том как это сделать по ОС Windows мы уже писали ранее статью: УСТАНОВКА PYTHON 3 НА WINDOWS. Проследуйте инструкциям указанным в данной статье и возвращайтесь сюда, для установки Django.

Шаг 2. Установка Pip

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

Для начала запустим командную строку Windows. Для этого нажмите Win+R и введите cmd.

В командной строке введем:

pip --version

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

Если вместо сообщения о версии (картинка сверху) вы увидели сообщение об ошибке, то вам необходимо установить pip.

Для этого:

  1. Скачайте get-pip.py. Если ваш браузер сразу открывает код, то на странице нажмите правую кнопку мыши и выберете «Сохранить как…»
  2. Запустите скачанный файл с правами Администратора или через командную строку. Для установки pip через командную строку, перейдите в ней в папку с скаченным get-pip.py и выполните команду:
    python get-pip.py
  3. Снова выполните проверку версии pip.

Шаг 3. Создание виртуального окружения

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

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

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

  1. Откройте командную строку и перейдите в директорию, где хотите создать проект.

    Здесь мы создали директорию djangoset1 и осуществили переход в неё.

  2. Создадим виртуальное окружение с именем venvset1 (имя можно выбрать любое):
    python -m venv venvset1

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

  3. Запустим виртуальное окружение virtualenv, выполнив команду в командной строке Windows:
    venvset1\Scripts\activate

    Если вы увидели строку, как на картинке выше, то всё у вас получилось.

Шаг 4. Установка Django в виртуальное окружение через pip

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

pip install django

Если установка прошла успешно, вы увидите следующее:

На этом всё, теперь можно начинать изучать Django и написать своё первое приложение.

Инструкция по развёртыванию полноценной среды для совместной удалённой разработки с Django в Windows. Для абсолютных новичков.

Статья не претендует на универсальность, но статья — есть работоспособная инструкция по развёртке среды «с нуля» до этапа «пишем первую строчку кода». В комментариях принимаются советы и рекоммендации по улучшению инструкции.

1. Установка и настройка Python.

Для установки Python, его, ясно дело, надо для начала

  • скачать с http://python.org/download/, далее следовать указаниям установщика.

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

  • Итак, перемнную PATH можно найти (для Win Vista) через Kомпьютер >> Свойства >>Дополнительные параметры системы >>  Переменные среды, в окошке «Системные перемнные» найти переменную PATH и, не заменить, а ДОБАВИТЬ(!) к этой переменной значение «C:\Python25;C:\Python25\Scripts;C:\Python25\lib\site-packages\django\bin»,

где «C:\Python25» — корневой каталог установленного Python.

2. Установка Django.

Здесь, опять же, сперва надо

  • скачать Django с http://www.djangoproject.com/download/ одним из представленных на странице способов. 
  • Если было принято решение качать официальную версию (первым способом), то, распаковав архив, надо в коммандной строке перейти в корневой каталог распакованного Django, затем выполнить команду «setup.py install» (в случае, если переменная окружения из первого шага не была установлена, тогда «python setup.py install»).

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

3. Установка Eclipse.

Здесь вообще всё просто, скачать Eclipse можно с http://www.eclipse.org/downloads, установка не составит большого труда.

4. Установка и настройка PyDev.

Имея на руках установленную Eclipse можем установить плагин к ней для разработки на Python — имя ему PyDev.

  • Запустите Eclipse и в меню выберите Help >> Software Updates >> Find and Install… (Справка >> Обновление программ >> Найти и установить…).

  • Выберите: Search for new features to install (Поиск новых комплектов для установки) 

    Нажмите кнопку [New Remote Site (Новый удалённый сайт…)] и введите следующий сетевой адрес: http://pydev.sourceforge.net/updates/.

  • Выберите только что добавленный сайт, выставив напротив него галочку, и нажмите кнопку [Finish (Готово)] .

  • Выберите PyDev расширение в списке комплектов для установки и нажмите кнопку [Finish (Готово)]. Подождите пока выбранные компоненты загрузятся и установятся в систему.

Теперь надо бы настроить PyDev.

  • Выберите в меню Window >> Preferences (Окно >> Параметры…) далее в дереве слева укажите PyDev>> Interpreter — Python.

  • Вверху в панели Python interpreters нажмите [New… (Создать)] и укажите полный путь к установленному Python (python.exe или python для Linux).
  • Далее в панели System PYTHONPATH нажмите [New folder (Новая папка)] и укажите путь к корневой папке Django.

Ну и «OK» нажать не забудьте.

Далее идут необязательные пункты для настройки системы контроля версий и создания репозитория в WEB для удалённой совместной разработки.

5. Создание репозитория (на хостинге проектов google).

Для этого, всего на всего, нужно заполнить анкету на странице http://code.google.com/hosting/createProject, будучи залогиненым с помощью аккаунта Gmail.

6. Установка и настройка SubVersion.

Для работы с SubVersion, или системой контроля версий, для Eclipse существует плагин SubEclipse.Чтобы его установить

  • в меню Eclipse выберите Help >> Software Updates >> Find and Install… (Справка >> Обновление программ >> Найти и установить…).

  • Выберите: Search for new features to install (Поиск новых комплектов для установки).

  • Нажмите кнопку [New Remote Site (Новый удалённый сайт…)] и введите следующий сетевой адрес: http://subclipse.tigris.org/update_1.4.x

Теперь систему надо настроить на репозиторий, созданный на пятом шаге.Для этого,

  • выбрав перспективу SubEclipse (Window >> Open perspective >> Other… >> SVN Repository Exploring),
  • в панели SVN Repositories в контекстном меню выбрать New… >> Repositoty Location… и в поле URL вставить адрес репозитория.

Адрес репозитория виден на странице вашего проекта на хостинге проектов Google, во вкладке Source. Это строка вида «https://<имя проекта>.googlecode.com/svn/trunk/».

  • Далее система спросит логин и пароль.

Логином здесь является имя учётной записи в Gmail, а пароль вам нужно будет сгенерировать, перейдя по ссылке «When prompted, enter your generated googlecode.com password.». Она находится на той же странице вашего проекта, в той же вкладке Source.

Ну вот и всё.

В инструкции использовался материал статьи http://twiki.falkolab.ru/bin/view/Python/SettingUpEclipse.

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

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

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

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

Что такое Django?

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

Установка Django

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

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

venv:

$ python –m venv ll_env

pipenv:

$ pipenv --python 3.8

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

venv, macOS and Linux:

$ source ll_env/bin/activate

venv, Windows:

> ll_env\Scripts\activate

pipenv:

$ pipenv shell

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

venv:

(ll_env)$ pip install Django

pipenv:

pipenv install Django

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

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

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

$ django-admin startproject learning_log .

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

$ python manage.py migrate

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

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

$ python manage.py runserver

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

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

$ python manage.py startapp learning_logs

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

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

$ python manage.py runserver

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

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

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

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

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

 def __str__(self):
     return self.text

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

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

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

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

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

$ python manage.py makemigrations learning_logs

$ python manage.py migrate

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

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

$ python manage.py createsuperuser

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

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

from django.contrib import admin
from .models import Topic

admin.site.register(Topic)

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

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

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

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

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

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

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

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

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

from django.contrib import admin
from django.urls import path, include
urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('learning_logs.urls')),
]

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

Файл urls.py в приложении сообщает Django, какое представление использовать для каждого URL-адреса в этом приложении. Вам нужно создать этот файл самостоятельно и сохранить его в папке приложения.

from django.urls import path
from . import views

app_name = 'learning_logs'
urlpatterns = [
    # Домашняя страница.
    path('', views.index, name='index'),
]

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

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

from django.shortcuts import render

def index(request):
    """Домашняя страница."""
    return render(request,
        'learning_logs/')

Написание простого шаблона

Шаблон устанавливает структуру страницы. Создайте папку с именем templates в директории проекта. Внутри templates создайте ещё одну папку с тем же именем, как у приложения. Здесь должны быть сохранены все файлы шаблонов. Шаблон домашней страницы будет сохранён как learning_logs/templates/learning_logs/.

Наследование шаблонов

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

Родительский шаблон

Родительский шаблон определяет общие элементы для набора страниц, а также уникальные блоки для отдельных страниц.

<p>
  <a href="{% url 'learning_logs:index' %}">
    Learning Log
  </a>
</p>

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

Дочерний шаблон

Дочерний шаблон использует тег {% extends %} для извлечения структуры родительского шаблона. Затем он переопределяет содержимое для блоков, указанных в родительском шаблоне.

{% extends 'learning_logs/base.html' %}

{% block content %}

  <p>
    Learning Log helps you keep track of your learning, for any topic you're learning about.
  </p>

{% endblock content %}

Отступы в шаблоне

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

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

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

Параметры URL

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

urlpatterns = [
    # --snip--
    path('topics/<int:topic_id>/', views.topic,
        name='topic'),
]

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

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

def topic(request, topic_id):
    """Показывает тему и все её записи."""
    topic = Topic.objects.get(id=topic_id)
    entries = topic.entry_set.order_by(
        '-date_added')
    context = {
        'topic': topic,
        'entries': entries,
    }
    return render(request,
        'learning_logs/topic.html', context)

Использование данных в шаблоне

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

{% extends 'learning_logs/base.html' %}

{% block content %}

  <p>Topic: {{ topic }}</p>

  <p>Entries:</p>
  <ul>
  {% for entry in entries %}
    <li>
    <p>
      {{ entry.date_added|date:'M d, Y H:i' }}
    </p>
    <p>
      {{ entry.text|linebreaks }}
    </p>
    </li>
  {% empty %}
    <li>There are no entries yet.</li>
  {% endfor %}
  </ul>

{% endblock content %}

Django Shell

Вы можете работать с проектом Django из командной строки. Это полезно для выполнения запросов и тестирования фрагментов кода.

Начать сеанс оболочки

$ python manage.py shell

Доступ к данным из проекта

>>> from learning_logs.models import Topic
>>> Topic.objects.all()
[<Topic: Chess>, <Topic: Rock Climbing>]
>>> topic = Topic.objects.get(id=1)
>>> topic.text
'Chess'

Пользователи и формы

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

Учётные записи пользователей

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

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

После создания приложения обязательно добавьте его в INSTALLED_APPS в файле settings.py проекта.

$ python manage.py startapp users

Добавление URL-адресов приложения users

Добавьте эти строки в файл urls.py проекта, чтобы включить в проект URL-адреса приложения users.

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

urlpatterns = [
    path('admin/', admin.site.urls),
    path('users/', include('users.urls')),
    path('', include('learning_logs.urls')),
]

Использование форм в Django

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

Создание URL для входа, выхода и регистрации

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

from django.urls import path, include
from . import views

app_name = 'users'
urlpatterns = [
    # Дефолтные url для авторизации.
    path('', include(
        'django.contrib.auth.urls')),
    # Страница авторизации.
    path('register/', views.register,
        name='register'),
]

Шаблон входа

Вид входа в систему предоставляется по умолчанию, но вам необходимо указать свой собственный шаблон входа. В примере ниже шаблон отображает простую форму входа и показывает основные сообщения об ошибках. Создайте папку templates в директории приложения users, а внутри templates — папку registration. Сохраните файл как login.html.

Тег {% csrf_token %} помогает предотвратить CSRF-атаки с помощью форм. Элемент {{form.as_p}} отображает форму входа по умолчанию в формате абзаца. Элемент <input> с именем next перенаправляет пользователя на домашнюю страницу после успешного входа в систему.

{% extends "learning_logs/base.html" %}

  {% block content %}
    {% if form.errors %}
    <p>
      Your username and password didn't match. Please try again.
    </p>
    {% endif %}

  <form method="post"
      action="{% url 'users:login' %}">

    {% csrf token %}
    {{ form.as_p }}
    <button name="submit">Log in</button>

    <input type="hidden" name="next"
        value="{% url 'learning_logs:index' %}"/>

  </form>

{% endblock content %}

Отображение текущего статуса входа

Вы можете изменить шаблон base.html, чтобы показать, вошёл ли пользователь на сайт в данный момент, и предоставить ссылку на страницы входа и выхода. Django делает объект user доступным для каждого шаблона.

Тег user.is_authenticated позволяет вам показать конкретный контент пользователям в зависимости от того, вошли они в систему или нет. Свойство {{user.username}} приветствует пользователей, которые вошли в систему. Те же, кто не вошёл в систему, увидят ссылки для регистрации или входа.

<p>
  <a href="{% url 'learning_logs:index' %}">
    Learning Log
  </a>
  {% if user.is_authenticated %}
    Hello, {{ user.username }}.
    <a href="{% url 'users:logout' %}">
      Log out
    </a>
  {% else %}
    <a href="{% url 'users:register' %}">
      Register
    </a> -
    <a href="{% url 'users:login' %}">
      Log in
    </a>
  {% endif %}

</p>

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

Шаблон logged_out

Выход из системы по умолчанию отображается с помощью шаблона logged_out.html, который необходимо сохранить в папке users/templates/registration.

{% extends "learning_logs/base.html" %}
{% block content %}
  <p>
  You have been logged out. Thank you
  for visiting!
  </p>
{% endblock content %}

Регистрация пользователей

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

from django.shortcuts import render, redirect
from django.contrib.auth import login
from django.contrib.auth.forms import \
        UserCreationForm

def register(request):
    """Регистрация нового пользователя."""
    if request.method != 'POST':
        # Отобразить пустую форму регистрации.
        form = UserCreationForm()
    else:
        # Обработать заполненную форму.
        form = UserCreationForm(
            data=request.POST)

        if form.is_valid():
            new_user = form.save()

            # Вход в систему, переход на дом.страницу.
            login(request, new_user)
            return redirect(
                'learning_logs:index')

    # Отобразить пустую форму или сообщение об ошибке.
    context = {'form': form}
    return render(request,
        'registration/register.html', context)

Шаблон регистрации

Шаблон register.html отображает поля формы регистрации в виде списка тегов <p>.

{% extends 'learning_logs/base.html' %}

{% block content %}

  <form method='post'
      action="{% url 'users:register' %}">

    {% csrf_token %}
    {{ form.as_p }}

    <button name='submit'>Register</button>
    <input type='hidden' name='next'
        value="{% url 'learning_logs:index' %}"/>

  </form>

{% endblock content %}

Данные пользователей

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

Создание темы, принадлежащей пользователю

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

После изменения модели вам нужно будет мигрировать базу данных и установить user ID для каждого существующего пользователя.

from django.db import models
from django.contrib.auth.models import User

class Topic(models.Model):
    """Тема, которую просматривает пользователь."""
    text = models.CharField(max_length=200)
    date_added = models.DateTimeField(
        auto_now_add=True)
    owner = models.ForeignKey(User,
        on_delete=models.CASCADE)

def __str__(self):
    return self.text

Запрос данных для текущего пользователя

Объект запроса имеет атрибут user в своём представлении. Вы можете использовать этот атрибут для получения данных пользователя — их извлекает метод filter().

topics = Topic.objects.filter(
    owner=request.user)

Ограничение доступа незарегистрированным пользователям

Некоторые страницы показываются только зарегистрированным пользователям. Представления для этих страниц могут быть защищены декоратором @login_required. Любое такое представление будет автоматически перенаправлять незарегистрированных пользователей на соответствующую страницу. Вот пример файла views.py:

from django.contrib.auth.decorators import \
    login_required

# --snip--

@login_required
def topic(request, topic_id):
    """Показать тему и все её записи."""

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

Декоратор @login_required отправляет неавторизованных пользователей на страницу входа. Добавьте следующую строку в файл settings.py, чтобы Django знал, как найти страницу входа.

LOGIN_URL = 'users:login'

Предотвращение случайного доступа

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

from django.http import Http404
# --snip--

@login_required
def topic(request, topic_id):
    """Показать тему и все её записи."""
    topic = Topics.objects.get(id=topic_id)
    if topic.owner != request.user:
        raise Http404
# --snip--

Формы для редактирования данных

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

Создание формы с исходными данными

Параметр instance позволяет указать начальные данные для формы.

form = EntryForm(instance=entry)

Изменение данных перед сохранением

Аргумент commit = False позволяет вносить изменения перед записью в базу данных.

new_topic = form.save(commit=False)
new_topic.owner = request.user
new_topic.save()

⌘⌘⌘

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

Пишите в комментариях, шпаргалки по каким языкам или фреймворкам вы хотели бы видеть в нашем блоге.


Шпаргалка основана на материалах сайта ehmatthes.github.io.

Django на production. uWSGI + nginx. Подробное руководство / Хабр

Перед вами руководство по настройке production окружения для Django. Здесь будут описаны необходимые шаги по настройке Django, uWSGI и nginx. Руководство охватывает все три компонента — полный стек серверного ПО для веб-приложений.

Подразумевается, что вы используете Unix-подобную операционную систему и менеджер пакетов, эквивалентный aptitude. Найти эквивалент aptitude почти для любой операционной системы, в том числе и для Mac OS X, для вас не составит никакого труда.

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

Общая идея

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

Для выполнения этих задач был разработан Web Server Gateway Interface — WSGI — стандарт взаимодействия Python программ и веб-сервра.

uWSGI — одна из реализаций WSGI. В этом руководстве мы установим и настроим uWSGI для создания Unix сокета и взаимодействия с веб-сервером по протоколу WSGI.


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

Пользователь <-> Веб-сервер <-> Сокет <-> uwsgi <-> Django

Перед установкой uWSGI

virtualenv

Создадаем и активируем виртуальное окружение для софта, который нам будет необходим (ниже я расскажу, как установить uwsgi глобально):

virtualenv uwsgi-tutorial
cd uwsgi-tutorial
source bin/activate

Django

Устонавливаем Django в наше виртуальное окружение:

pip install Django

Создаем новый проект и переходим в его корневую папку:

django-admin.py startproject mysite
cd mysite

Домен и порт

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

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

Установка и базовая настройка uWSGI

Установка uWSGI в виртуальное окружение

Один из хороших способов установить uWSGI:

pip install uwsgi

Нам понадобятся Python development пакеты. Если вы используете Debian или основнную на Debian операционную систему (например, Ubuntu или Mint), вам нужно установить пакет pythonX.Y-dev, где X.Y — нужная вам версия Python.

Проверка

Создаем файл test.py:

# test.py
def application(env, start_response):
    start_response('200 OK', [('Content-Type','text/html')])
    return [b"Hello World"] # python3
    #return ["Hello World"] # python2

Запускаем uWSGI:

uwsgi --http :8000 --wsgi-file test.py

Опции:

  • http: 8000: используется протокол http и порт 8000
  • wsgi-file test.py: uwsgi загрузит определенный файл (в нашем случае test.py)

В браузере переходим по адресу yourserver.com:8000.
Видим: «Hello, world», значит, мы все сделали правильно и следующие компоненты работают:

Пользователь <-> uWSGI <-> test.py

Проверка работы Django приложения

Теперь сделаем так, чтобы uWSGI работал с Django приложением, а не с файлом test.py.

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

python manage.py runserver 0.0.0.0:8000

Если проект запустился, останавливаем сервер для разработки и запускаем uWSGI следующим образом:

uwsgi --http :8000 --module mysite.wsgi

  • module mysite.wsgi: uwsgi загрузит модуль mysite.wsgi

В браузере переходим по адресу yourserver.com:8000.
Видим стартовую страницу Djangо, значит, мы все сделали правильно и следующие компоненты работают:

Пользователь <-> uWSGI <-> Django

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

Устновка и базовая настройка nginx

Установка и запуск nginx
sudo apt-get install nginx
sudo /etc/init.d/nginx start 

Чтобы проверить, что nginx установлен и запущен, перейдите по адресу yourserver.com:80. Если вы видите сообщение “Welcome to nginx!”, значит, все окей и следующие компоненты работают:

Пользователь <-> Веб-сервер

Если у вас занят восьмидесятый порт, измените конфигурацию nginx так, чтобы он использовал какой-нибудь другой (в этом руководстве nginx будет использовать порт 8000).

Конфигурация nginx для работы с Django

Нам понадобится файл uwsgi_params, который можно взять здесь: github.com/nginx/nginx/blob/master/conf/uwsgi_params.
Скачиваем его в корневую папку нашего проекта.

Создаем файл mysite_nginx.conf:

# mysite_nginx.conf

upstream django {
    # server unix:///path/to/your/mysite/mysite.sock; # взаимодействие с uwsgi через Unix-сокет (мы воспользуемся этим вариантом позже) 
    server 127.0.0.1:8001; # взаимодействие с uwsgi через веб-порт 
}

# конфигурация веб-сервера
server {
    # порт, который будет слушать веб-сервер в ожидании запросов от пользователй
    listen      8000;
    # доменное имя
    server_name     yourserver.com; # замените на собственный домен или IP адрес
    charset     utf-8;

    # максимальный размер загружаемых на сервер данных
    client_max_body_size 75M;  

    # обслуживание медиа файлов и статики
    location /media  {
        alias /path/to/your/mysite/media;  # расположение медиафайлов (при необходимости измените)
    }

    location /static {
        alias /path/to/your/mysite/static;  # расположение статики (при необходимости измените)

    }

    # Остальные запросы перенаправляются в Django приложение
    location / {
        uwsgi_pass  django;
        include     /path/to/your/mysite/uwsgi_params; # файл uwsgi_params, который мы только что взяли с github
    }
}

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

В папке /etc/nginx/sites-enabled создаем ссылку на файл mysite_nginx.conf, чтобы nginx увидел его:

sudo ln -s ~/path/to/your/mysite/mysite_nginx.conf /etc/nginx/sites-enabled/

Статика в одном месте

Перед запуском nginx поместим всю статику в папку static. Для этого добавляем в файл mysite/settings.py следующую строку:

STATIC_ROOT = os.path.join(BASE_DIR, "static/")

И выполняем команду:

python manage.py collectstatic

Проверка осблуживания статики и медиа

Перезапускаем nginx:

sudo /etc/init.d/nginx restart

Помещаем файл с именем, например, media.png в папку /path/to/your/project/project/media.

В браузере переходим по адресу yourserver.com:8000/media/media.png и, если видим наш файл, значит мы все сделали правильно.

nginx + uWSGI + test.py

Настраиваем взаимодействие nginx и test.py через uSWGI.

uwsgi --socket :8001 --wsgi-file test.py

Почти то же самое, что мы сделали недавано, за исключением одной опции:

  • socket :8001: используем протокол uWSGI, порт 8001

Как вы помните, мы сконфигурировали nginx(файл mysite_nginx.conf) для работы с uWSGI через порт 8001.

Если перейти по адресу yourserver.com:8001, то мы ничего не увидим, поскольку браузер использует протокол http, а не uWSGI, однако uWSGI выведет сообщение о попытке соединения в терминал.

Unix сокеты вместо веб-портов

До этого мометна мы использовали сокет, привязанный к TCP порту (я называл его веб-порт), потому что так было проще, но на деле рекомендуется использовать Unix-сокет из-за преимущества в производительности.

Редактируем mysite_nginx.conf следующим образом:

server unix:///path/to/your/mysite/mysite.sock; # взаимодействие с uwsgi через Unix-сокет
# server 127.0.0.1:8001; # взаимодействие с uwsgi через веб-порт 

И перезапускаем nginx:

sudo /etc/init.d/nginx restart

Запускаем uWSGI:

uwsgi --socket mysite.sock --wsgi-file test.py

На этот раз опция socket указывает на файл.
Открываем в браузере yourserver.com:8000/

Если не заработало

Проверьте лог ошибок nginx, скорее всего он находится в файле var/log/nginx/error.log

Если найдете там что-то похожее на

connect() to unix:///path/to/your/mysite/mysite.sock failed (13: Permission denied)

значит есть проблема с правами доступа к файлу mysite.sock. Необходимо сделать так, чтобы nginx имел разрешение на использование этого файла.

Попробуйте запустить uWSGI так:

uwsgi --socket mysite.sock --wsgi-file test.py --chmod-socket=666 #много полномочий

Или так:

uwsgi --socket mysite.sock --wsgi-file test.py --chmod-socket=664 #более разумно

Чтобы проблем с доступом в будущем не было, добавьте вашего пользователя в группу www-data.

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

nginx + uWSGI + Django

Запускаем:

uwsgi --socket mysite.sock --module mysite.wsgi --chmod-socket=664

В браузере переходим на yourserver.com:8000/ и видим стартовую страницу Django.

Пользователь <-> Веб-сервер <-> Сокет <-> uwsgi <-> Django

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

Конфигурация uWSGI через ini файл

Очень удобно все опции, с которыми мы запускаем uWSGI, указать в ini файле, а при запуске передавать только путь к этому файлу.

Создаем файл mysite_uwsgi.ini:

#mysite_uwsgi.ini 
[uwsgi]

# Настройки, связанные с Django
# Корневая папка проекта (полный путь)
chdir           = /path/to/your/project
# Django wsgi файл
module          = project.wsgi
# полный путь к виртуальному окружению
home            = /path/to/virtualenv

# общие настройки
# master
master          = true
# максимальное количество процессов
processes       = 10
# полный путь к файлу сокета
socket          = /path/to/your/project/mysite.sock
# права доступа к файлу сокета
# chmod-socket    = 664
# очищать окружение от служебных файлов uwsgi по завершению
vacuum          = true

Запускаем uWSGI:

uwsgi --ini mysite_uwsgi.ini

Проверяем. Все работает? Дальше.

Устанавливаем uWSGI глобально

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

Деактивируем виртуальное окружение:

deactivate

Устанавливаем uwsgi:

sudo pip install uwsgi
# Или можно установить LTS (с долговременной поддержкой) версию
pip install http://projects.unbit.it/downloads/uwsgi-lts.tar.gz

На вики странице uWSGI описано несколько вариантов установки. Перед тем, как установить uWSGI глобально, вам не помешает определиться с выбором версии и методом установки.

Запусить uWSGI можно той же командой, что и раньше:

uwsgi --ini mysite_uwsgi.ini

Режим Emperor

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

Если один из конфигурационных файлов будет изменен, uWSGI перезапустит соответствующего вассала.

Создаем папку для конфигурационных файлов:

sudo mkdir /etc/uwsgi
sudo mkdir /etc/uwsgi/vassals

Создаем в ней ссылку на mysite_uwsgi.ini:

sudo ln -s /path/to/your/mysite/mysite_uwsgi.ini /etc/uwsgi/vassals/

Запускаем uWSGI в режиме Emperor:

sudo uwsgi --emperor /etc/uwsgi/vassals --uid www-data --gid www-data

Опции:

  • emperor: папка с конфигурациолнными файлами
  • uid: id пользователя, от имени которого будет запущен процесс
  • gid: id группы, от имени которой будет запущен процесс

Проверяем. yourserver.com:8000/

Автоматичесеий запуск uWSGI после загрузки операционной системы

В файл /etc/rc.local, перед строкой “exit 0” добавляем:

/usr/local/bin/uwsgi --emperor /etc/uwsgi/vassals --uid www-data --gid www-data

Дело сделано.

Создаем Todo приложение c помощью Django. Часть 1

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


Джанго это мощный фреймворк для создания веб-приложений. Изначально Django был создан для того, чтобы быстро создавать, например, новостные сайты (или другие сайты, который нужно создавать максимально быстро). И после нативного PHP не покидает ощущение, что ты едешь на очень быстрой машине разработки. Чтобы посмотреть все его возможности для быстрой разработки, мы с вами попробуем создать простое Todo — приложение.

Начнем с формулировки краткого т.з. У нас будет небольшое веб-приложение с версткой на Bulma (да, я очень люблю Bulma. Возможно, когда-нибудь я сверну на Bootstrap или Picnic, но всему свое время). У нас (пока) нет авторизаций и пользователь может создавать, редактировать и удалять либо категорию дел, либо карточку todo, которая связана с какой-либо категорией, которую создал пользователь. Todo карточку или категорию можно удалить, поставив галочку на checkbox и нажав кнопку удалить.

Основные концепции Django

Немного поговорим о Django. Django реализует архитектурный паттерн MVT (Модель Представление Шаблон), которая немного отличается от знакомого большинству MVC (Модель Представление Контроллер) на котором работает Ruby on Rails и Laravel.

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

Представление (View) В представлении в Django вы задаете основную логику и алгоритмы приложения, получаете различные данные из базы данных или манипулируете ими. Представление обычно базируется на функциях request\response. Response представляет из себя обычно HTTP redirect, HTTP error(404), MimeTypes или какой-либо шаблон.

Шаблон Шаблон в Django это простой HTML код со специальным шаблонным языком Django. DTL (Django Template Language) — это язык, с помощью которого вы можете динамически менять содержимое страницы (к примеру, изменять имя пользователя на странице, в зависимости от того, как зовут авторизовавшегося пользователя).

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

Url Файл настройки роутинга — примерно то же самое, что и в Angular или Laravel. Это связывает представление с url запросами.

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

Установка Python и Django

Творческое отступление

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

Версии Python

До последнего времени активно поддерживались и развивались две основные ветки Python: 2.7 и 3.x. Я буду использовать версию 3.7.3 в данной статье, но на самом деле это не так важно. Если вы правда хотите знать разницу между ними, есть специальная вики. С другой стороны, сейчас уже нет никакого смысла использовать Python версии 2.7 — обновление языка остановилось на 2.7.17 (если я правильно понимаю документацию на официальном сайте). Это означает, что есть смысл переводить проекты написанные на Python 2.7.x на новую ветку, а вот новые писать на 2 версии совсем бессмысленно.

Инсталляция Python

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

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

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

Так как же использовать virtual env?

1) Самый простой вариант. Вы можете скачать замечательный IDE от JET BRAINS PyCharm Community Edition отсюда. После установки PyCharm создайте новый проект, и Pycharm по умолчанию предложит вам создать Virtual Env, в котором будет возможность установить нужную версию Django (или по умолчанию последнюю, которая на момент написания данной статьи 3.0.2):

pip3 install django

2) Чуть более хардкорный вариант:

А что, если вы хотите запустить Django в virtual env, к примеру, в любимой папке?

Во, первых, создаем папку, в которой мы будет творить:

	mkdir myfirstdjango && cd myfirstdjango

Дальше вводим следующие команды для активации venv, где django_env имя нашего виртуального окружения:

	python3 -m venv django_env
	source django_env/bin/activate

Далее наше виртуальное окружение активировалось. Можем поставить необходимые пакеты. В нашем случае это Django:

	pip3 install django

Если вы захотите выключить виртуальное окружение, чтобы вернуться в ваш глобальный python (вернуться в контекст system), введите следующую команду:

    deactivate

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

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

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

    django-admin startproject todo  #создаем корневую папку вашего проекта
    cd todo #проходим в нее
    python manage.py startapp todolist  #как бы подприложение todolist
	python3 manage.py runserver 8100 #поднимаем сервер на нашем любимом незанятом порте, 8000 по умолчанию
 

Так, после того как Django открыл стартовую страницу, необходимо проинсталлировать наше приложение todolist в основное приложение. Открываем settings.py и добавляем в уже имеющийся список приложений наш собственный todolist:

INSTALLED_APPS = [
	#предустановленные админки, аутентификации и остальное из коробки, не вижу смысла здесь перечислять
    'todolist',
]

Следующим шагом будет связывание приложения с базой данных. Если базы данных — это не то, с чем вы хотите возиться, вам стоит воспользоваться решением по умолчанию — SQlite. Я же решил воспользоваться PostgreSQL — она популярна и классически связана с Django, кроме того, потом мы можем захотеть увеличить производительность приложения. Инструкций как устанавливать PostgreSQL на все операционные системы достаточно много. Я разрабатываю под MacOS и не без небольших танцев с бубном я поставил эту базу данных, скачав сам Postgres.app отсюда . Что касается интерфейсов для БД, то здесь я воспользовался Postico и пробной версии для разработки приложения нам вполне хватит (хотя в принципе можно обойтись и без неё, потому что все наше взаимодействие с базой данных будет построено через само веб-приложение и миграции). Кроме того, пришлось поставить psycopg2 в виртуальное окружение проекта (без этого драйвера с БД ваше приложение работать не будет).

Дальше нужно настроить работу статики. По-прежнему редактируем файл settings.py, теперь в самом конце добавляем работу со статикой:

STATIC_URL = '/static/'
PROJECT_ROOT = os.path.dirname(os.path.abspath(__file__))
STATIC_ROOT = os.path.join(PROJECT_ROOT, 'static')
STATICFILES_STORAGE = 'whitenoise.django.GzipManifestStaticFilesStorage'

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

django.contrib.staticfiles, на тот случай, если произойдет ошибка.

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

	from django.conf.urls import url
	from django.contrib import admin
	from todolist.views import todo
	from todolist.views import category
	from todolist.views import redirect_view
 
urlpatterns = [
	url(r'$^', redirect_view ),
	url(r'^admin/', admin.site.urls),
	url(r'^todo/', todo, name="TodoList"),
	url(r'^category/', category, name="Category"),
]

Я добавил редирект так как хочу, чтобы с дефолтной страницы localhost сразу переходил на подстраницу category(чтобы не дай бог пользователь не потерялся). Также у нас есть роутинг на две страницы: категорий и дел.

Итак, надеюсь ваше приложение не упало. Далее мы можем наконец-то переходить к созданию самого приложения:

Создание модели Todo и Категорий

Дальше приступим к созданию модели, которая будет базово взаимодействовать с нашей базой данных. Для создания модели открываем файл models.py в нашем todolist и начинаем творить. Начнем с того, что создадим таблицу категорий:

from django.utils import timezone #мы будем получать дату создания todo
from django.db import models
 
class Category(models.Model): # Таблица категория которая наследует models.Model
    name = models.CharField(max_length=100) #varchar.Нам потребуется только имя категории
	class Meta:
    	verbose_name = ("Category") # человекочитаемое имя объекта
    	verbose_name_plural = ("Categories")  #человекочитаемое множественное имя для Категорий
    def __str__(self):
        return self.name  # __str__ применяется для отображения объекта в интерфейсе

Отлично! Да, здесь у нас будет только две колонки в таблице Категорий: id и name. Дальше создадим таблицу для наших дел. Думаю, из комментариев все понятно:

class TodoList(models.Model):
	title = models.CharField(max_length=250)
	content = models.TextField(blank=True) #текстовое поле
	created = models.DateField(default=timezone.now().strftime("%Y-%m-%d")) # дата создания
	due_date = models.DateField(default=timezone.now().strftime("%Y-%m-%d")) #до какой даты нужно было сделать дело
	category = models.ForeignKey(Category, default="general",on_delete=models.PROTECT) # foreignkey с помощью которой мы будем осуществлять связь с таблицей Категорий
	class Meta: #используем вспомогательный класс мета для сортировки наших дел
        ordering = ["-created"] #сортировка дел по времени их создания
	def __str__(self):
    	return self.title

После того, как ваша модель будет готова, необходимо создать миграции:

	python3 manage.py makemigrations

И потом запускаете сами миграции:

	python3 manage.py migrate

Создание view

Откроем файл view.py в todolist и отредактируем его. Для начала добавим необходимые импорты и редирект с главной на category:

from django.shortcuts import render, redirect #для отображения и редиректа берем необходимые классы
from django.http import HttpResponse
from .models import TodoList, Category #не забываем наши модели
 
def redirect_view(request):
	return redirect("/category") # редирект с главной на категории

Потом начинаем создание нашего дела. У экземпляра дела будут поля самого текста, даты, до которой должно быть закончено дело, категория дела, и объединенный контент:

def todo(request):
	todos = TodoList.objects.all() #запрашиваем все объекты todo через менеджер объектов
    categories = Category.objects.all() #так же получаем все Категории

После этого добавим функции добавления и удаления дел:

if request.method == "POST": #проверяем то что метод именно POST
	if "Add" in request.POST: #проверяем метод добавления todo
    	title = request.POST["description"] #сам текст
    	date = str(request.POST["date"]) #дата, до которой должно быть закончено дело
        category = request.POST["category_select"] #категория, которой может выбрать или создать пользователь.
        content = title + " -- " + date + " " + category # полный склеенный контент
    	Todo = TodoList(title=title, content=content, due_date=date, category=Category.objects.get(name=category))
    	Todo.save() # сохранение нашего дела
        return redirect("/todo") # перегрузка страницы (ну вот так у нас будет устроено очищение формы)
    if "Delete" in request.POST: #если пользователь собирается удалить одно дело
        checkedlist = request.POST.getlist('checkedbox') # берем список выделенные дел, которые мы собираемся удалить
        for i in range(len(checkedlist)): #мне почему-то не нравится эта конструкция
            todo = TodoList.objects.filter(id=int(checkedlist[i]))
        	todo.delete() #удаление дела
return render(request, "todo.html", {"todos": todos, "categories": categories})

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

def category(request):
	categories = Category.objects.all()  #запрашиваем все объекты Категорий
	if request.method == "POST": #проверяем что это метод POST
    	if "Add" in request.POST: #если собираемся добавить
        	name = request.POST["name"] #имя нашей категории
        	category = Category(name=name) #у нашей категории есть только имя
            category.save() # сохранение нашей категории
        	return redirect("/category")
    	if "Delete" in request.POST: # проверяем есть ли удаление
            check = request.POST.getlist('check') #немного изменил название массива в отличии от todo, что бы было меньше путаницы в коде
            for i in range(len(check)):
            	try:
                	сateg = Category.objects.filter(id=int(check[i]))
                	сateg.delete()   #удаление категории
            	except BaseException: # вне сомнения тут нужно нормально переписать обработку ошибок, но на первое время хватит и этого
                	return HttpResponse('<h2>Сначала удалите карточки с этими категориями)</h2>')
	return render(request, "category.html", {"categories": categories})

На этом мы заканчиваем с файлом view и можем переходить к шаблонам:

Работа с шаблонами

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

Создаем base.html и редактируем его:

<!DOCTYPE html>
<html lang="ru">
<head>
  <meta charset="UTF-8">
  <title> Приложение для дел</title>
  {% load static %}
	<link rel="shortcut icon" type="image/png" href="{% static 'favicon.png' %}"/>
   <link rel="stylesheet" type="text/css" href="{% static 'bulma.min.css' %}">
	<link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css">
</head>
<body>
<div django-app="TaskManager">
	<nav class ="navbar is-success" role="navigation" aria-label="main navigation">
     	<div>
        	<div>
        	<a href="../category"> Категории</a>
        	<a href="../todo"> Список дел </a>
        	</div>
         </div>
	</nav>
<!--     в блок контент мы будем подгружать наши странички категорий и тудушек-->
{% block content %}
{% endblock %}
</div>
</body>
</html>

Дальше у нас пойдут страницы todo.html и category.html:

Тудушка:

{% extends 'base.html' %}
{% block content %}
<div>
	<!-- на самом деле можно было обойтись и hero, но я обратился к inline-css -->
	<div>
    	<h2> Список дел </h2>
    	<form action="" method="post">
        	{% csrf_token %}
        	<!-- csrf для базовой безопасности нашего приложения -->
            <div>
            	<label for="description">Введите дело</label>
            	<div>
             	   <input type="text" placeholder="Чем собираетесь заняться?"
                    	name="description" required>
            	</div>
        	</div>
        	<div>
            	<div>
                	<label for="category">Категории</label>
                	<div>
                    	<div>
                        	<select name="category_select" required>
                            	<!--поставишь такой required, и не надо пустые поляв бд валидизировать. Не повторять в продакшене-->
                            	<option value="">Выберите категорию дела</option>
                    	        {% for category in categories %}
 	                           <option value="{{ category.name }}" name="{{ category.name }}">
                                    {{ category.name }}</option>
                            	{% endfor %}
                        	</select>
    	                </div>
                	</div>
            	</div>
            	<div>
                	<label for="dueDate">Выберите дату</label>
                	<input type="date" name="date" required>
            	</div>
        	</div>
        	<div>
            	<div>
                	<button name="Add" type="submit">
                    	<span>
                        	<i></i>
                    	</span>
                    	<span>Добавить задание</span>
                	</button>
             	   <button name="Delete" formnovalidate="" type="submit">
                    	<span>
                        	<i></i>
                    	</span>
                    	<span>
                        	Удалить дело
                    	</span>
                	</button>
            	</div>
        	</div>
        	<div>
            	{% for todo in todos %}
            	<!-- шаблонный язык django- for loop -->
            	<div>
                	<label>
                    	<input type="checkbox" name="checkedbox" value="{{ todo.id }}">
                    	<span>{{ todo.title }}</span>
                	</label>
                	<span>{{ todo.category }}</span>
                	<strong><i></i>{{ todo.created }} -
                    	{{ todo.due_date }}</strong>
            	</div>
            	{% endfor %}
        	</div>
    	</form>
	</div>
</div>
{% endblock %}

И category.html. В ней у нас не особо много чего меняется, принципиально никак не отличается от todo.html:

{% extends 'base.html' %}
{% block content %}
<div>
	<div>
    	<h2> Отредактируйте ваши категории </h2>
    	<form action="" method="post">
        	{% csrf_token %}
        	<!-- csrf для базовой безопасности нашего приложения -->
            <div>
            	<label for="description"> Введите категории </label>
            	<div>
     	           <input type="text" placeholder="Какого рода у вас дела?"
                    	name="name" required>
            	</div>
            	<div>
                	<button name="Add" type="submit">
                    	<span>
                        	<i></i>
                    	</span>
                    	<span>Добавить категорию</span>
                	</button>
                	<button name="Delete" formnovalidate="" type="submit">
                    	<span>
           	             <i></i>
                    	</span>
	                    <span> Удалить категорию </span>
                	</button>
            	</div>
            </div>
 
            <!--  cписок наших категорий -->
            <div>
            	{% for category in categories %}
            	<div>
                	<label>
                    	<input type="checkbox" name="check" value="{{category.id}}">
                    	<span>{{ category.name }}</span>
                	</label>
            	</div>
            	{% endfor %}
 
        	</div>
    	</form>
	</div>
    {% endblock %}
 

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

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

python — pip установить Django на python3.6

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

  1. Около
  2. Продукты

  3. Для команд
  1. Переполнение стека
    Общественные вопросы и ответы

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

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

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

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

.

python — не удается установить Django 2.0 с помощью pip

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

  1. Около
  2. Продукты

  3. Для команд
  1. Переполнение стека
    Общественные вопросы и ответы

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

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

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

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

  6. О компании

.

python — PIP не может установить Django внутри VIrtualenv

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

  1. Около
  2. Продукты

  3. Для команд
  1. Переполнение стека
    Общественные вопросы и ответы

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

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

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

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

  6. О компании

Загрузка…

  1. Авторизоваться
    зарегистрироваться

  2. текущее сообщество

.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *