Programmering

Django tutorial: Kom godt i gang med Django 2.0

Django er en one-size-fits-all Python-webramme, der blev inspireret af Ruby on Rails og bruger mange af de samme metaforer for at gøre webudvikling hurtig og nem. Fuldt belastet og fleksibel er Django blevet en af ​​Pythons mest anvendte webrammer.

Django indeholder stort set alt hvad du behøver for at opbygge en webapplikation af enhver størrelse, og dens popularitet gør det nemt at finde eksempler og hjælp til forskellige scenarier. Plus Django giver værktøjer, der gør det muligt for din applikation at udvikle sig og tilføje funktioner yndefuldt og til at migrere dets dataskema (hvis det har en).

Django har også ry for at være kompleks, med mange komponenter og en hel del ”under hætten” konfiguration krævet. I virkeligheden kan du få en simpel app i gang i relativt kort rækkefølge og derefter udvide dens funktionalitet derfra efter behov.

I denne vejledning gennemgår vi oprettelsen af ​​en rudimentær Django 2.0-app og berører kort de mest afgørende funktioner, den giver webudviklere.

Opgradering fra Django 1.x

Hvis du har erfaring med en tidligere 1.x-udgave af Django, er dette de vigtigste banebrydende ændringer, du skal være opmærksom på:

  • Django 2.0 kun understøtter Python 3.4 og nyere. Python 2.x understøttes ikke i fremtidige versioner af Django.
  • Django 2 følger Python 3s mønster om at bruge native Unicode-strenge, hvor det er muligt. Nogle Django-funktioner accepterer ikke længere bytring som input.

Der er mange andre bagudkompatible ændringer, men disse er to af de mest betydningsfulde, især når man starter nye projekter.

Installation af Djangos kernebiblioteker

For at installere Django 2.0 skal du bruge Python 3.4 eller bedre. Derefter er den nemmeste måde at installere Django på via Pythons pip værktøj:

pip installere django

Dette installerer de vigtigste Django-biblioteker og django-admin kommandolinjeværktøj, der bruges til styring af Django-projekter.

Hvis du vil arbejde med flere versioner af Django side om side, skal du oprette et virtuelt miljø, installere den ønskede version af Django der og bruge det til det pågældende Django-projekt.

Bemærk, at du ikke behøver at bruge virtuelle miljøer til at oprette flere projekter med en enkelt forekomst af Django. Du har kun brug for dem til at bruge forskellige punktrevisioner af Django ramme med forskellige projekter.

Oprettelse af et nyt Django-projekt

Django-forekomster er organiseret i to niveauer: projekter og apps.

  • EN projekt er en forekomst af Django med sin egen databasekonfiguration, indstillinger og apps. Det er bedst at tænke på et projekt som et sted at gemme alle de konfigurationer på webstedsniveau, du vil bruge.
  • En app er en underinddeling af et projekt med sin egen rute og gengivelseslogik. Flere apps kan placeres i et enkelt Django-projekt.

For at oprette et nyt Django-projekt fra bunden skal du indtaste det bibliotek, hvor du vil gemme projektet og skrive:

django-admin startprojekt

hvor er navnet på både projektet og underkataloget, hvor projektet opbevares. Sørg for at vælge et navn, der sandsynligvis ikke kolliderer med et navn, der bruges internt af Python eller Django. Et navn som myproj fungerer fint.

Den resulterende mappe skal indeholde enmanage.py fil, der bruges til at kontrollere appens adfærd fra kommandolinjen og en anden underkatalog (også med projektnavnet), der indeholder følgende filer:

  • En __init__.py fil, som bruges af Python til at udpege en underkatalog som et kodemodul.
  • settings.py, som indeholder de indstillinger, der bruges til projektet. Mange af de mest almindelige indstillinger udfyldes forud for dig.
  • urls.py, der viser de ruter eller URL'er, der er tilgængelige for dit Django-projekt, eller som projektet returnerer svar til.
  • wsgi.py, som bruges af WSGI-kompatible webservere, såsom Apache HTTP eller Nginx, til at betjene dit projekts apps.

Før noget andet, skal du teste projektet for at sikre, at det fungerer. Fra kommandolinjen i mappen, der indeholder dit projekt manage.py fil, kør:

python manage.py runserver

Dette skal starte en udviklingswebserver, der er tilgængelig på //127.0.0.1:8000/. Besøg dette link, og du skal se en enkel velkomstside, der fortæller dig, at installationen var vellykket.

Bemærk, at udviklingswebserveren skal ikke bruges til at tjene et Django-projekt til offentligheden. Den skaleres ikke for at håndtere den nødvendige trafik.

Oprettelse af en Django-app

Dernæst skal vi oprette en app inde i dette projekt. Naviger til samme bibliotek som manage.py og udsted denne kommando:

python manage.py startapp myapp

Dette opretter en underkatalog til en app med navnet myapp der indeholder følgende:

  • EN migrationer vejviser. Indeholder kode, der bruges til at migrere webstedet mellem versioner af dets dataskema.
  • admin.py. Indeholder objekter, der bruges af Djangos indbyggede administrationsværktøjer. Hvis din app har en admin-grænseflade eller privilegerede brugere, konfigurerer du de relaterede objekter her.
  • apps.py. Giver konfigurationsoplysninger om appen til projektet som helhed ved hjælp af en AppConfig objekt.
  • models.py. Indeholder objekter, der definerer datastrukturer, der bruges af din app til grænseflade med databaser.
  • tests.py. Indeholder test, der bruges til at sikre, at dit websteds funktioner og moduler fungerer efter hensigten.
  • views.py. Indeholder funktioner, der gengiver og returnerer svar.

For at begynde at arbejde med appen skal vi først registrere den i projektet. For at gøre dette skal du redigere myproj / settings.py og tilføj en linje til toppen af INSTALLERET_APPS liste:

INSTALLED_APPS = [‘myapp.apps.MyappConfig’, ‘django.contrib.admin’, ... 

Hvis du kigger ind myapp.apps, vil du se et prægenereret objekt med navnet MyappConfig, hvilket vi refererer til her.

Tilføjelse af ruter og visninger til din Django-app

Django-apps følger et grundlæggende mønster til behandling af anmodninger:

  • Når en indgående anmodning modtages, analyserer Django URL'en til en rute at anvende det på.
  • Ruter er defineret i urls.py, med hver rute knyttet til en udsigt, dvs. en funktion, der returnerer data, der skal sendes tilbage til klienten. Visninger kan findes hvor som helst i et Django-projekt, men de er bedst organiseret i deres egne moduler.
  • Visninger kan indeholde resultaterne af en skabelon, dvs. kode, der formaterer anmodede data i henhold til et bestemt design.

For at få en idé om, hvordan alle disse stykker passer sammen, lad os ændre standardruten for vores eksempelapp for at returnere en brugerdefineret besked.

Ruter er defineret i urls.py på en liste med navnet urlmønstre. Hvis du åbner prøven urls.py, du vil se urlmønstre allerede foruddefineret:

urlpatterns = [sti (‘admin /’, admin.site.urls),] 

Det sti funktion - en indbygget Django - tager en rute og en visningsfunktion som argumenter og genererer en henvisning til en URL-sti. Som standard opretter Django en admin sti, der bruges til webstedsadministration, men vi er nødt til at oprette vores egne ruter.

Tilføj en ny post, så hele filen ser ud:

fra django.contrib importadministrator fra django.urls import inkluderer sti urlpatterns = [sti (‘admin /’, admin.site.urls), sti (‘myapp /’, inkluderer (‘myapp.urls’))] 

Det omfatte funktion fortæller Django at kigge efter flere rutemønsteroplysninger i filen myapp.urls. Alle ruter, der findes i filen, vedhæftes ruten på øverste niveau myapp (f.eks., //127.0.0.1:8080/myapp).

Opret derefter en ny urls.py i myapp og tilføj følgende:

fra django.urls importsti fra. importvisninger urlpatterns = [sti (‘’, views.index)] 

Django lægger en skråstreg til begyndelsen af ​​hver URL, så for at specificere roden af ​​webstedet (/), leverer vi bare en tom streng som URL.

Rediger nu filen myapp / views.py så det ser sådan ud:

fra django.http import HttpResponse def index (anmodning): returner HttpResponse (“Hej verden!”) 

django.http.HttpResponse er en indbygget Django, der genererer et HTTP-svar fra en leveret streng. Noter det anmodning, som indeholder oplysningerne om en indgående HTTP-anmodning, skal sendes som den første parameter til en visningsfunktion.

Stop og genstart udviklingsserveren, og naviger til //127.0.0.1:8000/myapp/. Du skulle se Hej Verden! vises i browseren.

Tilføjelse af ruter med variabler i Django

Django kan acceptere ruter, der indeholder variabler som en del af deres syntaks. Lad os sige, at du ville acceptere webadresser, der havde formatet år/. Du kan opnå det ved at tilføje følgende post tilurlmønstre:

sti ('år /', visninger.år) 

Visningsfunktionen synspunkter. år ville derefter blive påberåbt sig gennem ruter som år / 1996, år / 2010, og så videre, med variablen år videregivet som parameter til synspunkter. år.

For at prøve dette selv skal du tilføje ovenstående urlmønstre adgang til myapp / urls.py, tilføj derefter denne funktion til myapp / views.py:

def år (anmodning, år): returner HttpResponse (‘År: {}’. format (år)) 

Hvis du navigerer til / myapp / år / 2010 på dit websted, skulle du se År: 2010 vises som svar. Bemærk, at ruter som / myapp / år / rutabaga vil give en fejl, fordi int: begrænsning på variablen år tillader kun et heltal i denne position. Mange andre formateringsmuligheder er tilgængelige for ruter.

Tidligere versioner af Django havde en mere kompleks og svær at parse syntaks for ruter. Hvis du stadig har brug for at tilføje ruter ved hjælp af den gamle syntaks - for eksempel for bagudkompatibilitet med et gammelt Django-projekt - kan du gøre det ved at bruge django.urls.re_path fungere.

Django-skabeloner

Djangos indbyggede skabelonsprog kan bruges til at generere websider ud fra data.

Skabeloner, der bruges af Django-apps, gemmes i et bibliotek, der er centralt i projektet: / skabeloner //. For vores myapp projekt, ville biblioteket være myapp / skabeloner / myapp /. Denne mappestruktur kan virke lidt akavet, men Django kan se efter skabeloner flere steder, så dette undgår navnekollisioner mellem skabeloner med de samme navne på tværs af flere apps.

I dinmyapp / skabeloner / myapp / bibliotek, skal du oprette en fil med navnet år.html med følgende indhold:

År: {{år}} 

Enhver værdi inden for dobbelt krøllede seler i en skabelon behandles som en variabel. Alt andet behandles bogstaveligt.

Modificere myapp / views.py at se sådan ud:

fra django.shortcuts import render fra django.http import HttpResponse def index (anmodning): return HttpResponse (“Hello, world!”) def year (anmodning, år): data = {'year': year} return render (anmodning, 'myapp / year.html', data) 

Det gengive funktion, en Django "genvej" (en kombination af flere indbyggede for nemheds skyld) tager det eksisterende anmodning objekt, ser efter skabelonen myapp / år.html i listen over tilgængelige skabelonplaceringer og passerer ordbogen data til det som kontekst for skabelonen.

Mængden af ​​behandling, du kan udføre på data inden for Django-skabeloner, er med vilje ret begrænset. Djangos filosofi er at håndhæve adskillelse af præsentation og forretningslogik, når det er muligt. Således kan du løbe gennem et iterabelt objekt, og du kan udføre hvis / så / ellers test, men ændring af data i en skabelon er forkert.

For eksempel kan en simpel "hvis" test kodes på denne måde:

{% if year> 2000%} 21. århundrede år: {{year}} {% else%} År før 21. århundrede: {{year}} {% endif%} 

Det {% og %} markører afgrænser kodeblokke, der kan udføres på Djangos skabelonsprog.

Hvis du vil bruge et mere sofistikeret sprog til behandling af skabeloner, kan du bytte i andre, såsom Jinja2 eller Mako. Django inkluderer backend-integration til Jinja2, men ethvert skabelonsprog, der returnerer en streng, kan bruges - for eksempel ved at returnere den streng i en HttpResponse modstand som i tilfældet med vores "Hej Verden!" rute.

Næste trin med Django

Det, vi har set her, dækker kun de mest grundlæggende elementer i en Django-applikation. Django inkluderer mange andre komponenter, der kan bruges i et webprojekt. Alle disse er værd at diskutere detaljeret hver for sig, men jeg vil give dig en kort oversigt:

  • Databaser og datamodeller. Djangos indbyggede ORM kan bruges til at definere datastrukturer og forhold mellem dem til din app såvel som migrationsstier mellem versioner af disse strukturer.

  • Formularer. Django giver en konsekvent måde for visninger at levere inputformularer til en bruger, hente data, normalisere resultaterne og levere konsekvent fejlrapportering.

  • Sikkerhed og forsyningsselskaber. Django indeholder mange indbyggede funktioner til caching, logning, sessionhåndtering, håndtering af statiske filer og normalisering af webadresser. Det indeholder også værktøjer til fælles sikkerhedsbehov, som f.eks. Brug af kryptografiske certifikater eller beskyttelse mod forfalskning på tværs af websteder eller clickjacking.