Share
Vi har täckt en hel del Python i de tidigare handledningarna i den här sessionen. Idag ska vi kombinera allt vi hittills har lärt oss för att bygga en dynamisk webbplats med Python.
Så, hur börjar du skapa webbplatser med Python? Tja, du kan göra allt själv och skriva ett program som körs på en webbserver, acceptera sidförfrågningar och betjäna svar i form av HTML och andra resurser. Men det är mycket arbete, så varför gå till alla problem när det finns gott om befintliga verktyg där ute för att göra jobbet för dig? Dessa verktyg kallas ramverk, och de är vad vi ska använda idag för att skapa vår hemsida.
Det finns en hel del Python webbramar, men här är några av de bästa:
En mer omfattande lista finns på Pythons webbplats om du behöver ytterligare alternativ. Idag ska vi ställa Django upp för utveckling på en lokal maskin, och sedan bygga en enkel blogg. Vi ska också granska processen för att installera den på en fjärrwebbserver.
Vi ska utföra det mesta av vårt arbete idag i terminalen. Detta borde fungera på Mac och Linux. Om du kör Windows är processen dock något annorlunda. En kännedom om kommandoraden är inte nödvändig om du bara skriver Python, men om du planerar att använda Django eller kör en dynamisk webbplats i allmänhet är det värt att lära sig.
Överväg att granska dessa handledning för att få dig igång med terminalen.
Här är de kommandon som du behöver installera Django. Det är inte kompatibelt med Python 3, så du måste installera version 2.7 eller tidigare för att få det att gå igång.
wget http://www.djangoproject.com/download/1.3.1/tarball/ tar xzvf Django-1.3.1.tar.gz cd Django-1.3.1 python setup.py installera
Därefter kan vi eventuellt ta bort installationsfilerna.
cd ... rm Django-1.3.1.tar.gz
Det borde göra det! Låt oss testa det.
python från django import get_version get_version ()
Du borde se "1.3.1". Om du gör det fungerade allt och Django är installerat på ditt system. grattis! Vi är redo att börja skapa vår webbplats!
Vi ska bygga ett bloggsystem idag, eftersom det är ett utmärkt sätt att lära sig grunderna. Först måste vi skapa ett Django-projekt.
cd ~ / Dokument / Projekt django-admin.py startprojekt FirstBlog cd FirstBlog ls
Vad gör alla dessa filer?
Accentsconagua
__init__.py berättar Python att den här mappen är ett Python-paket. Vi lärde oss om dessa i den tredje lektionen; Det tillåter Python att importera alla skript i mappen som moduler.manage.py är inte en del av din webbplats; Det är ett verktygsscript som du kör från kommandoraden. Den innehåller en mängd funktioner för att hantera din webbplats.settings.py innehåller webbplatsens inställningar. Django använder inte XML-filer för konfiguration; allt är python. Den här filen är helt enkelt ett antal variabler som definierar inställningen för din webbplats.urls.py är filen som kartlägger webbadresser till sidor. Det kan till exempel kartlägga yourwebsite.com/about till en Om oss sida. Django hänvisar till sig själv en MTV-ram, som står för Model Template View.
Ingen av dessa filer gör emellertid en funktionell webbplats. För det behöver vi Apps. Appar är där du skriver koden som gör din webbplats funktion, men innan vi tar en titt på dem behöver vi förstå lite om Djangos designprinciper.
Först Django är en MVC ram, som står för Model View Controller. Django hänvisar till sig själv en MTV-ram, som står för Model Template View. Det är en något annorlunda tillvägagångssätt än MVC, men i grunden är de ganska lika. Hur som helst är MVC ett arkitektoniskt mönster som ger en metod för att strukturera dina projekt. Det skiljer koden som används för att bearbeta data från koden som hanterar användargränssnittet.
Django abonnerar på DRY, eller "Do not Repeat Yourself" filosofin.
För det andra abonnerar Django på DRY, eller Repeat Yourself-filosofin, vilket innebär att du aldrig ska skriva kod som utför en viss uppgift mer än en gång. Om vi till exempel skrev en funktion som valde en slumpmässig artikel från arkivet och genomförde den här funktionen på flera sidor, skulle vi inte koda den igen varje gång den behövdes. Vi skulle koda den en gång och sedan använda den på varje sida.
Så hur relaterar detta till appar? Tja, tillåter appar att du skriver din webbplats i en DRY-stil. Varje projekt, som det vi har här, kan innehålla flera appar. Omvänt kan varje app vara en del av flera projekt. Med hjälp av exemplet från tidigare innebär det att om vi skapade en annan sida i framtiden som också behövde en slumpmässig sidfunktion, skulle vi inte behöva skriva det hela om igen. Vi kunde helt enkelt importera appen från det här projektet. På grund av detta är det viktigt att varje app tjänar ett distinkt syfte. Om du skriver alla funktioner på din webbplats inom en app och sedan behöver använda en del av det igen senare måste du importera allt. Om du till exempel skapade en e-handelswebbplats skulle du inte vilja importera alla bloggfunktioner. Men om du gör en app för den slumpmässiga funktionen och en app för bloggpubliceringssystemet, kan du välja och välja de bitar du behöver.
Detta innebär också att koden är välorganiserad inom webbplatsen. Om du vill ändra en funktion behöver du inte söka igenom en massiv fil; du kan istället bläddra till den relevanta appen och ändra den utan att oroa dig för att störa något annat.
python mangage.py startapp blog cd blogg ls
Återigen har vi en __init__.py fil för att göra det till ett paket, och tre andra filer: modeller, test och visningar. Vi behöver inte oroa oss för test för nu, men de andra två är viktiga. Modeller och åsikter är M och V delar av MVC.
I modeller definierar vi våra datastrukturer.
Om du någonsin har arbetat med PHP tidigare kan du ha använt PhpMyAdmin för att skapa dina MySQL-tabeller och sedan skriva ut dina SQL-frågor manuellt i dina PHP-skript. I Django är det mycket lättare. Vi definierar alla datastrukturer vi behöver i denna modellfil, kör sedan ett kommando och alla nödvändiga databaser är gjorda för oss.
När du vill komma åt den data går du via dessa modeller genom att ringa metod på dem istället för att köra raka frågor. Det här är mycket användbart, eftersom Django kan använda flera databasprogram. Vi ska använda MySQL idag, eftersom det är den mest kraftfulla, och det är vad de flesta värdar tillhandahåller, men om vi behövde byta till en annan databas i framtiden kommer hela koden fortfarande att vara giltig! På andra språk, om du ville byta till SQLite eller något liknande, skulle du behöva skriva om koden som går åt din databas.
I visningsfilen skriver vi koden som faktiskt genererar webbsidorna. Detta knyter samman alla andra delar. När en användare skriver in en URL, skickas den av webbadresser manus vi såg tidigare till visningar script, som då får relevanta data från modellerna, behandlar den och skickar den till en mall, som äntligen blir serverad som den sida användaren ser. Vi tar en titt på de här mallarna inom kort. De är den enklaste delen - mestadels HTML.
För en blogg behöver vi ett bord med inlägg, med flera fält för titeln, kroppstexten, författaren, den tid den skrevs och så vidare. En riktig blogg skulle ha kommentarer, men det ligger utanför dagens demo.
från django.db importmodeller klassposter (models.Model): author = models.CharField (max_length = 30) title = models.CharField (max_length = 100) bodytext = models.TextField () timestamp = models.DateTimeField ()
Dessa modeller är bara en beskrivning. Vi måste göra en faktisk databas från dem. För det första behöver vi MySQL springa på vårt system. På en faktisk webbserver skulle detta inte vara ett problem, eftersom de vanligtvis har det förinstallerat. Lyckligtvis är det med en pakethanterare lätt att installera. Först måste du installera Homebrew och Easy Install
brygga installera mysql easy_install mysql-python mysqld_safe - skip-grant-tables #lott någon har fullständiga behörigheter mysql -u rot UPDATE mysql.user SET Lösenord = PASSWORD ('netutsatser') WHERE User = "root"; #ge användarens root ett lösenord FLUSH PRIVILEGES; mysql -u root -p # logga in med vårt lösenord 'netuts' CREATE DATABASE firstblog; sluta python2.6 manage.py körserver När du startar om, kommer MySQL inte att springa, så varje gång du behöver göra det i framtiden, springa mysqld för att starta servern. Du kan sedan springa python2.6 manange.py körserver i en ny flik för att starta utvecklingsservern.
Det här kommandot kör inte servern ännu, det kommer bara att returnera ett fel. Det beror på att vi måste konfigurera våra inställningar. Låt oss ta en titt på settings.py.
Du måste ändra databasinställningarna först. Dessa börjar på rad tolv.
DATABASER = 'default': 'ENGINE': 'django.db.backends.mysql', # Lägg till 'postgresql_psycopg2', 'postgresql', 'mysql', 'sqlite3' eller 'oracle'. 'NAME': 'firstblog', # Eller sökväg till databasfilen om du använder sqlite3. 'USER': 'root', # Används inte med sqlite3. 'PASSWORD': 'netuts', # Används inte med sqlite3. "HOST": ", # Ange till tom sträng för localhost. Använd inte med sqlite3." PORT ":", # Ställ in för att tömma strängen som standard. Används inte med sqlite3.
Om du försöker köra servern igen ska den fungera, förutsatt att du framgångsrikt har installerat MySQL. Om du besöker 127.0.0.1:8000 I din webbläsare borde du se standard Django-sidan.
Låt oss nu göra vår Django-webbplats till en blogg. Först måste vi använda våra Modeller för att skapa tabeller i databasen genom att köra följande kommando:
python2.6 manage.py syncdb
Varje gång du ändrar dina modeller bör du köra kommandot för att uppdatera databasen. Observera att detta inte kan ändra befintliga fält. Det får bara lägga till nya. Så om du vill ta bort fält måste du göra det manuellt med något som PhpMyAdmin. Eftersom det här är första gången vi kör kommandot, kommer Django att konfigurera alla standardinställda tabeller för saker som administrationssystemet. Skriv bara 'ja' och fyll i dina uppgifter.
Nu ska vi sätta upp urls.py fil. Uncomment den första raden i avsnittet exempel, och ändra den för att säga url (r '^ $', 'FirstBlog.blog.views.home', name = "home") .
Nu, låt oss skapa visningsfilen för att svara på dessa förfrågningar.
från django.shortcuts import render_to_response från blog.models importera inlägg def home (request): return render_to_response ('index.html') Detta index.html filen finns inte ännu, så låt oss göra det. Skapa en mapp, kallad mallar i blog app och spara en fil i det som heter index.html, som helt enkelt kan innehålla "Hello World" för nu. Då måste vi redigera inställningsfilen så Django vet var den här mallen ligger.
Linje 105 är där sektionen för att deklarera mallmappar börjar. så justera det, så här:
TEMPLATE_DIRS = ("blogg / mallar", # Sätt strängar här, som "/ home / html / django_templates" eller "C: / www / django / templates". # Använd alltid framåt snedstreck, även på Windows. att använda absoluta vägar, inte relativa vägar.) Om du kör servern igen och uppdatera sidan i din webbläsare, ska du se meddelandet "Hello World". Vi kan nu börja lägga ut vår blogg. Vi lägger till några pekar HTML för hemsidan.
Första bloggen Första bloggen
Titel
Publicerad på datum av författare
Kropp text
Om du sparar och uppdaterar sidan ska du se att sidan har uppdaterats med det här nya innehållet. Nästa steg är att lägga till dynamiskt innehåll från databasen. För att uppnå detta har Django ett templerande språk som låter dig bädda in variabler med lockiga axlar. Ändra den mellersta sektionen på din sida för att se så här ut:
Första bloggen
title
Publicerad den date av author
body
Vi kan sedan vidarebefordra värden till dessa variabla platshållare från views.py fil genom att skapa en ordlista med värden.
från django.shortcuts import render_to_response från blog.models importera inlägg def home (request): content = 'title': 'Min första post', 'författare': 'Giles', 'date': '18 september 2011' kropp ':' Lorem ipsum dolor sit amet, consectetur adipiscing elit. Etiam kursens tempus visar, utgått från sin egen. Aenean justo felis, dapibus quis vulputate vid, porta et dolor. Berätta för dig, du behöver inte veta mer om vad du behöver Etiam eget convallis turpis. Donec non sem justo. ', Returnera render_to_response (' index.html ', innehåll) Spara och uppdatera, och du bör se att du nu skickar in innehåll till en mall från din visningsfil. Det sista steget är att hämta data från vår databas och skicka den i stället. Lyckligtvis kan vi göra allt utan SQL-frågor, med Django modeller. Vi måste lägga till vår blog app till vårt FirstBlog Projekt genom att ändra en annan inställning. Gå till INSTALLED_APPS på rad 112, och lägg till
'FirstBlog.blog',
till listan.
Ändra sedan views.py så det lägger till data från databasen.
från django.shortcuts import render_to_response från blog.models importera inlägg def home (request): entries = posts.objects.all () [: 10] return render_to_response ('index.html', 'posts': entries) Uppdatera sedan mallen för att komma åt dessa data.
Första bloggen
% för inlägg i inlägg%Post titel
Publicerad den post.timestamp av post.author
post.bodytext
% endfor%
Här kan vi få tillgång till all data i vårt bord i views.py fil, välj sedan bara de första tio posterna. Vi överför dessa data till mallen, loop genom posterna och visa data med HTML på vår webbplats. Detta kommer inte att fungera ännu, för det finns inget i databasen. Stoppa servern och springa:
python2.6 manage.py syncdb
Detta lägger till den nya tabellen för våra inlägg i databasen. Öppna sedan en ny flik och skriv:
mysql -u rot-p
... skriv ditt lösenord, tryck enter och kör:
INSERT INTO blog_posts (författare, titel, bodytext) värden ('Bob', 'Hello World', 'Lorem Ipsum'); Återgå till föregående flik och kör servern igen. Uppdatera sidan och du bör se ett blogginlägg med det dummyinnehåll som du just lagt till. Om du kör MySQL-kommandot några gånger, bör du se fler inlägg visas på sidan när du uppdaterar.
Det sista vi behöver göra idag är genomgång Djangos administrationssystem. Detta är en väldigt kraftfull funktion av Django som låter dig hantera din webbplats utan att skriva någon mer kod, som du skulle behöva om du skapade en webbplats från början. För att aktivera det måste vi ändra några inställningar. Första, obekanta linjerna 4, 5, 13 och 16 inom urls.py, så att du faktiskt kan komma åt administratörssidan. Gå sedan till INSTALLED_APPS avsnitt av settings.py och okommentar 'Django.contrib.admin', och 'django.contrib.admindocs',. För att låta administratören kontrollera din inlägg bord, skapa en ny fil som heter admin.py i blog mapp och lägg till följande rader:
från django.contrib import admin från blog.models importera inlägg admin.site.register (inlägg)
Springa python2.6 manage.py syncdb igen för att lägga till tabellerna för admin sektionen och starta om servern.
Om du besöker 127.0.0.1:8000/admin Nu i din webbläsare bör du se en inloggningssida. Använd de uppgifter du valde tidigare när du först sprang SyncDB Kommando att logga in. Du ska se en sektion, kallad Blogg, med en undertext för inlägg tabell. Du kan använda detta för att skapa, redigera och ta bort blogginlägg med ett enkelt gränssnitt.
Det är allt som finns att göra. Du har just skapat en helt fungerande, om än enkel blogg. För att slutföra den här lektionen ska vi se på att installera Django på en webbserver.
Det finns två typer av webbhotell, och vilken du har kommer att påverka om du kan använda Django. Om du har delat hosting, är du helt till din värds nåd.
Många billiga webbhotell stöder inte Python. Medan PHP nästan garanteras är det ofta inte stöd för andra språk. Du måste kontrollera kontrollpanelen för att avgöra om Python (och Django) är tillgängliga. Självklart är processen lite annorlunda med varje värd. Nästan alla hosting körs på Apache, och vi kan använda det för att vara värd för Django, med hjälp av
mod_wsgiellermod_pythonApache-moduler.
De flesta webbhotell kör skript på flera språk med hjälp av CGI. Django kan köras på FastCGI, och också teoretiskt på CGI, men det stöds inte officiellt och skulle vara alltför långsamt för en verklig produktionswebbplats. Du måste kontrollera om dessa är installerade. De finns vanligen under en rubrik, som "CGI och Scripting Language Support".
Om du har VPS hosting, eller har turen att ha en dedikerad server, är ditt liv mycket enklare. Vanligtvis kommer dessa med Python förinstallerade, och därifrån behöver du bara följa samma steg som vi gick igenom för att få en lokal kopia av Django. Om du inte har Python kan du installera den med en pakethanterare. Ditt system kan till och med komma med Django.
ssh [email protected] wget http://www.djangoproject.com/download/1.3.1/tarball/ tar xzvf Django-1.3.1.tar.gz cd Django-1.3.1 python setup.py installera
När du har installerat Django på din server, ladda upp den webbplats du just skapat med någon filöverföringsklient. Du kan lägga filerna var som helst, men håll dem borta från offentlig mappen, eller någon kommer att kunna se källkoden på din webbplats. jag använder /Hem för alla mina projekt.
Skapa sedan en MySQL-databas, kallad "firstblog" på din server och kör SyncDB igen. Du måste skapa ditt konto för administratörskontrollpanelen igen, men det här är en engångsartikel.
Om du försöker köra detta kan du få ett fel, och det beror på att inställningarna för servern är olika på din lokala dator. Du kan behöva ändra databas lösenord inom settings.py, men beroende på din serverkonfiguration kan du också stöta på andra problem. Google är din vän i dessa situationer!
För att köra servern denna gång är kommandot något annorlunda. Du måste ange en IP-adress och en port så att du kan komma åt webbplatsen via internet.
python manage.py körserver 0.0.0.0:8000
Om du besöker din webbplats i en webbläsare, på port 8000, borde du se din webbplats!
Det är det för den här lektionen ... och vår serie. Jag hoppas att du har lärt dig några användbara färdigheter under de senaste fem lektionerna och att du är redo att fortsätta och lära dig ännu mer Python i framtiden. Om du gillar utseendet på Django, och önskar fortsätta att öka din kunskap om ramverket, här är några ytterligare handledning om ämnet.
Som alltid är jag glad att diskutera några frågor om denna handledning eller Python i allmänhet inom kommentarerna. Tack för att du läser.
Lär dig Python med vår kompletta handledning för pythonhandledning, oavsett om du bara har börjat eller du är en erfaren kodare som vill lära dig nya färdigheter.
