Журнал LinuxFormat - перейти на главную

LXF165-166: Web-раз­ра­бот­ка: Django

Материал из Linuxformat
Перейти к: навигация, поиск

Кар­кас для web-при­ло­же­ний Вы­сво­бо­ди­те всю мощь это­го фрейм­вор­ка на Python

Содержание

Django: Пер­вый ваш web-опыт

Джо­но Бэ­кон объ­яс­ня­ет, как на­чать ра­бо­ту, и при­гла­ша­ет нас про­ехать­ся на Ferrari фрейм­вор­ков для web-при­ло­же­ний... Django.

(thumbnail)
Наш эксперт Джо­но Бэ­кон – ме­нед­жер со­об­ще­ст­ва Ubuntu, ав­тор кни­ги «Ис­кус­ст­во со­об­ще­ст­ва» и ос­но­ва­тель еже­год­но­го сам­ми­та ру­ко­во­ди­те­лей со­об­ще­ст­ва.

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

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

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

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

На­чи­на­ем

Ус­та­нов­ку Django я под­роб­но опи­сы­вать не бу­ду; в ва­шем ди­ст­ри­бу­ти­ве долж­ны быть со­от­вет­ст­вую­щие па­ке­ты (на­при­мер, в Ubuntu мож­но уста­но­вить python-django). Ес­ли у вас его нет и вы не хо­ти­те во­зить­ся с до­воль­но ви­тие­ва­тым на­бо­ром за­ви­си­мо­стей, за­гру­зи­те от­лич­ный стек Bitnami, с уже на­стро­ен­ным Django, с сай­та http://bitnami.org/stack/djangostack.

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

django-admin.py startproject pawnstore

Соз­на­юсь че­ст­но: мне бе­зум­но нра­вит­ся реа­ли­ти-шоу “Pawn Stars [Звез­ды за­кла­да]” (оно рас­ска­зы­ва­ет о труд­но­стях и ис­пы­таниях од­но­го лом­бар­да в Лас-Ве­га­се). Вот мы и на­пи­шем web-при­ло­жение для управ­ления лом­бар­дом. Здесь ко­ман­дой django-admin мы соз­да­ли но­вый про­ект ‘pawnstore’ [ломбард].

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

Пре­ж­де чем соз­да­вать на­ше пер­вое при­ло­жение, следует немно­го на­стро­ить про­ект. Внут­ри соз­дан­но­го про­ек­та ‘pawnstore’ вы ви­ди­те под­ка­та­лог pawnstore. В нем есть файл settings.py с па­ра­мет­ра­ми все­го про­ек­та. От­крой­те его, и да­вай­те сна­ча­ла вы­бе­рем ба­зу дан­ных, ко­то­рой мы хо­тим поль­зо­вать­ся.

Уз­най­те боль­ше

Ес­ли вы заинтересовались Django и хо­ти­те уз­нать о нем под­роб­нее, обя­за­тель­но зай­ди­те на за­ме­ча­тель­ный сайт про­ек­та и по­читай­те фан­та­сти­че­скую до­ку­мен­та­цию. Мир Django дос­ту­пен на www.djangoproject.com.

Django под­дер­жи­ва­ет мно­же­ст­во раз­лич­ных СУБД (в том чис­ле SQLite, MySQL, PostgreSQL и Oracle). Про­сто­ты ра­ди, восполь­зу­ем­ся SQLite; эта про­стая ба­за дан­ных хранит­ся в фай­ле на ва­шем ком­пь­ю­те­ре. Для это­го най­ди­те стро­ку ‘ENGINE’ и до­бавь­те в нее sqlite3. Она долж­на вы­гля­деть так:

‘ENGINE’: ‘django.db.backends.sqlite3’,

Так­же нуж­но за­дать имя ба­зы дан­ных. До­бавь­те сле­дую­щую стро­ку:

‘NAME’: ‘pawnstore.db’,

Вве­дя все на­строй­ки, мож­но соз­дать пер­вое при­ло­жение в про­ек­те. Мы соз­да­дим при­ло­жение Django для управ­ления спи­ском то­ва­ров лом­бар­да и на­зо­вем его ‘inventory’. Для соз­дания при­ло­жения мы спер­ва восполь­зу­ем­ся скрип­том manage.py (в ка­та­ло­ге верхнего уров­ня pawnstore). Этот скрипт – наш швей­цар­ский ар­мей­ский нож в управ­лении про­ек­том. В дальней­шем мы бу­дем поль­зо­вать­ся им все ча­ще и ча­ще.

Что­бы соз­дать при­ло­же­ние, вы­пол­ни­те ко­ман­ду

python manage.py startapp inventory

Она соз­даст но­вый ка­та­лог inventory. Те­перь при­сту­пим к соз­данию при­ло­жения.

Соз­да­ем ба­зу дан­ных

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

Внут­ри ка­та­ло­га inventory есть файл models.py. В этот файл мож­но до­ба­вить клас­сы Python с опи­санием струк­ту­ры дан­ных на­ше­го при­ло­жения для управ­ления пе­речнем то­ва­ров. Мы по-про­сто­му соз­да­дим две таб­ли­цы: Categories [ка­те­го­рии] и Items [то­ва­ры]. Ка­ж­дый то­вар от­но­сит­ся к какой-либо ка­те­го­рии.

Что­бы до­ба­вить упомянутые таб­ли­цы, впи­ши­те сле­дую­щий код в models.py:

class Category(models.Model):

name = models.CharField(max_length=200)

class Item(models.Model):

category = models.ForeignKey(Category)

dateadded = models.DateTimeField(‘date added’)

name = models.CharField(max_length=200)

description = models.TextField()

quantity = models.IntegerField()

Здесь ка­ж­дый класс со­от­вет­ст­ву­ет сво­ей таб­ли­це в на­шей про­грам­ме, а ка­ж­дая пе­ре­мен­ная клас­са с по­мо­щью функ­ции Django опи­сы­ва­ет тип по­ля с дан­ны­ми. На­при­мер, dateadded в клас­се Item име­ет тип DateTimeField, по­это­му Django бу­дет хранить дан­ные по­ля в фор­ма­те да­ты, а в неко­то­рых слу­ча­ях, когда поль­зо­ва­те­лю нуж­но вве­сти да­ту, вы­во­дить ка­лен­дарь для вы­бо­ра да­ты. Дру­гой при­мер – по­ле ‘name’, его тип CharField; это тек­сто­вая стро­ка, и дан­ные это­го по­ля обыч­но вво­дят­ся в од­но­строч­ное тек­сто­вое по­ле, в от­ли­чие от TextField, с ко­то­рым обыч­но ис­поль­зу­ет­ся мно­го­строч­ное тек­сто­вое по­ле.

Схе­ма на­шей ба­зы дан­ных соз­да­на; те­перь с ее по­мо­щью сгенери­ру­ем ба­зу дан­ных. Для это­го ско­ман­дуй­те

python manage.py syncdb

Тут вам за­да­дут несколь­ко во­про­сов. На во­прос, хо­ти­те ли вы соз­дать су­пер­поль­зо­ва­те­ля, от­веть­те «да» и за­дай­те имя поль­зо­ва­те­ля и па­ро­ль. За­тем вы долж­ны вер­нуть­ся в команд­ную стро­ку. Ба­за дан­ных соз­да­на успеш­но. За­пустим наш про­ект и по­смот­рим, как он вы­гля­дит. Для удоб­но­го про­смот­ра про­ек­та в Django есть встро­ен­ный web-сер­вер. За­пустит его ко­ман­да

python manage.py runserver

За­пусти­те брау­зер и от­крой­те ад­рес http://127.0.0.1:8000/, что­бы про­смот­реть про­ект. Вы долж­ны уви­деть текст о «пер­вом при­ло­жении на Django», вы­полнен­ный стан­дарт­ным шриф­том. Хо­тя это не слиш­ком впе­чат­ля­ет, но сдвиг есть! Кста­ти, оста­но­вить сер­вер мож­но, на­жав Ctrl + C.

Ин­тер­фейс ад­минист­ра­то­ра

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

Не по­вто­ряй се­бя

За соз­данием Django сто­ит мно­же­ст­во прин­ци­пов. Соз­да­те­ли про­ек­та при­ло­жи­ли мно­же­ст­во уси­лий для мак­си­маль­но­го во­пло­щения прин­ци­па DRY («Не по­вто­ряй се­бя» – Don’t Repeat Yourself). Об­щая его идея в том, что в ко­де не нуж­но по­вто­рять­ся, а ес­ли вы по­вто­ряе­тесь, зна­чит, де­лае­те что-то неправильно. Это осо­бен­но спра­вед­ли­во для Django, раз­ра­бот­чи­ки ко­то­ро­го при­ло­жи­ли мас­су уси­лий, что­бы умень­шить та­кие по­вто­рения. Всегда ста­рай­тесь поль­зо­вать­ся этим прин­ци­пом в сво­их про­ек­тах; оп­ре­де­ляй­те код один раз и ис­поль­зуй­те его многократно.

Что­бы вклю­чить ин­тер­фейс ад­минист­ра­то­ра, нуж­но за­дать кое-ка­кие на­строй­ки. Во-пер­вых, нуж­но на­стро­ить URL. Об­су­дим URL’ы в Django в об­щем слу­чае. В ка­ж­дом про­ек­те Django есть файл urls.py. Его мож­но най­ти в под­ка­та­ло­ге про­ек­та (у нас – pawnstore). Этот файл со­дер­жит спи­сок URL-ад­ре­сов, рас­по­зна­вае­мых про­ек­том, в ви­де ре­гу­ляр­ных вы­ра­жений. Ад­ре­са мож­но за­тем свя­зать с раз­лич­ны­ми при­ло­жения­ми про­ек­та. Под­робнее об этом поз­же.

В фай­ле долж­на присутствовать сле­дую­щая стро­ка, которую нуж­но рас­ком­мен­ти­ро­вать:

url(r’^admin/’, include(admin.site.urls)),

За­од­но рас­ком­мен­ти­руй­те та­кие стро­ки в на­ча­ле фай­ла:

from django.contrib import admin

admin.autodiscover()

Так мы вклю­чим ин­тер­фейс ад­минист­ра­то­ра в на­шем про­ек­те; но что­бы он под­дер­жи­вал­ся, нуж­но еще од­но неболь­шое из­менение. От­крой­те файл settings.py и рас­ком­мен­ти­руй­те сле­дую­щую стро­ку в раз­де­ле INSTALLED_APPS:

‘django.contrib.admin’,

Еще до­бавь­те стро­ку

‘inventory’,

Раз­дел INSTALLED_APPS в settings.py опи­сы­ва­ет раз­лич­ные при­ло­жения в про­ек­те, го­то­вые для ис­поль­зо­вания; од­но из них – ин­тер­фейс ад­минист­ра­то­ра, дру­гое – на­ше основ­ное при­ло­жение ‘inventory’.

Опять за­пус­тим сер­вер:

python manage.py runserver

За­тем от­крой­те ад­рес http://127.0.0.1:8000/admin/, и долж­на от­крыть­ся фор­ма для вхо­да в ин­тер­фейс ад­минист­ра­то­ра. Вве­ди­те имя поль­зо­ва­те­ля и па­роль – и поя­вит­ся глав­ный ин­тер­фейс.

К со­жа­лению, таб­лиц, ко­то­рые мы соз­да­ли ранее (Categories и Items) здесь нет – толь­ко Groups [груп­пы], Users [поль­зо­ва­те­ли] и Sites [сай­ты]. При­чи­на в том, что хо­тя мы вклю­чи­ли ин­тер­фейс ад­минист­ра­то­ра, мы еще не пре­доста­ви­ли ин­тер­фей­су пра­ва досту­па для ре­дак­ти­ро­вания на­ших таб­лиц. Для это­го в ка­та­ло­ге inventory нуж­но соз­дать файл admin.py и до­ба­вить в него сле­дую­щие стро­ки:

from django.contrib import admin

from inventory.models import Category, Item

admin.site.register(Category)

admin.site.register(Item)

За­тем пе­ре­за­пусти­те сер­вер и пе­ре­за­гру­зи­те ин­тер­фейс ад­минист­ра­то­ра. В нем поя­вят­ся две но­вых таб­ли­цы, как на рис. 1. Восполь­зу­ем­ся этим и до­ба­вим немно­го дан­ных. Во-пер­вых, до­ба­вим ка­кую-нибудь ка­те­го­рию. Щелкните по таб­ли­це Categories (за­меть­те, что к на­званию ка­ж­дой таб­ли­цы до­бав­ля­ет­ся окон­чание ‘s’ для мно­же­ст­вен­но­го чис­ла... как ми­ло!) и за­тем на кноп­ку Add Category [До­ба­вить ка­те­го­рию] в пра­вом верхнем уг­лу. По­сле это­го ука­жи­те на­звание ка­те­го­рии и на­жми­те кноп­ку Save [Со­хранить].

Те­перь до­ба­вим то­вар [Item]. Вернитесь на до­маш­нюю страницу и щелкните по таб­ли­це Items. На­жми­те кноп­ку Add Item [До­ба­вить то­вар] и об­ра­ти­те внимание, что фор­мы для по­лей раз­лич­ных ти­пов, ко­то­рые мы до­ба­ви­ли в мо­дель ба­зы дан­ных, вы­гля­дят по-раз­но­му (от­час­ти по­это­му важ­но за­да­вать тип по­ля пра­виль­но). С по­мо­щью этой фор­мы мож­но до­ба­вить то­вар в ба­зу дан­ных.

Од­на из про­блем, ко­то­рую вы, воз­мож­но, за­ме­ти­ли, состоит в том, что в вы­па­даю­щем спи­ске Category [Ка­те­го­рия] не ото­бра­жа­ет­ся ранее до­бав­лен­ная ка­те­го­рия. Вме­сте это­го мы ви­дим там об­щий объ­ект ‘category’. Это лег­ко ис­пра­вить.

При­чи­на, по ко­то­рой это про­ис­хо­дит, в том, что мы не за­да­ли по­ле по умол­чанию, ко­то­рое воз­вра­ща­ет­ся при об­ра­щении к клас­су в це­лом. Нам нуж­но ска­зать, что когда за­пра­ши­ва­ет­ся объ­ект Category, нуж­но вер­нуть за­дан­ное по­ле, ес­ли не за­пра­ши­ва­ет­ся ка­кое-то дру­гое по­ле. Сде­ла­ем этим по­лем ‘name’, до­ба­вив сле­дую­щий код по­сле клас­са Category в models.py:

def __unicode__(self):

return self.name

А те­перь раз­за­до­рим­ся и до­ба­вим в на­шу ба­зу по­боль­ше дан­ных. В ка­ж­дой ка­те­го­рии долж­но быть не мень­ше трех то­ва­ров. На­при­мер, я до­ба­вил ка­те­го­рию ‘Watches [Ча­сы]’ и ско­пи­ро­вал и вста­вил несколь­ко опи­саний с eBay.

Соз­да­ем ви­ды

Наш сле­дую­щий шаг – по­лу­чить дан­ные из ба­зы и ото­бра­зить их на web-странице. Для это­го мы соз­да­дим несколь­ко спо­со­бов (ви­дов, views) для про­смот­ра на­ших дан­ных.

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

url(r’^inventory/$’, ‘inventory.views.index’),

Эта стро­ка со­об­ща­ет Django, что ес­ли URL за­кан­чи­ва­ет­ся на ‘inventory’ (на­при­мер, http://127.0.0.1:8000/inventory/), то нуж­но за­гру­зить для него страницу inventory.views.index. Что та­кое inventory.views.index? Так и ду­мал, что спро­си­те! Сей­час объ­яс­ню...

При за­груз­ке страницы Django за­гля­ды­ва­ет в urls.py и смот­рит, нет ли там стро­ки, ко­то­рой со­от­вет­ст­ву­ет URL. Ес­ли есть, за­гру­жа­ет­ся со­от­вет­ст­вую­щий вид. Вид – это про­сто функ­ция, ко­то­рая генери­ру­ет дан­ные, необ­хо­ди­мые для ото­бра­жения со­дер­жи­мо­го страницы. Все ви­ды опи­са­ны в views.py (несколь­ко ви­дов в од­ном фай­ле).

Те­перь соз­да­дим вид. От­крой­те views.py и до­бавь­те сле­дую­щий код:

from inventory.models import Item

from django.shortcuts import render_to_response

def index(request):

latest_item_list = Item.objects.all().order_by(‘-dateadded’) [:5]

return render_to_response(‘inventory/index.html’, {‘latest_item_list’: latest_item_list})

В приведенном фраг­мен­те ко­да мы соз­да­ем функ­цию index(). Имя этой функ­ции ссы­ла­ет­ся на ‘index’ в inventory.views.index из на­ше­го фай­ла urls.py. В сле­дую­щей стро­ке мы по­лу­ча­ем все то­ва­ры из таб­ли­цы Items и сор­ти­ру­ем их в об­рат­ном по­ряд­ке (это де­ла­ет вы­зов пе­ред -dateadded), а за­тем по­ме­ща­ем их в пе­ре­мен­ную latest_item_list. В сле­дую­щей стро­ке мы вы­зы­ва­ем функ­цию Django render_to_response(), ко­то­рая от­прав­ля­ет их шаб­ло­ну inventory/index.html. Давайте же теперь раз­бе­рем­ся, что это та­кое – шаб­ло­ны.

Шаб­ло­ны

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

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

Что­бы приступить к ра­бо­те с шаб­ло­на­ми, соз­да­дим ка­та­лог templates в на­шем про­ек­те. В нем соз­дай­те под­ка­та­лог inventory, а там – файл index.html. Пре­ж­де чем соз­да­вать шаб­лон, нуж­но ска­зать Django, где на­хо­дят­ся шаб­ло­ны. До­бавь­те в файл settings.py пол­ный и аб­со­лют­ный путь к ним в раз­де­ле TEMPLATE_DIRS. На­при­мер:

TEMPLATE_DIRS = (

“/home/jono/pawnstore/templates”,

)

Внут­ри ка­та­ло­га templates/inventory дол­жен быть файл index.html. До­бавь­те в не­го та­кой код:

Latest Items

{% if latest_item_list %}

{% else %}

No items are available.

{% endif %}

В этом фай­ле ис­поль­зу­ет­ся осо­бая раз­мет­ка, ко­то­рую Django пре­об­ра­зу­ет в обыч­ный HTML при за­груз­ке шаб­ло­на. Об­ра­тив­шись к шаб­ло­ну в views.py, мы пе­ре­да­ли ему дан­ные в latest_item_list. За­тем ис­поль­зу­ют­ся обыч­ные опе­ра­то­ры: if, for и else в бло­ках { % %} для ото­бра­жения дан­ных в со­от­вет­ст­вии с те­ми или ины­ми усло­вия­ми. От­ме­тим, что мы соз­да­ли ссыл­ку, к ко­то­рой до­бав­ля­ет­ся иден­ти­фи­ка­тор то­ва­ра (на­при­мер, http://127.0.0.1:8000/inventory/3/) – та­кой фор­мат URL мож­но ис­поль­зо­вать для ото­бра­жения под­роб­ной ин­фор­ма­ции о то­ва­ре при щелч­ке на нем. Наш шаб­лон в дей­ст­вии мож­но уви­деть на рис. 2.

Об­ра­бот­ка форм

Уве­рен, что мно­гие из вас за­хо­тят пой­ти даль­ше и уз­нать, как вы­во­дить фор­мы и об­ра­ба­ты­вать дан­ные, вве­ден­ные поль­зо­ва­те­лем в форму. Более под­роб­ную ин­фор­ма­цию об этом мож­но най­ти по ссыл­ке https://docs.djangoproject.com/en/dev/topics/forms.

Для на­ча­ла от­кро­ем urls.py и до­ба­вим стро­ку для за­груз­ки но­вой страницы на тот слу­чай, когда в кон­це ад­ре­са пе­ре­да­ет­ся иден­ти­фи­ка­тор то­ва­ра (на­при­мер, http://127.0.0.1:8000/inventory/3/):

url(r’^inventory/(?P<item_id>\d+)/$’, ‘inventory.views.detail’),

Здесь фор­мат URL за­да­ет­ся ре­гу­ляр­ным вы­ра­жением, и ес­ли ад­рес со­от­вет­ст­ву­ет ему, мы за­гру­жа­ем вид ‘detail’. Важ­но от­ме­тить, что чис­лу в кон­це ад­ре­са в этой стро­ке со­от­вет­ст­ву­ет пе­ре­мен­ная item_id. Мы ссы­ла­ем­ся на нее на этой странице.

Те­перь до­ба­вим сле­дую­щую функ­цию в наш файл views.py:

def detail(request, item_id):

item = Item.objects.get(pk=item_id)

return render_to_response(‘inventory/detail.html’, {‘item’:item})

Здесь вы ви­ди­те, как пе­ре­мен­ная item_id пе­ре­да­ет­ся функ­ции, в ко­то­рой с по­мо­щью функ­ции Django get() про­ве­ря­ет­ся со­от­вет­ст­вие этой пе­ре­мен­ной пер­вич­но­му клю­чу то­ва­ра (pk). За­тем для пе­ре­да­чи осталь­но­го шаб­ло­на мы вы­зы­ва­ем все ту же функ­цию render_to_response().

Те­перь соз­дай­те файл detail.html в ка­та­ло­ге templates/inventory и до­бавь­те в него сле­дую­щий код:

{% if item %}

Шаблон:Item.name

Category: Шаблон:Item.category

Description: Шаблон:Item.description

Quantity: Шаблон:Item.quantity

{% else %}

No items are available.

{% endif %}

Здесь мы про­сто вы­во­дим все по­ля. Те­перь мож­но щелк­нуть на эле­мен­те спи­ска и по­лу­чить под­роб­ную ин­фор­ма­цию о нем, как по­ка­за­но на рис. 3.

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

Персональные инструменты
купить
подписаться
Яндекс.Метрика