Demistyfikacja magii Django

Zgodnie z oficjalną dokumentacją,

Django to wysokopoziomowy framework WWW w Pythonie, który zachęca do szybkiego rozwoju i czystego, pragmatycznego projektowania. Stworzony przez doświadczonych programistów, rozwiązuje większość problemów związanych z tworzeniem stron internetowych, dzięki czemu możesz skupić się na pisaniu aplikacji bez konieczności ponownego wymyślania koła. Jest darmowy i open source.

— DjangoProject.com

Jest to jeden z popularnych frameworków Pythona do tworzenia aplikacji internetowych i jest najbardziej preferowany ze względu na skalowalność w tworzeniu schematu z określonymi konfiguracjami i plikami. To podsumowuje cały cel Django dla programistów;

„...tworzenie świetnej aplikacji w krótkim czasie i mniej zmartwień o podstawowe ustawienia”.

Istnieją podstawowe konfiguracje, pliki i style, które przecinają wszystkie aplikacje internetowe, bez względu na to, co tworzysz. Podczas korzystania z Django są one generowane automatycznie, gdy uruchamiasz określone polecenia w różnych punktach cyklu rozwoju aplikacji. Dzięki temu będziesz miał wystarczająco dużo czasu, aby skupić się na głównym aspekcie tworzenia aplikacji, podczas gdy Django zajmie się pozostałymi za Ciebie.

Oznacza to, że pod maską dzieje się wiele rzeczy. Dla kogoś, kto nie ma pełnego zrozumienia ruchomych części, może to być przytłaczające. W tym artykule dowiemy się o następujących kwestiach:

• Instalacja Django
• Polecenia startproject i startapp
• Pliki konfiguracyjne Django, które zawierają;
• ustawienia.py
• url.py
• zarządzaj.py
• Układ modeli
• Rozgromienie

Dowiemy się, jak to wszystko do siebie pasuje i jaką rolę odgrywają. Ważne jest, aby wiedzieć, że nie będzie można przyjrzeć się wszystkim, co dzieje się w Django. W przypadkach wykraczających poza zakres tego samouczka będą dostępne linki do zasobów, które w tym pomogą.

W celach edukacyjnych będziemy budować platformę e-commerce. Nie jest to w pełni rozbudowana witryna e-commerce, nasza aplikacja będzie miała tylko dwie podstawowe funkcje; tworzenie produktów i składanie zamówień z punktu widzenia administratora.

Ten artykuł poprowadzi Cię przez zrozumienie gotowych poleceń, plików i podstaw Django. Jest skierowany do programistów, którzy korzystali z Django lub zamierzają go używać i chcą wiedzieć, co dzieje się pod maską. Chociaż korzystanie z Django nie jest obowiązkowe, posiadanie doświadczenia z podstawami Django przed kontynuowaniem tego artykułu da ci przewagę. Musisz mieć praktyczną znajomość Pythona, aby w pełni zrozumieć, co zostanie omówione w tym artykule.

Instalowanie Django

Jeśli nie masz jeszcze zainstalowanego Django, oto kroki, aby to zrobić.

Najpierw utwórz środowisko wirtualne o nazwie djangodev . Potrzebujesz tego, aby odizolować obszar roboczy Django i zależne od niego pakiety.

 python3 -m venv ~/.virtualenvs/djangodev

Teraz, aby dostać się do swojego środowiska wirtualnego, musisz je aktywować;

 source ~/.virtualenvs/djangodev/bin/activate

Jeśli pojawi się jakiś błąd podczas pracy ze source , możesz skorzystać z tego alternatywnego polecenia,

 . ~/.virtualenvs/djangodev/bin/activate

W przypadku użytkowników systemu Windows skorzystaj z tego zamiast,

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

Uwaga: Musisz aktywować środowisko wirtualne za każdym razem, gdy chcesz korzystać z Django.

Teraz, gdy jesteś w swoim wirtualnym środowisku, zainstaluj Django:

 python -m pip install Django

Aby sprawdzić, czy Django zostało poprawnie zainstalowane, uruchom;

 python -m django --version

Shakaboom! Teraz jesteś gotowy na trochę magii, przygotuj różdżki!

Metoda tworzenia plików i folderów w podróży może być prosta i bezpośrednia. Nie jest to jednak idealne rozwiązanie, gdy musisz stworzyć średni lub duży projekt i termin do pokonania. Zawsze mamy termin do pokonania, nawet w przypadku projektów osobistych.

Postępując zgodnie z tą metodą podczas tworzenia nowego dużego projektu, będziesz musiał utworzyć wiele plików i folderów oraz wprowadzić wiele ustawień, co może prowadzić do tworzenia możliwych do uniknięcia błędów i dużo straconego czasu. Polecenia startproject i startapp dostępne przez Django mają na celu rozwiązanie tego problemu. Te dwa polecenia tworzą pliki, foldery i przeprowadzają wiele konfiguracji za Ciebie.

Zacznijmy od wygenerowania nowej aplikacji za pomocą polecenia startproject .

Rusztowanie Aplikacja

Wygenerujemy naszą aplikację i przyjrzymy się generowanym plikom, a także kilku komendom, których użyjemy. Uruchom to polecenie w swoim terminalu, aby rozpocząć;

 django-admin startproject ecommerce_site

Podczas instalacji Django, django-admin jest dodawany do Twojej ścieżki, aby dać mu dostęp do wykonywania swoich działań. Jest to narzędzie wiersza poleceń Django do zadań administracyjnych. Dowiedz się więcej o zastosowaniach django-admin tutaj; to trochę wykracza poza zakres tego artykułu.

startproject to polecenie Django, które pomaga wygenerować projekt . Tutaj przekazujemy mu nazwę naszego projektu ecommerce_site . Następnie tworzy projekt w katalogu o nazwie ecommerce_site . Katalog powinien wyglądać tak,

Musimy przejść do nowo utworzonego katalogu i uruchomić polecenie, aby wygenerować aplikację .

 cd ecommerce_site python manage.py startapp trading

startapp to polecenie wykonywane przez manage.py w katalogu projektu, które tworzy wiele plików i folder o nazwie określonej w poleceniu, w tym przypadku określa się trading . Folder aplikacji składa się z prostych plików, które powinny być potrzebne do tworzenia funkcji aplikacji. Teraz twój katalog powinien wyglądać tak:

Jeśli zastanawiasz się, jaka jest różnica między projektem a aplikacją. Projekt to aplikacja internetowa Django, może składać się z jednej lub więcej aplikacji. Jest to folder zawierający manage.py i inny moduł zawierający settings.py i inne pliki. Aplikacja to pakiet Pythona, który ma określoną funkcję, zawiera pliki takie jak models.py , katalog migracji i inne. Możesz sprawdzić tę odpowiedź na Stack Overflow, aby uzyskać więcej informacji.

startproject utworzy główny katalog projektu, podczas gdy startapp utworzy katalog aplikacji. Obydwu zostały również przekazane nazwy, które mają być używane w pokoleniu. startproject jest pierwszym poleceniem uruchamianym podczas tworzenia nowego projektu, podczas gdy startapp jest uruchamiany w katalogu nowego projektu.

Obecny układ jest świetnym mapowaniem, którego możesz użyć dla dowolnej tworzonej aplikacji. Jest skalowalny i składa się z plików, których będziesz potrzebować. Istnieje możliwość tworzenia, zmiany nazwy, edycji i przenoszenia plików w ramach projektu.

Konfiguracja Django

Django zapewnia różne ustawienia i konfiguracje, po uruchomieniu dwóch poleceń w różnych plikach, przejrzyjmy wygenerowane pliki, aby dowiedzieć się, co robi każdy z nich.

settings.py

Większość aplikacji internetowych wymaga konfiguracji, takich jak; uwierzytelnianie w celu weryfikacji użytkowników, uprawnienia pozwalające niektórym użytkownikom z określonymi umiejętnościami i ustalanie standardów bezpieczeństwa. Wszystko to jest potrzebne, aby zapewnić użytkownikom jak najlepsze wrażenia. Deweloperowi zajmie dużo czasu, zanim zaczniesz wprowadzać każdy z nich na własną rękę, dla każdej aplikacji, nad którą pracujesz.

Django zapewnia te potrzebne konfiguracje i nie tylko — takie, że możesz wybrać te, które chcesz i podłączyć. Są to zrobione w settings.py , są już utworzone ustawienia, aby zapewnić Ci podstawowe funkcje.

Kiedy Django próbuje uruchomić projekt, szuka pewnych zmiennych. settings.py to plik zawierający te zmienne, które prowadzą do innych plików lub informacji. Django jest kierowany do tego pliku z pliku manage.py i pobiera informacje lub ładuje inne pliki, do których jest kierowany stąd.

Te konfiguracje obejmują:

• DEBUG
  Funkcja DEBUG jest ustawiona na True , aby umożliwić odczytywanie błędów i debugowanie kodu w fazie rozwoju, powinna być ustawiona na False podczas produkcji (tj. podczas wdrażania). To ustawienie umożliwia lepsze debugowanie kodu za pomocą Django, gdy próbuje uruchomić Twój kod.
• INSTALLED_APPS
  To jest lista wszystkich aplikacji wykonujących określoną funkcję w Django. Zawiera kilka domyślnych aplikacji, takich jak 'django.contrib.auth' który służy do uwierzytelniania użytkowników, django.contrib.admin' dla funkcji administratora oraz 'django.contrib.messages' potrzebne do wysyłania powiadomień lub informacji do użytkowników. Każda inna aplikacja, którą utworzysz za pomocą polecenia startapp , będzie musiała znajdować się tutaj, zanim będzie mogła zostać uruchomiona przez Django.
• MIDDLEWARE to lekki framework do przetwarzania danych wejściowych i wyjściowych przechodzących przez żądania i odpowiedzi Django. Każde oprogramowanie pośredniczące wykonuje określoną funkcję w aplikacji, na przykład 'django.contrib.auth.middleware.AuthenticationMiddleware' współpracuje z 'django.contrib.sessions' aby powiązać użytkowników z żądaniami. Powinieneś zapoznać się z dalszymi funkcjami każdego oprogramowania pośredniczącego w dokumentacji.
• ROOT_URLCONF to zmienna ścieżki, w której Django szuka twoich urlpatterns , gdy żądanie jest przekazywane do twojej aplikacji Django. Za każdym razem, gdy w aplikacji Django wysyłane jest żądanie, Django przeszukuje tę zmienną i ładuje wiodący plik oraz urlpatterns się przez listę wzorców url w poszukiwaniu pasującej ścieżki.
• TEMPLATES to ustawienie umożliwiające renderowanie plików HTML w celu reprezentowania widoku. Komunikuje się z aplikacjami żądań, uwierzytelniania i wiadomości. Wartość 'BACKEND' BACKEND' i 'APP_DIRS' ustawione na True umożliwiają Django wyszukiwanie plików HTML w folderze /templates . 'context_processors' w OPTIONS to callables , które przyjmują żądanie jako argument i łączą je z kontekstem podczas renderowania szablonu. Te callables pomagają w debugowaniu, uwierzytelnianiu i ogólnie obsłudze żądań.
• WSGI_APPLICATION to ścieżka prowadząca do zmiennej application w pliku wsgi.py
• DATABASE to słownik, który posiada dostęp do zewnętrznej bazy danych (lub wewnętrznej jak w przypadku domyślnego sqlite) jak PostgresSQL, MySQL i MongoDB. Oto przykład bazy danych Postgres, której użyję w naszym przykładzie:

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

Możesz zdecydować się na użycie domyślnej bazy danych sqlite, nie działa to dobrze w przypadku produkcji. Możesz skonfigurować bazę danych Postgres jak powyżej, najpierw musisz utworzyć bazę danych i przekazać użytkownika, hasło z uprawnieniami do zapisu do bazy danych.

Uwaga : do celów tego samouczka możesz już użyć domyślnego zestawu baz danych sqlite. Powyższe jest demonstracją, jak ustawić połączenie z bazą danych SQL i NO-SQL w Django.

• AUTH_PASSWORD_VALIDATORS są to funkcje wywoływane w celu weryfikacji hasła. Są wywoływane podczas tworzenia rekordów użytkowników (i administratorów), resetowania i zmiany haseł. Możesz dowiedzieć się o nich więcej z oficjalnej dokumentacji.

Więcej dokumentacji na temat ustawień można znaleźć tutaj.

manage.py

Większość projektów internetowych wymaga punktu wejścia, od którego zaczynają się polecenia. Punkt wejścia działający jako brama do aplikacji. W każdym projekcie Django jest to zwykle plik manage.py .

Ten plik jest potrzebny jako punkt wyjścia w Twojej aplikacji. Stąd uruchamiane są wszystkie polecenia i wszystko zaczyna się tutaj.

manage.py pełni tę samą funkcję, co django-admin. Informuje również Django o lokalizacji konfiguracji, które masz w swojej aplikacji. Jest to ustawione domyślnie i nie trzeba go zmieniać.

Używa funkcji def main() do obsługi modułu ustawień domyślnych naszego pliku settings.py . Próbuje zaimportować funkcję execute, a jeśli napotka błąd, zgłasza ImportError . W przeciwnym razie pobiera każdy argument przekazany przez sys.argv z wiersza poleceń i wykonuje.

sys.argv to lista, która pobiera polecenie przekazane przez terminal. Kiedy uruchamiamy python manage.py runserver w wierszu poleceń, sys.argv zostaje ustawiony na ["manage.py", "runserver"] i jest przekazywany do funkcji execute() .

Argumenty takie jak python manage.py startapp trading lub python manage.py makemigrations są ustawiane odpowiednio na [ "manage.py", "startapp", "trading"] i ["manage.py", "makemigrations"] do wykonania.

Instrukcja if jest ustawiona do uruchomienia, jeśli podane polecenie jest ustawione na manage.py .

Oprócz uruchamiania funkcji django-admin , będziesz używał go na serwerze, obsługi migracji i innych poleceń, których będzie używał Twój projekt. Będziesz go również potrzebował podczas wdrażania, testowania i debugowania swoich projektów.

Układ modelu

Django zapewnia prosty układ do modelowania. Swoje modele konfigurujesz w pliku models.py w katalogu trading . Twoje klasy (lub modele) to układy, według których będą podążać Twoje tabele bazy danych.

Definiujesz swoje klasy na podstawie typów danych, które chcesz uzyskać od użytkownika (lub administratora) dla każdej tabeli. Nasze modele tworzą plik migracji, który współpracuje ze zmienną DATABASE w settings.py .

Stwórzmy dwa modele, których będziemy potrzebować, dla produktów i zamówień:

 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

Model produktu posiada kolumny z nazwą, ceną, opisem i obrazkiem (który po zapisaniu zostanie przesłany do folderu products . Zostanie utworzony, jeśli ten folder nie istnieje). order zawiera product (podłączony do tabeli products ), ilość, datę i kolumny użytkownika.

Dzięki tym informacjom Django tworzy schemat bazy danych dla aplikacji. Ponadto tworzy interfejs API dostępu do bazy danych Python w celu uzyskania dostępu do obiektów Product i Order. Django posiada wbudowane narzędzie do migracji, dzięki czemu nie musisz używać zewnętrznych pakietów do migracji.

Następnym krokiem jest uruchomienie komendy migracji i migracja do bazy danych. Ale zanim to zrobimy, musimy zarejestrować trading jako aplikację w naszym katalogu projektów.

Po pierwsze, musimy skonfigurować katalog handlowy jako aplikację w Django. Django zrobił to za Ciebie w pliku app.py Ten plik rejestruje trading jako aplikację i będzie dalej używany w pliku settings.py .

Teraz w settings.py dodaj trading w INSTALLED_APP . To powinno wyglądać tak:

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

Na terminalu uruchom:

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

Uwaga: Twoje środowisko wirtualne musi być aktywowane i powinieneś znajdować się w katalogu projektu.

python manage.py makemigrations trading odnotowuje zmiany wprowadzone w module tradingu i tworzy plik w folderze migration zmian w models.py i python manage.py migrate , a następnie aktualizuje zmiany.

Wygenerowany plik migracji można znaleźć za pomocą polecenia python manage.py makemigrations trading w katalogu migration o nazwie 0001_initial.py . Możesz zobaczyć klasy i kolumny jako polecenia do tworzenia w pliku. W miarę wprowadzania kolejnych zmian w models.py , więcej plików zostanie wygenerowanych tutaj.

Funkcje administracyjne

W naszej obecnej aplikacji będziemy potrzebować funkcji administracyjnych do zarządzania produktami i zamówieniami, które zostaną utworzone w aplikacji. Django udostępnia nam wbudowaną funkcjonalność administratora. Aplikacja administracyjna (funkcja) została również zarejestrowana na naszej liście INSTALLED_APP ; 'django.contrib.admin' .

Ponadto adres URL administratora został również zarejestrowany na liście urlpatterns w naszym pliku konfiguracyjnym adresu URL urls.py ; path('admin/', admin.site.urls), . Plik admin.py umożliwia rejestrację modeli i akcji CRUD, które mają być wykonane na modelach.

Aby skonfigurować administratora, uruchom to na terminalu:

 $ python manage.py createsuperuser

Zostaniesz poproszony o podanie nazwy użytkownika, adresu e-mail i hasła. Po tym pomyślnie utworzyłeś administratora. Aby rozpocząć korzystanie z funkcji administratora, uruchom serwer:

 $ python manage.py runserver

Odwiedzenie https://127.0.0.1:8000/admin/ spowoduje sesję logowania, po zalogowaniu się (za pomocą utworzonej nazwy użytkownika i hasła) zostaniesz przekierowany do panelu administratora:

Grupy i użytkownicy to domyślne konfiguracje, które umożliwiają administratorowi dostęp do zarządzania użytkownikami i uprawnieniami. Teraz zarejestrujmy nasze modele.

W admin.py dodaj następujące wiersze:

 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 importuje funkcjonalność administratora z Django, a następnie zaimportowaliśmy dwie klasy z naszego models.py i zarejestrowaliśmy je, aby administrator mógł wykonywać akcje CRUD na produktach i zamawiać z pulpitu nawigacyjnego.

Po zarejestrowaniu modeli Twój dashboard powinien wyglądać tak:

Dodawanie produktów:

Składanie zamówień z panelu administracyjnego:

Łatwe wyznaczanie tras

Każda witryna potrzebuje trasy lub adresów URL prowadzących do określonych stron z określonymi informacjami dla użytkownika końcowego. Zbiory podobnych informacji lub aplikacji są dostępne na określonej trasie. Istnieje potrzeba grupowania tras w celu zapewnienia dostępności i komunikacji w plikach. Django zrobił to za Ciebie w pliku urls.py

urls.py to plik prowadzący od zmiennej ROOT_CONF w settings.py . Tutaj odbywa się nasza konfiguracja głównego adresu URL. Kiedy tworzymy widoki w różnych plikach lub folderach, a nawet w pliku urls.py , należy je skonfigurować na liście urlpatterns .

Django oczekuje w pliku listy o nazwie urlpatterns . Możesz zmienić plik w zmiennej ROOT_CONF na dowolny inny plik, w którym umieściłeś listę urlpatterns .

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

Lista składa się z obiektów będących wystąpieniami path lub re-path . Każde wystąpienie ma dwa parametry obowiązkowe, wzorzec 'admin/' oraz plik widoku lub adresu URL admin.site.urls .

Instancje mogą również prowadzić do innego pliku z większą liczbą konfiguracji adresów URL. Odbywa się to dla czytelności.

views.py

Ważną potrzebą aplikacji backendowej są widoki, do których mapowana jest każda trasa. W Django piszesz widoki oparte na funkcjach lub klasach dla aplikacji w pliku views.py . Widok to klasa lub funkcja, która przetwarza żądanie i odsyła odpowiedź do użytkownika.

Edytuj swój plik views.py do tego:

 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!")

Tutaj zaimportowaliśmy HTTPResponse , aby użyć go do zdefiniowania dwóch widoków (widoków funkcji), aby zwrócić zdanie po wywołaniu. def home należy wywołać, gdy odwiedzasz adres główny, a def order gdy uzyskujesz dostęp do adresu URL zamówienia.

Po utworzeniu naszych widoków musimy przypisać go do różnych tras (lub urlpatterns ). Można to zrobić na kilka sposobów, możemy utworzyć listę urlpatterns w tym samym pliku lub możemy zaimportować trading.views do pliku ecommerce_site.urls i utworzyć ścieżkę.

Preferowanym sposobem na to jest utworzenie pliku konfiguracyjnego podrzędnego adresu URL ( trading wewnętrzne) i uwzględnienie go w ecommerce_site.urls . Utwórz plik urls.py w katalogu trading . Twój katalog powinien wyglądać tak:

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

Dodaj następujący kod do nowego pliku ( urls.py )

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

Zarejestrujmy plik konfiguracyjny adresu URL trading ( urls.py ) w pliku konfiguracyjnym adresów URL projektu,

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

Aby mieć dostęp do urlpatterns , użyjemy klasy include z django.urls w wierszu 2. Następnie wybierzemy wzorzec i dodamy plik urls.py w katalogu handlowym.

To, co tutaj zrobiliśmy, to zaimportowanie klasy path z django i pliku views.py . Następnie nasza lista składa się z dwóch instancji ścieżki dla każdego widoku. Więc def home nazywa się https://127.0.0.1:8000/.

def order jest wywoływana pod adresem https://127.0.0.1:8000/order/.

Uwaga: Proces uruchamiania startproject i startapp nie jest obowiązkowy, ale bardzo zachęcany przez Django. I możesz tworzyć/przenosić pliki i foldery po uruchomieniu każdego polecenia dla wygody pracy.

Drzewo zależności

Oto proces, w którym Django przetwarza żądania z przychodzących adresów URL:

1. Django szuka głównej lokalizacji (ścieżki) dla Twoich adresów URL w zmiennej ROOT_CONF .
2. Django ładuje plik Pythona podany w podanej ścieżce. I lokalizuje zmienną urlpatterns , jest to lista zawierająca wszystkie wystąpienia django.urls.path() i/lub django.urls.re_path() .
3. Na liście Django układa się w porządku i szuka pasującego adresu URL.
4. Python, importuje i wywołuje widok (widok oparty na funkcjach lub na klasach). Co jest dalej przekazywane wraz z żądaniem HTTP.
5. Widok przetwarza żądanie i przekazane informacje oraz zwraca wiadomość/szablon lub przekierowuje do innego widoku.
6. Jeśli żaden wzorzec adresu URL nie pasuje lub jeśli w dowolnym momencie tego procesu zostanie zgłoszony wyjątek, Django wywołuje odpowiedni widok obsługi błędów.

Wniosek

Dowiedzieliśmy się o możliwości tworzenia plików dla Django bez wiersza poleceń. Poznaliśmy również zalety i podstawę projektu Django. Django to niesamowite narzędzie do budowania projektów backendowych, które ma na celu stworzenie prostoty.

Możesz sprawdzić kod tego samouczka w serwisie GitHub.

Zasoby

• Zarządzanie hasłami w Django
• Django: Pierwsze kroki
• Django: Ustawienia
• Lekkie Django autorstwa O'Reilly