Django er et one-size-fits-all Python web-rammeverk som ble inspirert av Ruby on Rails og bruker mange av de samme metaforene for å gjøre webutvikling rask og enkel. Fullt lastet og fleksibelt har Django blitt en av Pythons mest brukte nettrammer.
Django inkluderer praktisk talt alt du trenger for å lage en webapplikasjon i alle størrelser, og dens popularitet gjør det enkelt å finne eksempler og hjelp til ulike scenarier. Pluss Django gir verktøy som lar applikasjonen din utvikle seg og legge til funksjoner på en elegant måte, og for å migrere dataskjemaet (hvis det har en).
Django har også rykte for å være kompleks, med mange komponenter og en god del “under panseret” -konfigurasjon som kreves. I sannhet kan du få en enkel app i gang i relativt kort rekkefølge, og deretter utvide funksjonaliteten derfra etter behov.
I denne guiden går vi gjennom etableringen av en rudimentær Django 2.0-app, og berører kort de mest avgjørende funksjonene den gir for webutviklere.
Oppgradering fra Django 1.x
Hvis du har erfaring med en tidligere, 1.x utgave av Django, er dette de viktigste endringene du må være bevisst på:
- Django 2.0 kun støtter Python 3.4 og nyere. Python 2.x støttes ikke i fremtidige versjoner av Django.
- Django 2 følger Python 3s mønster om å bruke innfødte Unicode-strenger der det er mulig. Noen Django-funksjoner godtar ikke lenger bytring som input.
Det er mange andre bakoverkompatible endringer, men de er to av de viktigste, spesielt når du starter nye prosjekter.
Installerer Djangos kjernebiblioteker
For å installere Django 2.0 trenger du Python 3.4 eller bedre. Da er den enkleste måten å installere Django på via Python’s pip nytte:
pip installere django
Dette installerer kjernen til Django-biblioteker og django-admin kommandolinjeverktøy som brukes til å administrere Django-prosjekter.
Hvis du vil jobbe med flere versjoner av Django side om side, må du opprette et virtuelt miljø, installere ønsket versjon av Django der, og bruke det til det aktuelle Django-prosjektet.
Merk at du ikke trenger å bruke virtuelle miljøer for å opprette flere prosjekter med en enkelt forekomst av Django. Du trenger dem bare for å bruke forskjellige punktrevisjoner av Django rammeverk med forskjellige prosjekter.
Opprette et nytt Django-prosjekt
Django-forekomster er organisert i to nivåer: prosjekter og apper.
- EN prosjekt er en forekomst av Django med sin egen databasekonfigurasjon, innstillinger og apper. Det er best å tenke på et prosjekt som et sted å lagre alle konfigurasjonene på nettstedet.
- An app er en underavdeling av et prosjekt, med sin egen rute og gjengivelseslogikk. Flere apper kan plasseres i et enkelt Django-prosjekt.
For å lage et nytt Django-prosjekt fra bunnen av, skriv inn katalogen der du vil lagre prosjektet og skriv:
django-admin startprosjekt
hvor er navnet på både prosjektet og underkatalogen der prosjektet skal lagres. Husk å velge et navn som sannsynligvis ikke kolliderer med et navn som brukes av Python eller Django internt. Et navn som myproj vil fungere helt fint.
Den resulterende katalogen skal inneholde enmanage.py fil, som brukes til å kontrollere appens oppførsel fra kommandolinjen, og en annen underkatalog (også med prosjektnavnet) som inneholder følgende filer:
- An
__init__.pyfil, som brukes av Python til å utpeke en underkatalog som en kodemodul. settings.py, som inneholder innstillingene som brukes for prosjektet. Mange av de vanligste innstillingene blir forhåndsutfylt for deg.urls.py, som viser rutene eller URL-ene som er tilgjengelige for Django-prosjektet ditt, eller som prosjektet vil returnere svar for.wsgi.py, som brukes av WSGI-kompatible webservere, for eksempel Apache HTTP eller Nginx, for å betjene prosjektets apper.
Før noe annet, test prosjektet for å sikre at det fungerer. Fra kommandolinjen i katalogen som inneholder prosjektets manage.py fil, kjør:
python manage.py runserver
Dette bør starte en utviklingswebserver som er tilgjengelig på //127.0.0.1:8000/. Besøk den lenken, og du bør se en enkel velkomstside som forteller deg at installasjonen var vellykket.
Merk at utviklingswebserveren skal ikke brukes til å tjene et Django-prosjekt for publikum. Den skaleres ikke for å håndtere den nødvendige trafikken.
Opprette en Django-app
Deretter må vi lage en app i dette prosjektet. Naviger til samme katalog som manage.py og gi ut denne kommandoen:
python manage.py startapp myapp
Dette oppretter en underkatalog for en app som heter myapp som inneholder følgende:
- EN
migrasjonerkatalog. Inneholder kode som brukes til å migrere nettstedet mellom versjoner av dataskjemaet. admin.py. Inneholder objekter som brukes av Djangos innebygde administrasjonsverktøy. Hvis appen din har et administratorgrensesnitt eller privilegerte brukere, vil du konfigurere de relaterte objektene her.apps.py. Gir konfigurasjonsinformasjon om appen til prosjektet generelt, i form av enAppConfiggjenstand.models.py. Inneholder objekter som definerer datastrukturer som brukes av appen din til å grensesnitt med databaser.tests.py. Inneholder eventuelle tester som brukes for å sikre at nettstedets funksjoner og moduler fungerer som forutsatt.views.py. Inneholder funksjoner som gjengir og returnerer svar.
For å begynne å jobbe med appen, må vi først registrere den i prosjektet. For å gjøre dette, rediger myproj / settings.py og legg til en linje øverst på INSTALLERT_APPS liste:
INSTALLED_APPS = [‘myapp.apps.MyappConfig’, ‘django.contrib.admin’, ... Hvis du ser inn myapp.apps, vil du se et forhåndsgenerert objekt som heter MyappConfig, det er det vi refererer til her.
Legge til ruter og visninger i Django-appen din
Django-apper følger et grunnleggende mønster for behandling av forespørsler:
- Når en innkommende forespørsel mottas, analyserer Django URL-adressen for en rute å bruke den på.
- Ruter er definert i
urls.py, med hver rute knyttet til en utsikt, dvs. en funksjon som returnerer data som skal sendes tilbake til klienten. Visninger kan være hvor som helst i et Django-prosjekt, men de er best organisert i sine egne moduler. - Visninger kan inneholde resultatene av en mal, dvs. kode som formaterer forespurte data i henhold til et bestemt design.
For å få en ide om hvordan alle disse delene passer sammen, la oss endre standardruten til eksempelappen vår for å returnere en tilpasset melding.
Ruter er definert i urls.py i en liste som heter urlmønstre. Hvis du åpner prøven urls.py, du vil se urlmønstre allerede forhåndsdefinert:
urlpatterns = [sti (‘admin /’, admin.site.urls),] De sti funksjon - en Django innebygd - tar en rute og en visningsfunksjon som argumenter og genererer en referanse til en URL-bane. Som standard oppretter Django en admin sti som brukes til nettstedsadministrasjon, men vi trenger å lage våre egne ruter.
Legg til en ny oppføring, slik at hele filen ser ut som:
fra django.contrib importadministrator fra django.urls import inkluderer, sti urlpatterns = [sti (‘admin /’, admin.site.urls), sti (‘myapp /’, inkluderer (‘myapp.urls’))] De inkludere -funksjonen ber Django om å lete etter mer informasjon om rutemønsteret i filen myapp.urls. Alle rutene som finnes i den filen, blir lagt til ruten på øverste nivå myapp (f.eks. //127.0.0.1:8080/myapp).
Deretter oppretter du en ny urls.py i myapp og legg til følgende:
fra django.urls importsti fra. import views urlpatterns = [path (‘’, views.index)] Django legger en skråstrek til begynnelsen av hver URL, så for å spesifisere roten til nettstedet (/), vi leverer bare en tom streng som URL.
Rediger nå filen myapp / views.py så det ser slik ut:
fra django.http importer HttpResponse def indeks (forespørsel): returner HttpResponse (“Hei, verden!”) django.http.HttpResponse er en Django innebygd som genererer en HTTP-respons fra en medfølgende streng. Noter det be om, som inneholder informasjonen for en innkommende HTTP-forespørsel, må sendes som den første parameteren til en visningsfunksjon.
Stopp og start utviklingsserveren på nytt, og naviger til //127.0.0.1:8000/myapp/. Du bør se Hei Verden! vises i nettleseren.
Legge til ruter med variabler i Django
Django kan godta ruter som inneholder variabler som en del av syntaksen. La oss si at du ønsket å godta nettadresser som hadde formatet år/. Du kan oppnå det ved å legge til følgende oppføring iurlmønstre:
sti (‘år /’, visninger.år) Visningsfunksjonen visninger. år vil deretter bli påkalt gjennom ruter som år / 1996, år / 2010, og så videre, med variabelen år sendt som parameter til visninger. år.
For å prøve dette selv, legg til ovenstående urlmønstre inngang til myapp / urls.py, og legg deretter denne funksjonen til myapp / views.py:
def år (forespørsel, år): return HttpResponse (‘Year: {}’. format (year)) Hvis du navigerer til / myapp / år / 2010 på nettstedet ditt, bør du se År: 2010 vises som svar. Merk at ruter som / myapp / år / rutabaga vil gi en feil, fordi int: begrensning på variabelen år tillater bare et heltall i den posisjonen. Mange andre formateringsalternativer er tilgjengelige for ruter.
Tidligere versjoner av Django hadde en mer kompleks og vanskelig å analysere syntaksen for ruter. Hvis du fortsatt trenger å legge til ruter ved hjelp av den gamle syntaksen - for eksempel for bakoverkompatibilitet med et gammelt Django-prosjekt - kan du gjøre det ved å bruke django.urls.re_path funksjon.
Django maler
Djangos innebygde malspråk kan brukes til å generere websider fra data.
Maler som brukes av Django-apper, lagres i en katalog som er sentral i prosjektet: / maler //. For vår myapp prosjekt, ville katalogen være myapp / maler / myapp /. Denne katalogstrukturen kan virke litt vanskelig, men Django kan se etter maler flere steder, så dette unngår navnekollisjon mellom maler med samme navn på tvers av flere apper.
I dinmyapp / maler / myapp / katalog, lager du en fil med navnet år.html med følgende innhold:
År: {{år}} Enhver verdi innenfor dobbel krøllete bukseseler i en mal blir behandlet som en variabel. Alt annet behandles bokstavelig.
Endre myapp / views.py å se slik ut:
fra django.shortcuts importer gjengivelse fra django.http import HttpResponse def index (forespørsel): return HttpResponse (“Hello, world!”) def år (forespørsel, år): data = {'år': år} retur gjengivelse (forespørsel, 'myapp / year.html', data) De gjengi funksjon, en Django "snarvei" (en kombinasjon av flere innebygde for enkelhets skyld), tar den eksisterende be om objekt, ser etter malen myapp / year.html i listen over tilgjengelige malplasseringer, og passerer ordboken data til det som kontekst for malen.
Mengden behandling du kan utføre på data i Django-maler er med vilje ganske begrenset. Djangos filosofi er å håndheve separasjon av presentasjon og forretningslogikk når det er mulig. Dermed kan du gå gjennom et iterabelt objekt, og du kan utføre hvis / da / annet tester, men det er mislikt å endre dataene i en mal.
For eksempel kan en enkel "hvis" test kodes på denne måten:
{% if year> 2000%} 21. århundre år: {{year}} {% else%} År før 21. århundre: {{year}} {% endif%} De {% og %} markører avgrenser blokker med kode som kan kjøres på Djangos malspråk.
Hvis du vil bruke et mer sofistikert språk for malebehandling, kan du bytte inn andre, for eksempel Jinja2 eller Mako. Django inkluderer back-end integrasjon for Jinja2, men ethvert mal språk som returnerer en streng kan brukes - for eksempel ved å returnere den strengen i en HttpResponse innvende som i tilfelle av vår "Hei Verden!" rute.
Neste trinn med Django
Det vi har sett her, dekker bare de mest grunnleggende elementene i en Django-applikasjon. Django inneholder mange andre komponenter som kan brukes i et webprosjekt. Alle disse er verdt å diskutere i detalj hver for seg, men jeg vil gi deg en kort oversikt:
Databaser og datamodeller. Djangos innebygde ORM kan brukes til å definere datastrukturer og forhold mellom dem for appen din, samt migreringsstier mellom versjoner av disse strukturene.
Skjemaer. Django gir en jevn måte for visninger å levere inngangsskjemaer til en bruker, hente data, normalisere resultatene og gi konsekvent feilrapportering.
Sikkerhet og verktøy. Django inkluderer mange innebygde funksjoner for hurtigbufring, logging, økthåndtering, håndtering av statiske filer og normalisering av nettadresser. Den pakker også verktøy for vanlige sikkerhetsbehov, som å bruke kryptografiske sertifikater, eller beskytte mot forfalskningsbeskyttelse på tvers av nettsteder eller clickjacking.
