Linuxformat - Вклад участника [ru]

LXF106:Django

2009-10-17T16:53:05Z

Gordano: Убрал нумерацию строк в листенге - т.к. сильно затрудняяет форматирование при вставке в проект

: '''''Django''''' Разрабатываем динамические web-приложения современным способом[[Категория:Учебники]]

==Личная блогосфера==

{{Цикл/Django}}

: '''ЧАСТЬ 2''' Новостной портал из прошлого номера журнала легко превратить в мини-блог, предоставив посетителям возможность оставлять комментарии. Но что делать с троллями и спамерами? '''Никита Шультайс''' (http://shultais.ru) во всем разберется.

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

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

===Добавим гибкости===

Откройте файл '''urls.py''' (как вы помните, именно он устанавливает
соответствие между URL-адресами и представлениями) и замените строку

(r'^news/', 'news.views.last_news')

на

(r'^news/', include('news.urls'))

Теперь при переходе к '''news/''' будут подгружаться URL-карты,
относящиеся к приложению. Это позволит нам работать с новостной системой, не выходя за рамки директории news. Далее, нужно
составить URL-карты приложения: создайте файл '''news/urls.py''' следующего содержания:

<source lang="python">
from django.conf.urls.defaults import *
urlpatterns = patterns('news.views',
url(r'^$','last_news',name = 'news.last_news'),
url(r'^(?P<news_id>\d+)/$','news_detail',name = 'news.news_detail'),
)
</source>

Что происходит при обращении к http://mysite.com/news/? Сначала часть URL ('''news/''') ищется в главном файле URL-карт, где
обнаруживается соответствие. Затем система считывает URL-карты,
отвечающие за конкретное приложение (благодаря '''include('news.urls')''') и продолжает поиск, откинув уже найденный шаблон. Так как
после '''news/''' ничего нет, ''Django'' остановится в строке 3 файла '''news/urls.py''' и выполнит представление '''news.views.last_news''', которое мы
создали на прошлом уроке.

Рассмотрим '''news/urls.py''' подробнее. Во второй строке есть интересная запись – '''news.views''', которая указывает ''Django'', что нужно
задействовать представления из одноименного модуля; это позволяет сэкономить место при наборе URL-карт и облегчает чтение
кода. Строки 3 и 4 – это URL-карты особого формата. Они обернуты функцией '''url()''', принимающей три (точнее сказать – до пяти)
аргументов:

* первый (позиционный обязательный) – регулярное выражение;
* второй (позиционный обязательный) – имя представления, которое будет выполняться;
* третий (именованный необязательный) – имя URL-карты. Оно должно быть уникальным не только для приложения, но и для всего проекта, и в нашем случае состоит из двух частей: имени приложения и представления (это не единственный вариант). Часто возникают ситуации, когда одно представление обслуживает несколько URL-адресов, но имя каждой URL-карты всё равно должно быть уникальным. Скажем, если представление view может добавлять или изменять объекты, в зависимости от URL, то карты могут называться '''app.view.add''' и '''app.view.change'''.

{{Врезка|Заголовок=Скорая помощь|Содержание=Если вы взглянете на наши модели, то увидите, что поля первичного ключа – '''id''' – в них
нет, однако в примере с тегом '''url''' мы используем '''news.id''', как ни в чем не бывало. Все верно – ''Django'' сам создает первичные ключи для каждой модели.|Ширина=200px}}

Обратите внимание на конструкцию ('''?P<news_id>\d+''') в строке 4.
Она совпадает с числом ('''\d+'''), захватывает его и помещает в переменную '''news_id''', которая затем передается в представление.

Хотя картам и не обязательно давать имена, это очень сильно упрощает жизнь
разработчика и делает приложение переносимым. Поэтому откройте файл '''news/templates/news/last_news.html''' и измените
строку:

<nowiki><strong>{{ news.title }}</strong></nowiki>

на

<nowiki><strong>
<a href=”{% url news.news_detail news_id=news.id %}”>{{ news.title }}</a>
</strong></nowiki>

В качестве значения атрибута '''href''' мы вставили тег '''url''' системы шаблонов
''Django''. Ему передаются имена URL-карты
и объявленной нами переменной – '''news_id'''. Значение '''news_id''' присваивается первичному ключу новости, которую хотим
просмотреть.

Теперь, когда ''Django'' будет компилировать наш шаблон, '''{% url news.news_detail news_id=news.id %}''' заменится на http://mysite.com/news/1/ для новости с номером 1, и так далее. Если же вы решите модифицировать URL-
карты, например, переименовав news/ в главном файле URL-карт
в '''supernews/''', то система автоматически скорректирует все ссылки,
и сайт продолжит работать. Не забудьте только отредактировать
файл '''media/templates/index.html''', поправив:

<nowiki><a href=”/news/”>News</a></nowiki>

на

<nowiki><a href=”{% url news.last_news %}”>News</a></nowiki>

Если вы решите опробовать возможность автоматической генерации URL, не дожидаясь конца урока, то потребуется также добавить в файл '''news/views.py''' представление-заглушку для нового типа URL,

def news_detail(requets,news_id):
pass

В противном случае автогенерация работать не будет.

===Создаем форму===

{{Врезка|Содержание=[[Изображение:LXF106_79_1.jpg|Рис. 1|300px]]Рис.1. Вот что должно получиться в итоге.|Ширина=300px}}

Продолжим развитие нашего приложения. Сейчас мы создадим
представление и шаблон, с помощью которого можно просматривать детали новости, а также добавлять комментарии. Первым
делом нужно реализовать форму для комментариев (рис.1), и,
как вы могли догадаться, ''Django'' поможет нам в этом непростом
деле. Дистрибутив ''Django'' содержит целых две системы обработки
форм: '''forms''' (старую) и '''newforms''' (новую). Мы будем пользоваться
последней, так как она более удобна и имеет больше возможностей. К тому же в версии 1.0 разработчики удалят старую библио
теку, оставив только '''newforms''' (которая будет переименована в
'''forms''').

Формы очень удобно хранить в файле '''forms.py''' в директории приложения. Создайте его и наберите код:

<source lang="python" >
# -*- coding: utf-8 -*-
from django import newforms as forms
class CommentForm(forms.Form):
username = forms.CharField(label=”Имя”,required=True,
widget=forms.TextInput(attrs={
'size':'30',
'maxlength':'255'}))
text = forms.CharField(label=”Текст”,required=True,
widget=forms.Textarea())
</source>

{{Врезка|Заголовок=Все еще сомневаетесь?|Содержание=Приведем два основных преимущества отделения URL-карт уровня приложений от главной карты сайта:

* '''Переносимость''' Теперь, если мы хотим добавить наше приложение в другой проект, нужно только скопировать директорию с ним в корень проекта, вписать его в '''INSTALLED_APPS''' и включить '''news/urls.py''' в главный файл '''urls.py'''. Если автор приложения расширит функциональность (например, добавит версию для печати), достаточно будет обновить файлы внутри директории '''news''', не заботясь о добавлении или изменении URL-карт.
* '''Удобная работа с картами'''. В реальных проектах количество приложений может достигать 20 и больше, и каждое из них может содержать 10–20 внутренних карт. Если бы мы оформляли все URL-карты в одном файле, то его размер составил бы около 400 строк, а следовательно, возросла бы вероятность ошибки.|Ширина=200px}}

Каждая форма представлена классом ''Python'', унаследованным
от '''forms.Form'''. Она содержит набор полей, являющихся объектами
класса '''forms.*Field'''. Так, в строках 4-7 определяется поле '''username'''
типа '''CharField''' – символьное. Атрибут '''required''' указывает, что мы
не можем оставить его пустым. Далее следует определение «виджета», то есть органа управления, который будет отображаться на
web-странице. Виджет связан с определенным элементом '''HTML'''-формы, например, '''<select>, <input>''' или '''<textarea>'''. Каждый класс
поля имеет свой стандартный виджет, но мы можем переопределить или расширить его, добавив дополнительные атрибуты.
Виджетом по умолчанию для '''CharField''' является '''TextInput (<input type=»text»>)''', здесь мы задаем ему атрибуты '''size''' и '''maxlength'''. В
строках 8-9 определяется поле '''text''', которое также является символьным, но, поскольку одна строка плохо подходит для ввода
комментария, мы назначаем '''text''' виджет '''Textarea()''', соответствующий '''HTML'''-тегу '''<textarea>'''. Обратите внимание на атрибуты '''label:''' они содержат поясняющий текст, который выводится около элемента экранной формы. Так как мы используем кириллицу, необходимо указать кодировку – это делается в первой строке. Я предпочитаю UTF-8.

Теперь пришло время заменить и нашу заглушку (если, конечно,
вы ее создали):

<source lang="python">
def news_detail(request, news_id):
news = News.objects.get(pk=news_id)
if request.method == 'POST':
form = CommentForm(request.POST)
if form.is_valid():
comment = Comment(
news=news,
username = form.cleaned_data['username'],
text = form.cleaned_data['text'])
comment.save()
return HttpResponseRedirect(
reverse('news.news_detail',kwargs={'news_id':news_id}))
else:
form = CommentForm()

comments = Comment.objects.filter(news=news).order_by(“pub_ date”,”id”)
comment_count = comments.count()

template = get_template(“news/news_detail.html”)
context = RequestContext(request, {
“news”:news,
“form”:form,
“comment_count”:comment_count,
“comments”:comments
})
return HttpResponse(template.render(context))
</source>

Сразу стоит обратить внимание на то, что в представление передается дополнительный аргумент '''news_id''', имя которого совпадает с идентификатором переменной, захватываемой при обработке
регулярного выражения в файле '''news/urls.py'''. Во второй строке
мы извлекаем новость, а так как нам нужен только один объект,
то используем для этого функцию '''get()''', передавая ей '''news_id'''
в качестве именованного аргумента '''pk''' ('''Primary Key''', первичный ключ). Дальше следуют два блока: для '''POST-''' (строки 4-12), и
'''GET-'''запросов (14). В строке 3 проверяется, как именно произошло
обращения к данному URL. В случае '''GET''' мы просто создаем объект
формы с пустыми полями.

Если же данные были получены посредством запроса '''POST''', они
передаются в форму. Далее идет проверка на корректность (строка
5): мы убеждаемся, что заполнены все поля. В случае успеха создается объект комментария. Первый параметр – это новость, к которой
он относится, аргументам '''username''' и '''text''' присваиваются очищенные
(то есть преобразованные к определенному типу: '''unicode''' для текста,
'''datetime''' для даты и так далее) данные из полей формы. В 10-й строке
объект сохраняется в БД, а в строках 11–12 мы осуществляем перенаправление. Функция '''reverse''' – это аналог тега url в шаблонах. Она принимает имя URL-карты, а в словаре '''kwargs''' должны содержаться требуемые аргументы, причем переменной '''news_id''' присваивается номер
текущей новости... Проще говоря, мы обновляем страницу. Если же
проверка в строке 5 не проходит, то мы автоматически отправляемся к
строке 15 с формой, где уже заполнены некоторые поля, а для пустых
созданы сообщения об ошибках.

Обратимся к строкам 16 и 17. В первой мы извлекаем все комментарии, относящиеся к новости, а во второй получаем их количество, причем функция '''count()''' генерирует '''SQL'''-конструкцию '''COUNT''',
которая работает очень быстро.

Строки 19-26 рассматривались на прошлом уроке, и сейчас мы
не будем на них останавливаться. Лучше рассмотрим шаблон '''news/templates/news/news_detail.html''' – он может иметь такой вид:

<source lang="python">
{% extends “index.html” %}

{% block application %}

<h1>{{ news.title }}</h1>
<p> {{ news.text }} </p>
{% if comment_count %}
<h3>Комментариев: {{ comment_count }}</h3>
{% for comment in comments %}
<div>
<strong>{{ comment.username }}</strong> пишет:<br/>
{{ comment.text }}<br/>
Дата {{ comment.pub_date|date:”d.m.Y” }}
</div>
<br/><br/>
{% endfor %}
{% else %}
<h3>Комментариев нет</h3>
{% endif %}

<h3>Оставить комментарий:</h3>
<form action=”.” method=”POST”>
<table>{{ form }}</table>
<input type=”submit”/>
</form>

{% endblock %}
</source>

Обратите внимание на строку 7, с которой начинается новый для нас тег – '''{% if %}'''. Он принимает логическую (а поскольку в ''Python'' все числовые значения и строки, которые не равны нулю и не пусты, эквивалентны True, то практически любую) переменную. В строке 17
расположена вторая часть тега – альтернативный блок '''{% else %}''' и,
наконец, в строке 19 тег закрывается. Разумеется, альтернативный
блок можно опустить.

Хотя ''Django'' берет на себя бремя генерации форм, некоторую
часть кода приходится писать вручную. Так, в строке 22 мы определяем форму, а в строке 23 создаем таблицу, в которую она будет
помещена. Дело в том, что по умолчанию при вызове объекта формы все виджеты оборачиваются в '''<nowiki><tr> и <td></nowiki>'''. Это поведение можно
исправить, заменив '''form''' на '''form.as_ul''' или '''form.as_p''', которые которые возвращают ее в виде ненумерованного списка '''<nowiki>(<ul>)</nowiki>''' и параграфов '''<nowiki>(<p>)</nowiki>''', соответственно. Кнопка для отправки формы создается
в строке 24.

Теперь, когда мы создали шаблон и представление для просмотра текста новости и добавления комментариев, осталось только
импортировать необходимые классы и функции в представление
'''news/views.py''':

<source lang=python>
from news.models import News
from news.forms import CommentForm
from django.http import HttpResponseRedirect
from django.core.urlresolvers import reverse
</source>

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

===Плохой песик, плохой!===

Когда ваши новости комментируют объективно – это прекрасно,
но мир неидеален и пока не искоренены спам и флуд, вам придется модерировать сообщения, оставленные посетителями. Наша
система не поддерживает пре-модерацию; конечно, в реальных
проектах так поступать не стоит. Но и у нас не всё потеряно – мы
можем:

* Модерировать комментарии из административного интерфейса
* Делать это прямо с сайта.

{{Врезка|Содержание=[[Изображение:LXF106_81_1.jpg|Рис. 2|300px]]Рис. 2. Пользователи и группы ''Django''.|Ширина=300px}}

Первый вариант настолько прост, что мы даже не будем на
нем останавливаться, но прежде чем перейти ко второму случаю,
поговорим о системе прав ''Django''. С главной страницы «админки»
можно перейти в разделы управления пользователями и группами (рис.2).

Каждый пользователь и группа могут иметь определенные
права доступа, которые описываются в моделях. По умолчанию,
модель предоставляет три разрешения: добавить, изменить и удалить объект из базы данных. Если вы перейдете на страницу редактирования пользователя в «админке», то в разделе '''Permissions > User permissions''' увидите список прав доступа, причем в левой
части ('''Available user permissions''') указываются всевозможные права,
известные системе, а в правой ('''Chosen user permissions''') – разрешения, которыми обладает редактируемый пользователь (рис.3).

{{Врезка|Содержание=[[Изображение:LXF106_81_2.jpg|Рис. 3|300px]]Рис. 3. Настройка прав доступа.|Ширина=300px}}

Каждая строка содержит три части: приложение, модель и право доступа в человеко-понятной форме. Например, '''news | comment | Can add comment''' означает, что пользователь может добавлять комментарии в модель '''comment''' приложения '''news'''. Проверку прав доступа
нужно осуществлять на уровне представлений или/и шаблонов. На
уровне моделей она не производится, поэтому комментарии к нашим
новостям могут добавлять любые посетители, даже не имеющие прав
на совершение таких действий.

Условно, всех пользователей системы можно разделить на две
группы: анонимные и авторизованные. Особый случай – это суперпользователь; в ''Django'', как и в Linux, он царь и бог и обладает
всеми возможными правами. Назначить себя суперпользователем
можно, установив галочку напротив поля '''Superuser status'''. Отметим
ещё два поля в разделе '''Permissions''':
* '''Staff status''' – если эта галочка установлена, пользователь может заходить в «админку» ''Django''.
* '''Active''' – если флажок снят, посетителю будет отказано в авторизации, даже когда он верно указывает свои имя и пароль.

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

<source lang="python" >
@permission_required('news.delete_comment')
def delete_comment(request, news_id, comment_id):
comment = get_object_or_404(Comment,pk=comment_id)
comment.delete()
return HttpResponseRedirect(reverse('news.news_ detail',kwargs={'news_id':news_id}))
</source>

Основным его отличием от виденных нами ранее является проверка прав доступа. Она реализована с помощью декоратора в строке 1 – кстати, не забудьте его импортировать.

from django.contrib.auth.decorators import permission_required

Права доступа в декораторах определяются именем приложения
('''news''') и названием разрешения ('''delete_comment'''). Последнее получается автоматически конкатенацией действия ('''delete''') и модели.
Обратите внимание на строку 3: в ней мы извлекаем из базы данных единственный объект, но используем сокращение '''get_object_or_404()''', которое возвращает страницу 404 в случае отсутствия объекта. Не забудьте импортировать функцию '''get_object_or_404()''' в
ваше представление до её использования:

from django.shortcuts import get_object_or_404

Теперь нам нужно связать URL с представлением:

url(r'^(?P<news_id>\d+)/(?P<comment_id>\d+)/delete/$','delete_comment',name='news.delete_comment'),

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

{% if perms.news.delete_comment %}
<a href=”{% url news.delete_comment news_id=news.id,comment_id=comment.id %}”>[X]</a>
{% endif %}

Это напоминает использование декораторов, за исключением
обращения к объекту '''perms'''. Теперь напротив каждого комментария
будет присутствовать ссылка для его удаления. Далее, заключите
форму (строки 21-25) в блок '''{% if %}''', чтобы она не отображалась
неавторизованным пользователям.

{% if user.is_authenticated %}
...
{% endif %}

Помимо '''perms''', содержащего права текущего пользователя, в
шаблон передается объект '''user''', предоставляющий доступ к прочим реквизитам: имени пользователя, хэшу пароля, данным о текущем состоянии (анонимный или авторизованный). Например, с помощью:

{% if user.is_superuser %}

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

===Вас взломали!===

Казалось бы, все в порядке, но есть одна тонкость. Спрятав форму
от глаз неавторизованного пользователя, мы не лишили его возможности «заполнять» ее, генерируя HTTP-заголовки вручную – представление ведь осталось прежним! Чтобы закрыть лазейку, нужно перво-наперво импортировать исключение '''Http404''' (страница не найдена):

from django.http import Http404

После проверки метода запроса в файле '''news/views.py''' (строка 3) добавьте конструкцию

if not request.user.is_authenticated(): raise Http404

она выбрасывает исключение, если посетитель неавторизован.

Помимо '''Http404''', можно создавать ответы с различными HTTP-кодами, например, '''HttpResponseForbidden''' (403 – доступ запрещен)
и так далее. Заметьте, что '''Http404''' – это именно исключение и его
нужно возбуждать с помощью '''raise''', тогда как остальные ответы
возвращаются посредством '''return'''.

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

form = CommentForm()

на

form = CommentForm(initial={'username':request.user.username})

поле '''username''' автоматически получит имя текущего авторизованного пользователя.''' LXF'''

LXF105:Django

2009-10-17T14:36:57Z

Gordano: Убрал нумерацию строк в листингах - т.к. не удобно копировать код в рабочий проект

: '''Новая серия!''' Разрабатываем динамические web-приложения современным способом[[Категория:Учебники]]

==''Django'': Новостной портал==

{{Цикл/Django}}

: '''ЧАСТЬ 1''' Нужен ли миру еще один новостной портал? Вряд ли больше, чем очередной интернет-магазин, но кого это останавливало! '''Никита Шультайс''' (http://shultais.ru) расскажет эту старую историю на новый лад.

Сегодня каждый более-менее продвинутый пользователь желает иметь свой сайт. Одни устанавливают готовые системы управления web-содержимым (CMS), вторые пишут все с нуля, а третьи – используют web-каркасы (framework), позволяющие создавать отличные динамические web-сайты без особых усилий.
''Django'' как раз и является таким каркасом, написанным на ''Python''. К
числу задач, с которыми он помогает справиться, относятся:

* Создание и обработка форм;
* Разделение логики и представления с помощью мощной системы шаблонов;
* Добавление, поиск, извлечение и удаление записей из базы данных, в объектно-ориентированном стиле (ORM);
* Обработка URL с помощью регулярных выражений;
* Автогенерация интерфейса администратора (в просторечии, «админки»);
* Аутентификация и авторизация пользователей;
* Кэширование как отдельных элементов, так и целых страниц;
* Интернационализация сайта;
* Создание и отправка сообщений по e-mail;
* Тестирование;
* Работа с сессиям, HTTP-запросами и cookie.

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

===На исходную!===

Дистрибутив ''Django'' можно скачать с официального сайта (http://www.djangoproject.com) или взять с '''LXFDVD'''. Желательно использовать
версию из репозитория (0.97), но можно ограничиться и последним стабильным релизом – 0.96. Кроме того, для связи с сервером ''MySQL'' нам
понадобится ''MySQLdb'' версии 1.2.1p2 или выше. После получения ''Django'',
распакуйте архив, перейдите в появившийся каталог и выполните

sudo python setup.py install
[ваш пароль]

При желании, можете заменить ''sudo'' на ''su'' и ввести пароль суперпользователя.

Для начала работы нам нужно создать «проект», в котором будут
храниться все наши файлы. Для этого перейдите в директорию, в
которой вы собираетесь хранить проект (например, '''/var/www'''), и
дайте команду

python /путь/к/django/bin/django-admin.py startproject myproject

после выполнения которой в текущем каталоге появится поддиректория с именем '''myproject'''.

Рассмотрим ее внутреннюю структуру:
myproject/
__init__.py
manage.py
settings.py
urls.py

'''__init__.py''' – это специальный (как видно по двум подчеркиваниям в
имени) файл, который указывает на то, что данный каталог является
модулем (пакетом) языка ''Python''; '''manage.py''' – утилита, позволяющая
управлять вашим проектом. '''Settings.py''' содержит его настройки, а '''urls.py''' – это так называемый «файл URL-карт». В нем указывается, какому адресу какой код соответствует.

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

{{Врезка|Содержание=[[Изображение:LXF105_86_1.jpg|Рис. 1|300px]]Рис. 1. Оно работает, следовательно, существует!|Ширина=300px}}

python manage.py runserver

Она запустит встроенный в ''Django'' web-сервер, предназначенный
специально для разработки сайтов. Сервер стартует на локальном
хосте на порту 8000 и, если все пройдет успешно, вы увидите в консоли следующее сообщение:

Validating models...
0 errors found.
Django version 1.0, using settings 'myproject.settings'
Development server is running at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

Направив свой любимый web-браузер по адресу
http://127.0.0.1:8000/:, вы получите нечто похожее на рис. 1.

===Настроим ''Django''===

Как уже говорилось выше, основные настройки вашего проекта хранятся в файле '''settings.py'''. Откроем его и найдем строку '''DATABASE_ENGINE = ''''': она отвечает за СУБД, которую мы будем использовать в нашем проекте. Поскольку мы выбрали ''MySQL'', изменим эту строку
на '''DATABASE_ENGINE = 'mysql''''. Далее, в '''DATABASE_USER''' укажем
имя пользователя вашей базы данных (заметьте, что у него должны
быть права на создание таблиц в БД), а в '''DATABASE_PASSWORD''' –
его пароль. Если сервер баз данных запущен на локальном хосте и на
порту по умолчанию, параметры '''DATABASE_HOST''' и '''DATABASE_PORT'''
можно оставить пустыми. В поле '''DATABASE_NAME''' введите имя базы
данных (не путайте его с именем СУБД!), которую будет использовать
проект. Да, и не забудьте создать ее перед использованием. В частности, для ''MySQL'' это делается так:

mysql --user=username --password=password
mysql > CREATE DATABASE `myproject_base` DEFAULT CHARACTER
SET utf8 COLLATE utf8_general_ci;

Здесь '''username''' – имя пользователя, который имеет доступ к
СУБД, '''password''' – его пароль, '''myproject_base''' – название БД, в которой будут храниться данные нашего проекта.

Перейдем к секции '''INSTALLED_APPS''', которая отвечает за установленные в нашем проекте приложения. По умолчанию, команда
startproject создает проект с четырьмя предустановленными приложениями общего назначения:

INSTALLED_APPS = (
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.sites',
)

Каждое из них отвечает за свою специфическую область:

* '''django.contrib.auth''' – система аутентификации;
* '''django.contrib.contenttypes''' – каркас типов содержимого;
* '''django.contrib.sessions''' – работа с сессиями;
* '''django.contrib.sites''' – каркас, позволяющий управлять несколькими сайтами из одной установки ''Django''.

Хотя эти приложения и перечислены в '''INSTALLED_APPS''', они еще не установлены окончательно, так как для них не созданы таблицы в
базе данных. Для завершения инсталляции, выполните следующий
код:

python manage.py syncdb

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

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'''», а затем следуйте инструкциям, заполняя поля
имени, '''e-mail''' и пароля для суперпользователя. Вот теперь система
полностью установлена.

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

Перечисленные выше приложения ''Django'' – это, по сути, программы
''Python'', предназначенные для решения конкретной задачи. Например,
мы можем написать приложение-блог, которое будет создавать записи в личном интернет-дневнике, а также предоставлять другим пользователям возможность просматривать их. Для генерации нового приложения нужно просто скомандовать:

python manage.py startapp news

где '''news''' – имя нашего приложения; его-то мы и будем разрабатывать
на протяжении всех четырех уроков. Задача '''news''' достаточно стандартна: это публикация, просмотр и обсуждение новостей. По традиции, давайте начнем с изучения структуры нашего приложения:

news/
__init__.py
models.py
views.py

Как видно, оно состоит из трех файлов: '''__init__.py''', с которым
мы уже встречались выше, '''models.py''' – места для описания моделей
(схем таблиц в БД с некоторыми дополнительными данными) и '''views.py''', определяющего представления (код, который отвечает за логику
вашего приложения).

Работа с приложением обычно начинается с создания моделей,
поэтому откройте файл '''models.py''' в вашем любимом текстовом
редакторе и наберите следующий код:

from django.db import models
class News(models.Model):
title = models.CharField(max_length=70)
description = models.CharField(max_length=255)
pub_date = models.DateTimeField()
text = models.TextField()
class Comment(models.Model):
news = models.ForeignKey(News)
username = models.CharField(max_length=70)
text = models.TextField()
pub_date = models.DateTimeField(auto_now_add=True)

Мы создали две модели: первая ('''News''') отвечает за саму новость,
а вторая ('''Comment''') – за комментарии к ней.

Каждая модель (таблица, в терминах БД) представлена классом,
который наследуется от '''django.db.models.Model'''. Все поля представляются объектом класса '''models.*Field'''. Имя поля используется как
для создания столбцов в таблице БД, так и для доступа к данным
через ''Django ORM'', поэтому для упрощения чтения и написания кода
старайтесь давать полям осмысленные названия.

Начнем с поля '''title''' класса '''News'''. Запись '''models.CharField''' указывает на то, что это поле является символьным, а '''max_length=70''' говорит, что мы можем записать в него максимум 70 символов. Соответственно,
'''DateTimeField''' означает, что поле будет содержать дату в формате
'''DateTime''' (атрибут '''auto_now_add''' в '''pub_date''' в классе '''Comments''' указывает на то, что поле при создании записи будет автоматически заполняться текущим временем), '''TextField''' – это обычный текст.

Особое значение имеет '''ForeignKey''', который говорит, что поле
является внешним ключом (в связке «один-ко-многим») по отношению к модели (таблице) '''News'''. То есть, у каждого комментария
есть поле news, хранящее номер новости, к которой относится комментарий.

Теперь, когда модели созданы, приложение можно установить.
Этот процесс проходит в два этапа:

# Инициализация приложения в '''settings.py''' в разделе '''INSTALLED_APPS''';
# Создание таблиц в базе данных.

Откройте '''settngs.py''' и добавьте к '''INSTALLED_APPS''' строку ''''myproject.news''''. Заметьте, что '''INSTALLED_APPS''' – это кортеж ''Python'',
поэтому будьте внимательны с синтаксисом. Теперь перейдите в корень нашего проекта и наберите команду:

python manage.py syncdb

Она, как мы уже знаем, создаст необходимые таблицы в БД.

===Автогенерация «админки»===

{{Врезка|Содержание=[[Изображение:LXF105_88_1.jpg|Рис. 2|250px]]Рис. 2. Врата в административный раздел ''Django''. |Ширина=250px}}

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

Для того, чтобы подключить систему администрирования, нужно выполнить несколько шагов (в той очередности, в которой они представлены ниже):
# Добавить '''django.contrib.admin''' в '''INSTALLED_APPS''' вашего проекта.
# Выполнить ''python manage.py syncdb'' из корневого каталога проекта.
# Открыть myproject/urls.py и раскомментировать строку
# (r'^admin/', include('django.contrib.admin.urls')),

После этого запустите web-сервер (''python manage.py runserver'') и перейдите по адресу http://127.0.0.1:8000/admin/. Вы увидите форму авторизации для входа в систему администрирования:

{{Врезка|Содержание=[[Изображение:LXF105_88_2.jpg|Рис. 3|300px]]Рис. 3. Административный интерфейс ''Django''.|Ширина=300px}}

Введите имя и пароль суперпользователя, и – добро пожаловать
в «админку» ''Django''! На ее главной странице (рис.3) можно видеть
несколько областей:
* Вверху – панель приветствия, просмотра документации, изменения пароля и выхода из системы.
* Посередине слева – установленные приложения (название и модели) и действия, которые можно совершать с ними (добавление и изменение записей).
* Посередине справа – последние действия, которые были произведены в «админке».

Вы заметили, что нашего приложения '''news''' в нет списке (в журнале
этого не видно, но уж поверьте мне на слово)? Все правильно: просто
так приложения в нем не появляются – для этого нужно выполнить
несколько несложных действий. Откройте файл моделей ('''models.py''')
приложения news и добавьте в каждую модель подкласс.

class Admin:
pass

Сохраните файл моделей и перезагрузите страницу. Теперь наше
приложение должно быть доступно в «админке». Если бы мы использовали какой-то другой HTTP-сервер (например, ''Apache''), нам бы
пришлось бы перегружать его после каждого изменения в исходных
кодах. А это очень неудобно, особенно когда процесс разработки в
самом разгаре.

Ну что, добавим первую новость? Найдите на странице строку
'''Newss''' (это не опечатка – ''Django'' автоматически добавляет окончание
'''-s''' к именам моделей) и перейдите по ссылке '''Add'''. Откроется форма для
добавления новости:

Заполните все поля и нажмите кнопку '''Save''' [Сохранить]. Вы будете перенаправлены на страницу списка доступных новостей. Пока что он состоит из одной новости, которую мы только что добавили, но
как только их станет больше, возникнет одно неудобство: все новости
будут отображаться как '''News object''' [Объект класса News], и мы быстро
запутаемся, где какая. Чтобы видеть заголовок новости, изменим
'''models.py''' приложения '''news''', добавив в модель '''News''' следующий код:

{{Врезка|Содержание=[[Изображение:LXF105_88_3.jpg|Рис. 4|300px]]Рис. 4. Форма для добавления новостей.|Ширина=300px}}

def __unicode__(self):
return self.title

Обновите страницу – у новостей появятся осмысленные названия.
Давайте добавим еще одну новость, но на этот раз оставим поле '''Title'''
пустым, в поле '''Date''' напишем слово «дата», а в поле '''Time''' – «время»
и попробуем сохранить ее в базе. Что, ''Django'' ругается? И правильно делает – нечего оставлять поля пустыми. Обратите внимание, что
прочие поля (которые были введены верно) остались нетронутыми, и
вам осталось только исправить ошибки, а не заполнять форму заново, как это часто бывает на сайтах «средней руки».

===Публикация в сети===

Хорошо, создавать записи («объекты» в терминах ''Django ORM'') мы научились, а дальше-то что? Дальше нам надо разместить их на сайте – ведь
от новостей, которые никто не видит, нет пользы. Чтобы сделать это,
нужно опять пройти через несколько несложных этапов:

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

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

Начнем с представлений. Они, как мы знаем, хранятся в файле
'''views.py''' в корне каждого приложения. Перейдите в директорию '''news'''
и откройте файл '''views.py'''. Затем добавьте следующий код (разумеется,
номера строк приведены исключительно для удобства):

<source lang="python">
from datetime import datetime
from django.template.loader import get_template
from django.http import HttpResponse
from django.template import RequestContext

from news.models import News

def last_news(request):
news = News.objects.filter(
pub_date__lte=datetime.now()).order_by(«-pub_date»)[:10]
template = get_template(“news/last_news.html”)
context = RequestContext(request, {
“last_news”:news,
})
return HttpResponse(template.render(context))
</source>

Первые четыре строчки загружают необходимые функции и классы:
* '''datetime''' – тип для работы с датой и временем;
* '''get_template''' – функция, которая ищет и возвращает шаблон;
* '''HttpResponse''' – основной HTTP ответ;
* '''RequestContext''' – специальный класс, с помощью которого можно определять переменные, используемые в шаблонах.

Далее (строка 6) происходит импорт класса модели наших новостей. С
его помощью мы получаем доступ к ''Django ORM'', и, следовательно, к объектам в нашей базе данных.

Функция '''last_news''' – это и есть представление. Заметьте, что она принимает обязательный аргумент '''request''', через который передаются параметры HTTP-запроса.

Что же происходит при вызове '''last_news'''? Сначала мы извлекаем
объекты из базы данных (строки 9–10). Конструкция '''filter''' ограничивает
выборку по какому-то условию, в нашем случае '''pub_date__lte=datetime.now()''' означает, что дата публикации новостей должна быть меньше или
равна ('''lte''' – «less than or equal to») текущей дате ('''datetime.now()'''). Это
позволит нам создавать новости «на будущее», и они не будут отображаться на сайте до тех пор, пока дата их публикации не станет раньше или
равной текущей. '''order_by''' – сортирует записи по определенному столбцу,
в нашем случае – '''pub_date''', а знак минус означает, что сортировка будет
произведена в обратном порядке. И наконец '''[:10]''' – срез, который указывает, что извлекать нужно только 10 последних записей.

В строке 11 мы получаем объект шаблона, передавая в функцию
'''get_template''' путь до него. Строки 12–14 отвечают за наполнение наших
шаблонов какими-то данными, причем мы передаем в шаблон весь HTTP-
запрос (request) и извлеченные новости (на самом деле, они еще даже
не извлечены: просто создан объект, с помощью которого новости будут
получены при первом обращении к ним). Обратите внимание, что данные
передаются в шаблон с помощью словаря, где ключ – это имя переменной,
которая будет доступна в шаблоне, а значение – ее значение.

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

===Шаблоны===

Для начала подготовим базовый шаблон – '''index.html'''. Создадим в корне
нашего проекта каталог media для хранения статичных файлов (изображений, шаблонов, стилей и т.д.), а уже в '''media''' – подкаталог '''templates''', в
который и поместим файл '''index.html''' со следующим содержимым:

<html>
<head><title>My site</title></head>
<body>
<nowiki><a href=“/news/”>News</a><br/></nowiki>
{% block application %}
Welcome to site.
{% endblock %}
</body>
</html>

Шаблон – это обычный текстовый файл, содержащий специальные
конструкции языка шаблонов ''Django''. В '''index.html''' содержится только одна
конструкция, которая определяет блок '''application''' (строки 6-8). Она называется «тэгом», причем тэг начинается с '''{%''', а заканчивается '''%}'''. Внутри
этого блока находится приветствие, как это часто бывает на сайтах. ''Django''
еще не знает, где искать шаблон, поэтому откроем '''settings.py''', найдем кортеж '''TEMPLATE_DIRS''' и добавим в него строку '''/path/to/project/myproject/media/templates/''', где '''/path/to/project''' – путь до вашего проекта; у меня
это '''/var/www'''.

{{Врезка|Заголовок=Скорая помощь|Содержание=Если вы не увидели ни одной новости (при условии, что они были добавлены), то скорее всего, вы не попали в нужный часовой пояс. Когда мы вызываем функцию '''datetime.now()''', она возвращает время относительно часового пояса, заданного в переменной
'''TIME_ZONE''' в файле '''settings.py'''. По умолчанию в нем содержится '''America/Chicago'''. Все, что вам нужно – это изменить значение на название вашего часового пояса на английском, например, на '''Asia/Krasnoyarsk'''. Cписок часовых поясов можно найти в директории '''/usr/share/zoneinfo/'''
в файле '''zone.tab'''. |Ширина=200px}}

Теперь, когда базовый шаблон готов, перейдем к шаблону новостей.
Опять же, создадим в директории нашего приложения ('''news''') каталог
'''templates''', внутри '''templates''' создадим каталог '''news''', а в '''templates/news'''
добавим файл '''last_news.html'''. Заметьте, что имя файла шаблона совпадает с именем представления, к которому оно относится. Так делать не
обязательно – это просто правило хорошего стиля.

Сам файл '''last_news.html''' может иметь следующий вид:
<source lang="python">
{% extends “index.html” %}

{% block application %}
{% for news in last_news %}
<nowiki>[{{ news.pub_date|date:»d.m.Y»}}]</nowiki>
<nowiki><strong>{{ news.title }}</strong></nowiki>
<nowiki><p>{{ news.description }}</p></nowiki>
{% endfor %}

{% endblock %}
</source>
Первая строка означает, что шаблон новости расширяет шаблон '''index.html'''. В строке 3 мы открываем блок '''application''' (он, как вы помните,
идет из '''index.html''') и переопределяем его. В строках 5–8 мы создаем цикл
по объектам '''last_news''' (которые были переданы в шаблон из нашего представления). В строках 6–8 мы вставляем данные, относящиеся к каждой
новости, из '''last_news'''. Помимо тэгов, в шаблоны можно помещать переменные, имена которых будут заменены их значениями. Для этого используется конструкция '''<nowiki>{{ имя_переменной }}</nowiki>'''. В строке 7 мы обращаемся
к переменной '''news''', но каждая новость имеет несколько полей (в соответствии с тем, что мы определили в '''models.py'''), поэтому мы указываем
конкретное поле – '''title''', что в конечном счете выведет заголовок новости.
Особое внимание нужно обратить на запись в строке 6, где мы не просто
обращаемся к дате публикации новости '''news.pub_date''', но и применяем
фильтр форматирования '''|date:«d.m.Y»''', который позволяет вывести дату
в более традиционном для России виде.

Последнее, что нам осталось – это связать URL с представлением.
Откроем '''urls.py''' и после строки

(r'^admin/', include('django.contrib.admin.urls')),

добавим

(r'^news/', 'news.views.last_news').

Данный код означает, что при переходе к http://www.mydomain.ru/news/ будет выполняться представление '''news.views.last_news'''.

Затем допишите в самый конец файла

urlpatterns += patterns('django.views.generic.simple',
(r'^$','direct_to_template', {'template': 'index.html'}),)

Эта запись говорит, что при обращении к корню сервера должен
использоваться шаблон '''index.html'''.

Ну все, наш сайт готов. Запустите сервер разработчика и перейдите в
вашем браузере по адресу http://127.0.0.1:8000/. Кликните по ссылке '''News'''
и получите самые свежие новости! '''LXF'''