Demistificarea magiei lui Django

Potrivit documentației oficiale,

Django este un cadru web Python de nivel înalt care încurajează dezvoltarea rapidă și designul curat și pragmatic. Construit de dezvoltatori experimentați, se ocupă de mare parte din necazul dezvoltării web, astfel încât să vă puteți concentra pe scrierea aplicației fără a fi nevoie să reinventați roata. Este gratuit și open source.

— DjangoProject.com

Este unul dintre cadrele populare Python pentru construirea de aplicații web și este cel mai preferat pentru scalabilitatea sa în crearea unui boilerplate cu configurații și fișiere stabilite. Aceasta încheie întregul obiectiv al Django pentru dezvoltatori;

„... construirea unei aplicații grozave în puțin timp și mai puține griji cu privire la setările de bază.”

Există configurații de bază, fișiere și stiluri care se referă la toate aplicațiile web, indiferent de ceea ce construiți. Când utilizați Django, acestea sunt generate automat pentru dvs. atunci când executați anumite comenzi în diferite puncte ale ciclului de dezvoltare al aplicației dvs. Cu aceasta, veți avea suficient timp să vă concentrați asupra aspectului de bază al dezvoltării aplicației dvs., în timp ce Django se ocupă de celelalte pentru dvs.

Înseamnă că se întâmplă o mulțime de lucruri sub capotă. Pentru cineva care nu are o înțelegere completă a părților în mișcare, acest lucru poate fi copleșitor. În acest articol vom afla despre următoarele:

• Instalarea Django
• Comenzile startproject și startapp
• Fișierele de configurare Django care includ;
• setări.py
• urls.py
• gestionează.py
• Aspectul modelelor
• Dirijare

Vom afla cum se potrivesc toate acestea și rolul pe care îl joacă. Este important să știți că nu va fi posibil să aruncați o privire la tot ce se întâmplă în interiorul lui Django. Pentru cazurile care nu fac obiectul acestui tutorial, vor exista link-uri care să vă îndrume către resurse care vă vor ajuta în acest sens.

În scopul învățării, vom construi o platformă de comerț electronic. Acesta nu este un site de comerț electronic complet, aplicația noastră va avea doar două caracteristici de bază; crearea produselor si efectuarea comenzilor din punctul de vedere al administratorului.

Acest articol vă va ghida prin înțelegerea comenzilor, fișierelor și elementelor de bază predefinite ale Django. Este destinat dezvoltatorilor care au folosit Django sau intenționează să-l folosească și doresc să știe ce se întâmplă sub capotă. Deși nu este obligatoriu să fi folosit Django, a avea experiență cu elementele de bază ale Django înainte de a continua cu acest articol vă va oferi un avantaj. Trebuie să aveți cunoștințe practice despre Python pentru a înțelege pe deplin ceea ce va fi acoperit în această piesă.

Instalarea Django

Dacă nu aveți deja instalat Django, iată pașii pentru a face asta.

Mai întâi, creați un mediu virtual, numit djangodev . Aveți nevoie de acest lucru pentru a izola spațiul de lucru Django și pachetele sale dependente.

 python3 -m venv ~/.virtualenvs/djangodev

Acum, pentru a intra în mediul virtual, trebuie să îl activați;

 source ~/.virtualenvs/djangodev/bin/activate

Dacă primiți vreo eroare care rulează cu source , puteți utiliza această comandă alternativă,

 . ~/.virtualenvs/djangodev/bin/activate

Pentru utilizatorii de Windows, utilizați în schimb acest lucru,

 ...\> %HOMEPATH%\.virtualenvs\djangodev\Scripts\activate.bat

Notă: Trebuie să activați mediul virtual oricând doriți să utilizați Django.

Acum că vă aflați în mediul virtual, instalați Django:

 python -m pip install Django

Pentru a verifica dacă Django a fost instalat corect, rulați;

 python -m django --version

Shakaboom! Acum ești pregătit pentru ceva magie, pregătește-ți baghetele!

Metoda de a crea fișiere și foldere din mers poate fi simplă și simplă. Totuși, nu este ideal atunci când trebuie să creezi un proiect mediu sau mare și un termen limită de depășit. Avem întotdeauna un termen de depășit, chiar și pentru proiecte personale.

Urmând această metodă atunci când creați un nou proiect mare, va trebui să creați mai multe fișiere și foldere și să faceți mai multe setări, ceea ce ar putea duce la crearea de erori care pot fi evitate și o mulțime de timp pierdut. Comenzile startproject și startapp disponibile prin Django urmăresc să rezolve această problemă. Aceste două comenzi creează fișiere, foldere și efectuează o mulțime de configurare pentru tine.

Să începem prin a genera o nouă aplicație folosind comanda startproject .

Scafodarea unei aplicații

Vom genera aplicația noastră și vom arunca o privire la fișierele care sunt generate, precum și la câteva comenzi pe care le vom folosi. Rulați această comandă în terminalul dvs. pentru a începe;

 django-admin startproject ecommerce_site

Când instalați Django, django-admin este adăugat în calea dvs. pentru a-i oferi acces pentru a-și efectua acțiunile. Este utilitarul de linie de comandă al Django pentru responsabilitățile administrative. Aflați mai multe utilizări django-admin aici; este puțin dincolo de scopul acestui articol.

startproject este o comandă Django care ajută la generarea proiectului . Aici îi trecem numele proiectului nostru ecommerce_site . Apoi se creează proiectul într-un director numit ecommerce_site . Directorul ar trebui să arate așa,

Va trebui să navigăm în directorul nou creat și să rulăm comanda pentru a genera aplicația .

 cd ecommerce_site python manage.py startapp trading

startapp este o comandă executată de manage.py în directorul proiectului, creează mai multe fișiere și un folder numit folosind numele specificat în comandă, în acest caz, ceea ce este specificat este trading . Dosarul aplicației este format din fișiere simple care ar trebui să fie necesare pentru a crea caracteristici ale unei aplicații. Acum directorul tău ar trebui să arate astfel:

Dacă vă întrebați care este diferența dintre un proiect și o aplicație. Un proiect este o aplicație web Django, poate consta din una sau mai multe aplicații. Este folderul care conține manage.py și celălalt modul care include settings.py și alte fișiere. O aplicație este un pachet Python care face o anumită funcție, include fișiere precum models.py , directorul de migrare și multe altele. Puteți consulta acest răspuns pe Stack Overflow pentru mai multe.

startproject va crea directorul principal al proiectului, în timp ce startapp va crea directorul aplicației. Ambelor li s-a dat, de asemenea, un nume pentru a fi folosite în generație. startproject este prima comandă rulată la crearea unui nou proiect, în timp ce startapp este rulată în noul director de proiect.

Aspectul actual este o mapare excelentă pe care o puteți folosi pentru orice aplicație pe care o construiți. Este scalabil și constă din fișiere de care veți avea nevoie. Există șansa de a crea, redenumi, edita și muta fișiere în cadrul proiectului.

Configurația lui Django

Django vă oferă diferite setări și configurații, după ce rulați cele două comenzi în fișiere diferite, să parcurgem fișierele generate pentru a afla ce face fiecare.

settings.py

Majoritatea aplicațiilor web au nevoie de configurații precum; autentificare pentru verificarea utilizatorilor, permisiuni pentru a permite anumitor utilizatori cu anumite abilități și stabilirea standardelor de securitate. Toate acestea sunt necesare pentru a oferi utilizatorilor cea mai bună experiență necesară. Va dura mult timp pentru ca dezvoltator să începeți să rulați fiecare dintre acestea pe cont propriu, pentru fiecare aplicație la care lucrați.

Django vă oferă aceste configurații necesare și multe altele - astfel încât să puteți opta pentru cele dorite și să le conectați. Acestea sunt făcute în settings.py , există deja setări create pentru a vă oferi funcționalități de bază.

Când Django încearcă să ruleze un proiect, există anumite variabile pe care le caută. settings.py este fișierul care conține acele variabile care duc la alte fișiere sau informații. Django este direcționat către acest fișier din fișierul manage.py și preia informații sau încarcă alte fișiere la care este condus de aici.

Aceste configurații includ:

• DEBUG
  Funcționalitatea DEBUG este setată la True pentru a permite citirea erorilor și codul de depanare în dezvoltare, ar trebui să fie setată la False în timpul producției (adică atunci când implementați). Această setare vă permite să vă puteți depana mai bine codul cu ajutorul Django atunci când încearcă să ruleze codul.
• INSTALLED_APPS
  Aceasta este o listă a tuturor aplicațiilor care efectuează o anumită funcție în Django. Vine cu unele aplicații implicite, cum ar fi 'django.contrib.auth' care este folosit pentru autentificarea utilizatorilor, django.contrib.admin' pentru funcționalitatea de administrare și 'django.contrib.messages' necesare pentru a trimite notificări sau informații către utilizatori. Orice altă aplicație pe care o creați folosind comanda startapp va trebui să fie aici înainte de a putea fi rulată de Django.
• MIDDLEWARE este un cadru ușor pentru procesarea intrărilor și ieșirilor care trec prin solicitările și răspunsurile Django. Fiecare middleware realizează o funcție specifică cu o aplicație, cum ar fi 'django.contrib.auth.middleware.AuthenticationMiddleware' lucrează cu 'django.contrib.sessions' pentru a asocia utilizatorii cu solicitări. Ar trebui să verificați funcțiile suplimentare ale fiecărui middleware din documente.
• ROOT_URLCONF este o variabilă către o cale în care Django caută urlpatterns -urile dvs. atunci când o solicitare este transmisă aplicației dvs. Django. Ori de câte ori se face o solicitare într-o aplicație Django, Django caută această variabilă și încarcă fișierul principal și trece prin lista de urlpatterns în căutarea căii potrivite.
• TEMPLATES este o setare care permite redarea fișierelor HTML pentru a reprezenta o vizualizare. Comunică cu aplicațiile de solicitare, autentificare și mesaje. Valoarea 'BACKEND' și 'APP_DIRS' setate la True îi permit lui Django să caute fișiere HTML în folderul /templates . 'context_processors' din OPTIONS sunt apelabile , care preiau cererea ca argument și o îmbină cu contextul când este redat un șablon, aceste apelabile funcționează pentru a ajuta la depanarea, autentificarea și gestionarea cererilor în general.
• WSGI_APPLICATION este o cale care duce la variabila application din fișierul wsgi.py
• DATABASE este un dicționar care deține acces la o bază de date externă (sau internă ca în cazul sqlite implicit) precum PostgresSQL, MySQL și MongoDB. Iată un exemplu de bază de date Postgres pe care o voi folosi pentru exemplul nostru:

 DATABASES = { 'default': { 'ENGINE': 'django.db.backends.postgresql_psycopg2', 'NAME': 'db_name', 'USER': 'db_user', 'PASSWORD': 'db_password', 'HOST': 'localhost', 'PORT': '', } }

Puteți decide să utilizați baza de date sqlite implicită, aceasta nu funcționează grozav pentru producție. Puteți configura o bază de date Postgres ca mai sus, va trebui să creați mai întâi baza de date și să transmiteți utilizatorului, parola cu permisiunea de scriere în baza de date.

Notă : În scopul acestui tutorial, puteți utiliza deja setul implicit de baze de date sqlite. Cele de mai sus este o demonstrație despre cum puteți seta conexiunea la baza de date SQL și NO-SQL în Django.

• AUTH_PASSWORD_VALIDATORS acestea sunt funcții care sunt apelate pentru validarea parolei. Acestea sunt apelate la crearea înregistrărilor utilizatorilor (și, de asemenea, administratorilor), resetarea și schimbarea parolelor. Puteți afla mai multe despre ele din documentația oficială.

Mai multe documente despre setări pot fi găsite aici.

manage.py

Majoritatea proiectelor web au nevoie de un punct de intrare de unde pornesc comenzile. Un punct de intrare care acționează ca o poartă în aplicație. În fiecare proiect Django, este de obicei fișierul manage.py .

Acest fișier este necesar ca punct de plecare în aplicația dvs. De aici, toate comenzile sunt executate și totul pornește aici.

manage.py are aceeași funcție ca django-admin. De asemenea, îi spune lui Django locația pentru configurațiile pe care le aveți în aplicația dvs. Acesta este setat implicit și nu trebuie schimbat.

Utilizează funcția def main() pentru a gestiona modulul de setări implicite în fișierul nostru settings.py . Încearcă să importe funcția de execuție, iar dacă întâlnește o eroare, aruncă ImportError . În caz contrar, preia orice argument este transmis de sys.argv din linia de comandă și se execută.

sys.argv este o listă care preia comanda transmisă prin terminal. Când rulăm python manage.py runserver în linia de comandă, sys.argv este setat la ["manage.py", "runserver"] și acesta este transmis funcției execute() .

Argumente precum python manage.py startapp trading sau python manage.py makemigrations sunt setate la [ "manage.py", "startapp", "trading"] și, respectiv, ["manage.py", "makemigrations"] pentru execuție.

Declarația if este setată să ruleze dacă comanda dată este setată la manage.py .

Pe lângă rularea funcțiilor django-admin , îl veți folosi în serverul care rulează, veți gestiona migrațiile și alte comenzi pe care le va folosi proiectul dvs. De asemenea, veți avea nevoie de el atunci când implementați, testați și depanați proiectele dvs.

Aspectul modelului

Django vă oferă un aspect simplu de modelare. Vă configurați modelele în fișierul models.py din directorul de trading . Clasele (sau modelele) sunt modele pe care le vor urma tabelele bazei de date.

Vă definiți clasele pe baza tipurilor de date pe care doriți să le obțineți de la utilizator (sau administrator) pentru fiecare tabel. Modelele noastre creează un fișier de migrare care funcționează cu variabila DATABASE din settings.py .

Să creăm două modele de care vom avea nevoie, pentru produse și comenzi:

 from django.db import models class Product(models.Model): name = models.CharField(max_length=50) image = models.ImageField(upload_to='products', default='python.png') price = models.IntegerField() description = models.TextField() def __str__(self): return self.name class Order(models.Model): product = models.ForeignKey(Product, on_delete=models.CASCADE) quantity = models.IntegerField() date = models.DateField(auto_now_add=True) user = models.CharField(max_length=50) def __str__(self): return self.user

Modelul de produs are un nume, preț, descriere și o imagine (care, atunci când este salvată, va fi încărcată într-un dosar de products . Acesta este creat dacă folderul nu există) coloane. order are un product (legat la tabelul de products ), cantitatea, data si coloanele utilizator.

Cu aceste informații, Django creează o schemă de bază de date pentru aplicație. De asemenea, creează un API de acces la baza de date Python pentru accesarea obiectelor Produs și Comandă. Django are un instrument de migrare integrat, astfel încât să nu fie nevoie să utilizați pachete externe pentru migrare.

Următorul pas este să rulați comanda de migrare și să migrați la baza de date. Dar înainte de a face asta, trebuie să înregistrăm trading ca aplicație în directorul nostru de proiecte.

În primul rând, trebuie să configuram directorul de tranzacționare ca o aplicație în Django. Django a făcut asta pentru tine în fișierul app.py Acest fișier înregistrează trading ca aplicație și va fi utilizat în continuare în fișierul settings.py .

Acum, în settings.py adăugați trading în INSTALLED_APP . Ar trebui să arate așa:

 INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'trading.apps.TradingConf', ]

Pe terminal, rulați:

 $ python manage.py makemigrations trading $ python manage.py migrate

Notă: Mediul dumneavoastră virtual trebuie să fie activat și ar trebui să vă aflați în directorul proiectului.

python manage.py makemigrations trading ia notă de modificările efectuate în modulul de tranzacționare și creează un fișier în folderul de migration al modificărilor din models.py și python manage.py migrate , apoi actualizează modificările.

Puteți găsi fișierul de migrare generat din comanda de python manage.py makemigrations trading în directorul de migration numit 0001_initial.py . Puteți vedea clasele și coloanele ca comenzi pentru creare în interiorul fișierului. Pe măsură ce se fac mai multe modificări în models.py , aici vor fi generate mai multe fișiere.

Funcții de administrare

În aplicația noastră actuală, vom avea nevoie de funcții de administrare pentru a gestiona produsele și comenzile care vor fi create în aplicație. Django ne oferă o funcționalitate de administrare încorporată deja la dispoziția noastră. Aplicația (funcția) de administrare a fost de asemenea înregistrată în lista noastră INSTALLED_APP ; 'django.contrib.admin' .

De asemenea, adresa URL pentru administrator a fost înregistrată și în lista urlpatterns fișierul nostru de configurare URL urls.py ; path('admin/', admin.site.urls), . Fișierul admin.py vă permite să înregistrați modele și acțiunile CRUD care urmează să fie efectuate asupra modelelor.

Pentru a configura administratorul, rulați acest lucru pe terminal:

 $ python manage.py createsuperuser

Vi se va solicita să introduceți un nume de utilizator, un e-mail și o parolă. După aceea, ați creat cu succes un administrator. Pentru a începe cu funcționalitatea de administrare, rulați serverul:

 $ python manage.py runserver

Vizitarea https://127.0.0.1:8000/admin/ va duce la o sesiune de autentificare, când vă conectați (cu numele de utilizator și parola pe care le-ați creat) sunteți direcționat către tabloul de bord:

Grupurile și utilizatorii sunt configurații implicite care permit administratorului să acceseze gestionarea utilizatorilor și permisiunea. Acum să ne înregistrăm modelele.

În admin.py , adăugați următoarele rânduri:

 from django.contrib import admin # Register your models here. from .models import Product, Order admin.site.register(Product) admin.site.register(Order)

from django.contrib import admin importă funcționalitatea de admin din Django, apoi am importat cele două clase din models.py și le-am înregistrat astfel încât un administrator să poată efectua acțiuni CRUD asupra produselor și să comande din tabloul de bord.

După înregistrarea modelelor, tabloul de bord ar trebui să arate astfel:

Adăugarea produselor:

Efectuarea comenzilor din tabloul de bord administrativ:

Rutare ușoară

Fiecare site are nevoie de rută sau URL-uri care să conducă la anumite pagini cu anumite informații pentru utilizatorul final. Colecțiile de informații sau aplicații similare sunt accesate pe o anumită rută. Este nevoie de gruparea rutelor împreună pentru accesibilitate și comunicare în cadrul fișierelor. Django a făcut asta pentru tine în fișierul urls.py

urls.py este un fișier care duce de la variabila ROOT_CONF din settings.py . Aici se realizează configurarea URL-ului principal. Când creăm vizualizări în diferite fișiere sau foldere, sau chiar în fișierul urls.py , acestea trebuie configurate în lista urlpatterns .

Django așteaptă o listă numită urlpatterns în fișier. Puteți schimba fișierul din variabila ROOT_CONF cu orice alt fișier pe care l-ați plasat în lista de urlpatterns .

 urlpatterns = [ path('admin/', admin.site.urls), ]

Lista constă din obiecte care sunt instanțe de path sau re-path . Fiecare instanță are doi parametri obligatorii, modelul 'admin/' și un fișier de vizualizare sau URL, admin.site.urls .

Instanțele ar putea duce, de asemenea, la un alt fișier cu mai multe configurații URL. Acest lucru se face pentru lizibilitate.

views.py

O nevoie importantă pentru o aplicație de backend sunt vizualizările la care se mapează fiecare traseu. În Django, scrieți vizualizările bazate pe funcții sau clase pentru o aplicație în fișierul views.py . O vizualizare este o clasă sau o funcție care procesează o solicitare și trimite înapoi un răspuns utilizatorului dvs.

Editați fișierul views.py astfel:

 from django.http import HttpResponse def home(request): return HttpResponse("This is a shopping site for products") def order(request): return HttpResponse("Hello, welcome to our store, browse to our products and order!")

Aici am importat HTTPResponse pentru a-l folosi în definirea a două vederi (vizualizări de funcții) pentru a returna propoziția atunci când este apelat. def home ar trebui să fie apelat când vizitați adresa principală și def order când accesați adresa URL a comenzii.

După ce ne creăm vizualizările, trebuie să le atribuim diferitelor rute (sau urlpatterns ). Acest lucru se poate face în mai multe moduri, putem crea o listă de urlpatterns în același fișier sau am putea importa trading.views în fișierul ecommerce_site.urls și să creăm calea.

Modul preferat de a face acest lucru este crearea unui fișier de configurare a adresei URL secundare (inside trading ) și includerea acestuia în ecommerce_site.urls . Creați un fișier urls.py în directorul de trading . Directorul dvs. ar trebui să arate astfel:

 trading/ __init__.py admin.py apps.py migrations/ __init__.py 0001_initial.py models.py tests.py urls.py views.py

Adăugați următorul cod în noul fișier ( urls.py )

 from django.urls import path from . import views urlpatterns = [ path('', views.home, name='home'), path('order/', views.order, name='order'), ]

Să înregistrăm fișierul de configurare a adreselor URL de trading ( urls.py ) în fișierul de configurare a adreselor URL ale proiectului,

 from django.contrib import admin from django.urls import include, path urlpatterns = [ path('admin/', admin.site.urls), path('', include('trading.urls')) ]

Pentru a putea accesa urlpatterns vom folosi clasa include din django.urls în linia 2. Apoi am ales un model și am atașat fișierul urls.py în directorul de tranzacționare.

Ceea ce am făcut aici a fost să importam clasa de path din django și fișierul views.py . Apoi lista noastră constă din două instanțe de cale pentru fiecare vizualizare. Deci def home este apelat pe https://127.0.0.1:8000/.

Și def order este apelată pe https://127.0.0.1:8000/order/.

Notă: procesul de rulare a startproject și startapp nu este obligatoriu, dar este foarte încurajat de Django. Și puteți crea/muta fișiere și foldere după ce rulați fiecare comandă, în funcție de confortul dvs.

Arborele de dependență

Iată procesul prin care Django procesează solicitările de la adresele URL care vin:

1. Django caută locația rădăcină (calea) pentru adresele URL în variabila ROOT_CONF .
2. Django încarcă fișierul python dat în calea furnizată. Și localizează variabila urlpatterns , aceasta este o listă care conține toate instanțele django.urls.path() și/sau django.urls.re_path() .
3. În listă, Django merge în ordine și caută o adresă URL care se potrivește.
4. Python, importă și apelează vizualizarea (fie vizualizare bazată pe funcții, fie vizualizare bazată pe clasă). Care este transmisă în continuare cu cererea HTTP.
5. Vizualizarea procesează solicitarea și informațiile transmise și fie returnează un mesaj/șablon, fie redirecționează către o altă vizualizare.
6. Dacă nu se potrivește niciun model URL sau dacă se ridică o excepție în orice moment al acestui proces, Django invocă o vizualizare adecvată de gestionare a erorilor.

Concluzie

Am aflat de posibilitatea de a crea fișiere pentru Django fără linia de comandă. De asemenea, am învățat avantajele și elementele de bază ale unui proiect Django. Django este un instrument uimitor în construirea proiectelor backend cu scopul de a crea simplitate.

Puteți consulta codul acestui tutorial pe GitHub.

Resurse

• Gestionarea parolelor în Django
• Django: Pentru început
• Django: Setări
• Django ușor de O'Reilly