Forbedre Django-prosjektet med disse beste praksisene

Django er et robust, åpen kildekode, Python-basert rammeverk for å bygge webapplikasjoner. Populariteten har økt de siste par årene, og den er allerede moden og mye brukt med et stort samfunn bak seg.

Blant andre Python-baserte rammer for å lage nettapplikasjoner (som Flask og Pyramid), er Django den desidert mest populære. Den støtter både Python versjon 2.7 og Python 3.6. Men på tidspunktet for denne artikkelen er Python 2.7 fortsatt den mer tilgjengelige versjonen når det gjelder fellesskap, tredjepartspakker og online dokumentasjon. Django er sikker når den brukes riktig, og gir høye dimensjoner av fleksibilitet. Det er veien å gå når du utvikler applikasjoner på serversiden ved bruk av Python.

Google Trends av de tre mest populære rammene for Python webutvikling

Som en erfaren Python- og Django-utvikler vil jeg dele med deg noen av de beste praksisene for et Django-oppsett som jeg har lært og samlet opp gjennom årene. Enten du har noen få Django-prosjekter under beltet, eller du i ferd med å starte det første fra bunnen av, kan de beste fremgangsmåtene beskrevet her hjelpe deg med å lage bedre applikasjoner nede.

Jeg skrev denne artikkelen fra et veldig praktisk tankesett, slik at du kan legge til noen verktøy i utviklingsverktøykassen din umiddelbart. Du kan til og med lage en avansert tilpasset Django-kjeleplate for dine neste prosjekter.

I forbindelse med denne artikkelen antar jeg at du bruker en Linux Ubuntu-maskin. Gjennom hele artikkelen starter noen kodelinjer med et $-tegn. Disse brukes til å understreke at denne linjen skal settes inn i terminalen. Sørg for å kopiere linjen uten $ -tegnet.

Virtuelt miljø

Mens du utvikler Python-baserte applikasjoner, er det å bruke tredjepartspakker en pågående ting. Disse pakkene oppdateres ofte, så det er viktig å holde dem organisert. Når du utvikler flere og flere prosjekter på samme lokale maskin, er det utfordrende å følge med på den nåværende versjonen av hver pakke. Det er umulig å bruke forskjellige versjoner av den samme pakken til forskjellige prosjekter. Videre kan oppdatering av en pakke på ett prosjekt ødelegge funksjonaliteten på et annet, og omvendt.

Det er her Python Virtual Environment er praktisk. Slik installerer du virtuelt miljøbruk:

$ apt-get-oppdatering
$ apt-get install python-pip python-dev build-essential
$ export LC_ALL = "en_US.UTF-8" # kan være nødvendig i tilfelle du får en feil fra neste linje
$ pip installere - oppgradere pip
$ pip installere - oppgradere virtualenv
$ mkdir ~ / .virtualenvs
$ pip installer virtualenvwrapper
$ eksport WORKON_HOME = ~ / .virtualenvs
$ nano ~ / .bashrc

Legg denne linjen til slutten av filen:

. /usr/local/bin/virtualenvwrapper.sh

Så kjør:

$. Bashrc

Etter installering oppretter du et nytt virtuelt miljø for prosjektet ved å skrive:

$ mkvirtualenv prosjektnavn

Mens du er i sammenheng med det virtuelle miljøet ditt, vil du legge merke til at et prefiks legges til terminalen, som:

(prosjektnavn) ofir @ lekeplass: ~ $

For å deaktivere (avslutte) det virtuelle miljøet og komme tilbake til den viktigste Python-konteksten til din lokale maskin, bruk:

$ deaktivere

For å aktivere (starte) den virtuelle miljøkonteksten, bruk:

$ workon prosjektnavn

For å liste over de virtuelle miljøene som finnes på din lokale maskin, bruk:

$ lsvirtualenv

Hvis du holder prosjektavhengighetene (pakker) i et virtuelt miljø på maskinen din, kan du holde dem i et isolert miljø. Du bruker dem bare til et enkelt (eller flere) prosjekt. Når du oppretter et nytt virtuelt miljø, starter du et friskt miljø uten pakker installert i det. Da kan du bruke for eksempel:

(prosjektnavn) $ pip installer Django

for å installere Django i ditt virtuelle miljø, eller:

(prosjektnavn) $ pip installere Django == 1.11

for installering av versjon 1.11 av Django bare tilgjengelig innenfra.

Verken din viktigste Python-tolk eller de andre virtuelle miljøene på maskinen din vil kunne få tilgang til den nye Django-pakken du nettopp har installert.

For å bruke runserver-kommandoen ved å bruke det virtuelle miljøet, mens du er i sammenheng med det virtuelle miljøet:

(prosjektnavn) $ cd / bane / til / django / prosjekt
(prosjektnavn) $ ./manage.py runserver

Når du går inn i Python-tolken fra det virtuelle miljøet, skriver du på samme måte:

(prosjektnavn) $ python

Den vil ha tilgang til pakker du allerede har installert i miljøet.

Krav

Krav er listen over Python-pakker (avhengigheter) prosjektet bruker mens det kjøres, inkludert versjonen for hver pakke. Her er et eksempel på en krav.txt-fil:

dicttoxml == 1.7.4
Django == 1.11.2
h5py == 2.7.0
matplotlib == 2.0.2
numpy == 1.13.0
Pillow == 4.1.1
psycopg2 == 2.7.1
pyparsing == 2.2.0
python-dateutil == 2.6.0
pytz == 2017,2
seks == 1.10.0
xmltodict == 0.11.0

Å holde kravene dine.txt oppdatert er avgjørende for å kunne samarbeide ordentlig med andre utviklere. Det er også viktig for å holde produksjonsmiljøet riktig konfigurert. Når denne filen er inkludert i kodelageret, kan du oppdatere alle pakkene som er installert i det virtuelle miljøet ved å utføre en enkelt linje i terminalen. Da kan du få nye utviklere i gang på kort tid.

For å generere et nytt krav.txt eller for å oppdatere et eksisterende, bruk innen det virtuelle miljøet:

(prosjektnavn) $ pip fryse> krav.txt

For enkelhets skyld må du sørge for å utføre denne kommandoen i en mappe som blir sporet av ditt Git-lager. Dette gjør at andre forekomster av koden også har tilgang til filen krav.txt.

Hvis en ny utvikler blir medlem av teamet, eller hvis du vil konfigurere et nytt miljø ved hjelp av de samme pakkene som er oppført i kravene.txt-filen, kjør i virtuell miljøsammenheng:

(prosjektnavn) $ cd / bane / til / krav / fil
(prosjektnavn) $ pip installere -r krav.txt

Alle kravene som er oppført i filen blir umiddelbart installert i det virtuelle miljøet. Eldre versjoner blir oppdatert og nyere versjoner blir nedgradert for å passe til den nøyaktige listen over krav.txt. Vær forsiktig - det kan være forskjeller mellom miljøer du fremdeles vil respektere.

Jeg anbefaler på det sterkeste å integrere disse kommandoene i arbeidsflyten. Oppdater filen krav.txt før du skyver kode til depotet og installer krav.txt-filen etter å ha trukket kode fra depotet.

Kreditt: https://www.djangoproject.com/

Bedre innstillinger.py-konfigurasjon

Django kommer ut av boksen med en veldig grunnleggende, men likevel nyttig settings.py-fil. Dette definerer de viktigste og mest nyttige konfigurasjonene for prosjektet. Settings.py-filen er veldig grei. Men noen ganger, som en utvikler som jobber på et team, eller når du setter opp et produksjonsmiljø, trenger du mer enn en grunnleggende innstillinger.py-fil.

Flere innstillingsfiler lar deg enkelt definere skreddersydde konfigurasjoner for hvert miljø hver for seg, slik som:

ALLOWED_HOSTS # for produksjonsmiljø
DEBUG
DATABASER # for forskjellige utviklere på samme team

La meg introdusere deg for en utvidet tilnærming for konfigurering av settings.py-filen. Det lar deg vedlikeholde forskjellige versjoner og bruke den du ønsker til enhver tid og i ethvert miljø.

Naviger først til filstien til settings.py:

(prosjektnavn) $ cd / bane / til / innstillinger / fil

Opprett deretter en ny modul som heter innstillinger (modulen er en mappe som inneholder en __init__.py-fil):

(prosjektnavn) $ mkdir-innstillinger

Nå, gi nytt navn til settings.py-filen til base.py og plasser den i den nye modulen du opprettet:

(prosjektnavn) $ mv settings.py settings / base.py

For dette eksempelet antar jeg at du vil konfigurere en innstillingsfil for utviklingsmiljøet og en for produksjonsmiljøet. Ulike utviklere på samme team kan bruke nøyaktig samme tilnærming for å definere forskjellige innstillingsfiler.

For utviklingsmiljøet ditt:

(prosjektnavn) $ nano-innstillinger / utvikling.py

Skriv deretter inn:

fra .baseimport *
DEBUG = Sant

og lagre filen ved å trykke på Ctrl + O, Enter og deretter Ctrl + X.

For produksjonsmiljøet ditt:

(prosjektnavn) $ nano-innstillinger / produksjon.py

og skriv:

fra .baseimport *
DEBUG = Falske
ALLOWED_HOSTS = [‘app.project_name.com’,]

Nå, når du vil legge til eller oppdatere innstillingene i et bestemt miljø, kan du enkelt gjøre det i sin egen innstillingsfil.

Du lurer kanskje på - hvordan vet Django hvilke innstillingsfiler som skal lastes inn på hvert miljø? Det er det __init__.py-filen brukes til. Når Django ser etter settings.py som den pleide å laste når du for eksempel kjører serveren, finner den nå en innstillingsmodul i stedet for en settings.py-fil. Men så lenge det er en modul som inneholder en __init__.py-fil, hva Django angår, er det nøyaktig samme ting. Django vil laste inn __init__.py-filen og utføre hva som er skrevet i den.

Derfor må vi definere hvilken innstillingsfil vi vil laste inni filen __init__.py ved å utføre:

(prosjektnavn) $ innstillinger / __ init__.py

og for et produksjonsmiljø, for eksempel ved å skrive:

fra .produksjonsimport *

På denne måten vil Django laste inn alle base.py- og production.py-innstillingene hver gang den starter. Magic?

Nå er den eneste konfigurasjonen som er igjen å beholde __init__.py i .gitignore-filen din, slik at den ikke blir inkludert i trykk og trekk. Når du har satt opp et nytt miljø, ikke glem å opprette en ny __init__.py-fil i innstillingsmodulen. Importer deretter innstillingsfilen som kreves nøyaktig som vi gjorde før.

I denne artikkelen har vi dekket tre beste fremgangsmåter for bedre å sette opp Django-prosjektet:

  • Jobber i et virtuelt miljø
  • Hold filen krav.txt oppdatert og bruk den kontinuerlig i arbeidsflyten
  • Sette opp en bedre prosjektinnstillingsgruppe

Har du fulgt disse beste praksisene i det siste prosjektet ditt? Har du innsikt å dele? Kommentarer er høyt verdsatt.

Fant du dette nyttig? I så fall, gi meg noen klapper, slik at flere ser artikkelen.

Dette er del 1 i serien om beste praksis for utvikling av Django. Følg meg for å få en øyeblikkelig oppdatering når de neste delene er tilgjengelige.

Finn flere gode tips for teknologiske gründere på CodingStartups.