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

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

Материал из Linuxformat
Версия от 15:56, 2 ноября 2018; Olkol (обсуждение | вклад)

(разн.) ← Предыдущая | Текущая версия (разн.) | Следующая → (разн.)
Перейти к: навигация, поиск
Подписка на печатную версию
Весь 2015 год (12 номеров)
Первое полугодие (6 номеров)
Второе полугодие (6 номеров)
Подписка на электронную версию
Весь 2015 год (12 номеров)
Первое полугодие (6 номеров)
Второе полугодие (6 номеров)
Подшивки старых номеров журнала (печатные версии)
Весь 2014 год (12 номеров)
Первое полугодие (6 номеров)
Второе полугодие (6 номеров)

Кар­кас для 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 под­дер­жи­ва­ет мно­же­ст­во раз­лич­ных СУБД (в том чис­ле 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 нам это не по­на­до­бит­ся: в нем есть соб­ст­вен­ный ин­тер­фейс для управ­ления ба­зой дан­ных, до­бав­лением и уда­лением дан­ных и дру­гих дей­ст­вий. Он встро­ен в ваш про­ект.

Что­бы вклю­чить ин­тер­фейс ад­минист­ра­то­ра, нуж­но за­дать кое-ка­кие на­строй­ки. Во-пер­вых, нуж­но на­стро­ить 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.

Для на­ча­ла от­кро­ем 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 вы смо­же­те соз­да­вать лю­бые при­ло­жения, ка­кие вам толь­ко по­на­до­бят­ся. На­сла­ж­дай­тесь! |

Источник — «http://wiki.linuxformat.ru/wiki/index.php?title=LXF165-166:_Web-%D1%80%D0%B0%D0%B7%C2%AD%D1%80%D0%B0%C2%AD%D0%B1%D0%BE%D1%82%C2%AD%D0%BA%D0%B0:_Django&oldid=19138»
Персональные инструменты
купить
подписаться
Яндекс.Метрика