”Den här artikeln är reviderad och uppdaterad med den senaste versionen av Django - maj 2016”
I Del 1 i den här serien lärde du dig hur du installerar och konfigurerar Django i en virtuell miljö och du skapade skelettet för ditt första projekt.
Sedan i Del 2 vi skapade en applikation och en modell för Posta objekt, som vi senare migrerade till databasen. Slutligen visade vi dig hur du integrerar din nyskapade applikation i Django -användargränssnittet.
Dessa artiklar är en del av Django -serien:
Installera och konfigurera Django Web Framework med virtuella miljöer - Del 1
Granska grunderna i Python och skapa din första webbapplikation med Django - Del 2
I den här sista guiden kommer vi att diskutera hur du får åtkomst till programmet med användargränssnittet och hur du gör det mobilvänligt för alla typer av enheter. Som sagt, låt oss komma igång.
För att skapa objekt av typ Posta (kom ihåg att det är modellen vi definierade i
Del 2 i denna serie) kommer vi att använda Django -administratörsgränssnittet.Se till att den inbyggda Django-webbservern körs på porten 8000 (eller en annan du väljer) genom att köra följande kommando från utsidan myfirstdjangoproject katalog:
# cd ~/myfirstdjangoenv/myfirstdjangoproject. # python manage.py körserver 0.0.0.0:8000.
Öppna nu din webbläsare och peka på http://ip-address: 8000/admin
, logga sedan in med de referenser du ställde in i föregående artikel och börja skriva ett inlägg (vilket igen skapar ett objekt av typ Posta och infoga tillhörande data i den underliggande databasen):
Upprepa processen 2 eller 3 gånger:
Efter att vi har skapat ett par inlägg, låt oss se vad vi behöver göra för att visa dem med vår webbläsare.
Vår första vy (~/myfirstdjangoenv/myfirstdjangoproject/myblog/views.py) kommer att ansvara för att filtrera alla Posta objekt och returnerar de där värdet av när publicerad är mindre än eller lika med aktuellt datum och tid (whenPublished__lte = timezone.now ()) beställt genom att sjunka när publicerad, vilket är detsamma som att säga ”senaste först“.
Dessa objekt sparas i en variabel som bekvämt heter inlägg och returneras (identifieras som alla inlägg) för att vara inbäddad i HTML, som vi kommer att se i nästa avsnitt:
från django.shortcuts import render. från .modeller import Post. från django.utils importera tidszon. def posts (request): posts = Post.objects.filter (whenPublished__lte = timezone.now ()). order_by ('-whenPublished') return render (request, 'myblog/posts.html', {'allposts': posts} )
Slutligen understryker den dubbla in närPublished__lte
ovan används för att separera ett databasfält (när publicerad) från ett filter eller en operation (lte = mindre än eller lika).
När vi har definierat vår ursprungliga vy, låt oss arbeta med den associerade mallen.
Efter de direktiv och vägar som anges i föregående avsnitt kommer vi att lagra vår första mall inuti myblog/mallar/myblog. Det betyder att du måste skapa en katalog som heter mallar och en underkatalog som heter min blogg:
# cd ~/myfirstdjangoenv/myfirstdjangoproject/myblog. # mkdir -p mallar/myblog.
Vi kommer att kalla mallen posts.html
och sätt in följande kod i den. Du kommer att märka att vi lägger till online -referenser till jQuery, Bootstrap, FontAwesome och Google -teckensnitt.
Dessutom har vi bifogat Python -kod inuti lockiga parenteser inuti HTML -koden. Observera att för varje objekt av typen Post kommer vi att visa dess titel, dess publicerade datum och författare, och slutligen dess text. Slutligen kommer du i rött att se att vi refererar till objekten som returneras via myblog/views.py:
Ok, här är posts.html fil:
Min blogg
{ % för inlägg i allposts %}{ % endfor %}{{ Post titel }}Publicerad på {{post.whenPublished}} av {{post.author}}.{{post.text | linjeavbrott}}
I ovanstående mall, radbrytningar filter används för att ersätta radbrytningar i vanlig text med motsvarande HTML -ekvivalent (
eller
Därefter måste vi skapa en kartläggning mellan webbadresser i vår applikation och motsvarande vyer som returnerar data. För att göra det, skapa en fil med namnet urls.py inuti min blogg med följande innehåll:
från django.conf.urls import url. från. importera vyer. urlpatterns = [url (r '^$', views.posts, name = 'posts'),]
De r '^$'
förtjänar lite mer förklaring. Ledningen r
instruerar Django att behandla strängen inuti enskilda citattecken som ett vanligt uttryck.
Särskilt, r '^$'
representerar en tom sträng så att när vi riktar vår webbläsare till http://ip-address: 8000
(och ingenting annat), data som returneras av variabeln inlägg inuti views.py
(se föregående avsnitt) kommer att presenteras på vår hemsida:
Sist men inte minst kommer vi att inkludera urls.py filen för vår bloggapplikation (~/myfirstdjangoenv/myfirstdjangoproject/myblog/urls.py) in i urls.py av vårt huvudprojekt (~/myfirstdjangoenv/myfirstdjangoproject/myfirstdjangoproject/urls.py):
från django.conf.urls import inkluderar, url. från django.contrib import admin urlpatterns = [url (r '^admin/', inkludera (admin.site.urls)), url (r '', include ('myblog.urls')),]
Låt oss sedan starta webbservern:
# cd ~/myfirstdjangoenv/myfirstdjangoproject. # python manage.py körserver 0.0.0.0:8000.
Vi borde nu kunna se listorna med inlägg vi skapade tidigare:
Tack vare Bootstrap, kan du fortfarande ha en utmärkt visualisering i en mindre enhet:
Låt oss nu granska de begrepp som vi har täckt i den här artikeln och i hela denna serie:
1. Varje modell definierar ett objekt och kartlägger till en databastabell, vars fält i sin tur mappar till objektets egenskaper. Å andra sidan, a mall definierar användargränssnittet där data som returneras av vyn kommer att visas.
Låt oss säga att vi vill ändra vår modell genom att lägga till ett fält med namnet sammanfattning till Posta objekt, där vi kommer att lagra en valfri kort beskrivning av varje inlägg. Låt oss lägga till följande rad myblog/models.py:
sammanfattning = modeller. CharField (max_length = 350, blank = True, null = True)
Som vi lärde oss i föregående artikel måste vi migrera ändringarna till databasen:
# python manage.py gör migreringsblogg. # python manage.py migrerar minblogg.
Använd sedan administratörsgränssnittet för att redigera inläggen och lägga till en kort sammanfattning till varje inlägg. Slutligen ersätt följande rad i mallen (posts.html):
{{post.text | linjeavbrott}}
med
{{post.summary}}
Uppdatera hemsidan för att se ändringarna:
2. A se funktion tar en HTTP -begäran och returnerar ett HTTP -svar. I den här artikeln, def -inlägg (begäran) i views.py ringer till den underliggande databasen för att hämta alla inlägg. Om vi vill hämta alla inlägg med ordet ansible i titeln, bör vi ersätta.
posts = Post.objects.filter (whenPublished__lte = timezone.now ()) .order_by ('-whenPublished')
med
posts = Post.objects.filter (title__icontains = "ansible") .order_by ('-whenPublished')
Genom att skilja användargränssnittet från applikationslogiken i webbapplikationer underlättar Django uppgifterna för att underhålla och eskalera appar.
3. Om du följde instruktionerna i den här serien bör strukturen för ditt projekt vara följande:
myfirstdjangoenv/myfirstdjangoproject. ├── db.sqlite3. ├── hantera.py. ├── minblogg. │ ├── admin.py. │ ├── admin.pyc. │ ├── __init__.py. │ ├── __init __. Pyc. │ ├── migreringar. │ │ ├── 0001_initial.py. │ │ ├── 0001_initial.pyc. │ │ ├── __init__.py. │ │ └── __init __. Pyc. │ ├── modeller.py. │ ├── modeller.pyc. │ ├── mallar. │ │ └── myblogg. │ │ └── posts.html. │ ├── tests.py. │ ├── urls.py. │ ├── urls.pyc. │ ├── views.py. │ └── views.pyc. └── myfirstdjangoproject ├── __init__.py ├── __init __. Pyc ├── settings.py ├── settings.pyc ├── urls.py ├── urls.pyc ├── wsgi.py └── wsgi .pyc.
Om listan ovan inte visas korrekt i din webbläsare, här är en skärmdump av resultatet av följande kommando:
# tree myfirstdjangoenv/myfirstdjangoproject.
Även om alla dessa begrepp kan verka lite skrämmande till en början, kan jag försäkra dig om att Django är väl värt alla ansträngningar som krävs för att bekanta dig med det
Jag hoppas att det exempel som vi har använt i denna serie för att presentera dig för detta enastående webbramverk kommer att motivera dig att lära dig mer. Om så är fallet, tjänstemannen Django dokumentation (som hela tiden hålls uppdaterad) är det bästa stället att börja.
Jag kan försäkra er om att det finns mycket mer i Django än vi kan täcka tillräckligt i en serie artiklar, så utforska det gärna och lär dig genom att göra!
Skriv gärna till oss med frågor eller förslag med hjälp av formuläret nedan.