Poniższy artykuł przedstawi Tobie sposób tworzenia i podstawowej konfiguracji aplikacji webowej w Django (stworzymy jak każdy, bloga). Nie będziemy się tutaj za bardzo rozdrabniać z wersją i użyjemy najnowszej: aktualnie Django 2.0.2.

Jak zawsze, zalecam przejrzeć kurs na oficjalnej stronie Django, autorzy tworzą tam prostą aplikację do głosowania. Poznasz z niego podstawowe mechanizmy frameworka oraz flow pracy z nim.

W Django pierwsze rezultaty przychodzą naprawdę szybko. 30 minut roboty i masz postawionego bardzo prostego bloga. Ale wyluzuj, zanim zaczniesz sobie wymyślać coraz to głupsze rzeczy do roboty, zapoznaj się mniej więcej z dokumentacją i kluczowymi komponentami, aby potem nie zrezygnować  na kolejne pół roku 🙂

Co będzie nam potrzebne?

Trzy rzeczy:

  1. Zainstalowany najnowszego pythona (do pobrania stąd / jak masz linuxa to możesz olać sprawę, na 99% masz go już zainstalowanego).
  2. Zainstalowany Virtualenv: wirtualne środowisko uruchomieniowe dla Python
  3. Jakieś porządne IDE – w ostateczności może być notepad++, sublime text, ale najlepiej zainstalować PyCharm Community Edition (darmowa wersja)

Podstawowe informacje na temat Django.

Każdy serwis, strona czy inny element stworzony w Django to projekt – katalog zawierający cały kod strony. Każdy projekt zawiera aplikacje: np. aplikacja bloga, aplikacja forum czy jakiegoś kalkulatora.

Podobnie jak w np. Symfony w Django mamy jeden z najważniejszych plików: manage.py, to za jego pomocą będziemy wykonywać migrację, tworzyć admina, odpalać testy czy serwer. Wpisz sobie python manage.py i sprawdź jakie możliwości ma skrypt.

Drugą ważną rzeczą w frameworku Django jest plik settings.py. Jest to kręgosłup naszego projektu. To w nim podpinamy bazę danych, ustawiamy strefy czasowe, podpinamy wszystkie utworzone aplikacje i middleware. Przejrzyj sobie plik by sprawdzić z czym to się je.

Trzecią ogromną zaletą Django jest automatycznie generowany panel admina pod adresem /admin, w którym możemy podpinać nasze modele z danymi. Panel Admina można modyfikować, dorabiać kolejne widoki, funkcję i przeróżne filtry. W kolejnych artykułach na pewno się nim zajmiemy. To co jest ważne, nie przyzwyczajaj się do niego 🙂 z czasem spróbuj sobie sam stworzyć taki panel, sporo się wtedy nauczysz (o bibliotece auth i innych).

Podstawowa struktura naszej aplikacji

Każda aplikacja w naszym projekcie ma kilka automatycznie generowanych plików. Opiszmy je sobie:

  • models.py: plik modeli aplikacji (każdy model opisuje tabelę w bazie danych, np. model postów blogowych)
  • views.py: plik zawierający kod klasy widoków. Widoki podpięte są pod konkretne adresy URL, pod którymi zwracane są szablony html
  • tests.py: ten plik zawiera testy naszej aplikacji. Nie jest konieczny, ale warto byś w przyszłości go zapełniał, na rozmowach kwalifikacyjnych przydatna umiejętność 🙂
  • admin.py: panel admina, to w nim możemy podpinać nasze modele by w przyszłości dynamicznie je edytować, dodawać i usuwać
  • urls.py: z czasem na pewno stworzymy ten plik, to w nim będziemy tworzyć konkretne URL w naszej aplikacji
  • forms.py: w tym pliku będziemy tworzyć formularze, które będą przyjmować od nas dane do zapisu do bazy lub innych niestandardowych rzeczy

Oczywiście plików będzie więcej, ale niech te Cię najbardziej zainteresują na sam początek.

Instalacja Środowiska Wirtualnego oraz podstawowa konfiguracja Django

Czas w końcu postawić pierwszą aplikację w Django. Zacznijmy od instalacji środowiska wirtualnego oraz podstawowej konfiguracji Django. Wszystkie polecenia będą wykonywane we wcześniej utworzonym katalogu ‘Projekt’.

To pora zainstalować środowisko (virtualenv env) i je uruchomić (env/scripts/activate) – moje będzie nazywać się po prostu ‘env’. Lecz możesz je nazwać jak tylko chcesz…

PS C:\Users\pawel\desktop\projekt> virtualenv env

Using base prefix 'c:\\users\\pawel\\appdata\\local\\programs\\python\\python36-32'

New python executable in C:\Users\pawel\desktop\projekt\env\Scripts\python.exe

Installing setuptools, pip, wheel...done.

PS C:\Users\pawel\desktop\projekt> env/scripts/activate

(env) PS C:\Users\pawel\desktop\projekt>

Wszystko działa, poznasz to po nazwie swojego środowiska w nawiasach przed ścieżką (env). Kolejnym krokiem jest zainstalowanie Django (pip install Django).

(env) PS C:\Users\pawel\desktop\projekt> pip install django

Collecting django

 Using cached Django-2.0.2-py3-none-any.whl

Collecting pytz (from django)

 Downloading pytz-2018.3-py2.py3-none-any.whl (509kB)

    100% |████████████████████████████████| 512kB 1.1MB/s

Installing collected packages: pytz, django

Successfully installed django-2.0.2 pytz-2018.3

(env) PS C:\Users\pawel\desktop\projekt>

Wszystko poszło jak należy. Czas utworzyć nasz hub, czyli folder, w którym będzie podstawowa konfiguracja naszej aplikacji (django-admin startproject mysite).

(env) PS C:\Users\pawel\desktop\projekt> django-admin startproject mysite

(env) PS C:\Users\pawel\desktop\projekt\mysite>

Stworzył nam się folder, w którym mamy plik manage.py, pisałem o nim wyżej. Oraz folder mysite, który zawiera trzy ważne pliki:

  • settings.py – konfiguracja naszego projektu, – podpięta baza danych, strefy czasowe, ścieżki do projektów i inne ważne rzeczy
  • urls.py – w tym pliku podłączamy adresy poszczególnych stworzonych aplikacji wewnątrz projektu (np. admin, blog, forum etc.)
  • wsgi.py – WSGI to interfejs. To tylko specyfikacja lub zestaw reguł dla serwera. Ten plik zainteresuje Cię jak będziesz chciał umieścić swoją aplikację na serwerze.

No to teraz czas na stworzenie naszej pierwszej aplikacji wewnątrz projektu (python manage.py startapp blog). Wszystkie ważne rzeczy w Django będziesz wykonywał na pliku manage.py – jak miałeś doczynienia np. z Symfony lub Laravel schemat będzie Ci znajomy.

(env) PS C:\Users\pawel\desktop\projekt\mysite> python manage.py startapp blog

Opis podstawowych elementów aplikacji został opisany kilka akapitów wyżej.

Django na starcie ma podłączoną bazę danych SQLite (przejrzyj manage.py i znajdź słownik DATABASE). Na start wystarczy.

Piszę o tym ponieważ musimy wykonać tzw. pierwsza migrację, czyli stworzyć wszystkie podstawowe tabele związane z użytkownikami i elementami Django (python manage.py migrate).

(env) PS C:\Users\pawel\desktop\projekt\mysite> python manage.py migrate

Operations to perform:

 Apply all migrations: admin, auth, contenttypes, sessions

Running migrations:

 Applying contenttypes.0001_initial... OK

 Applying auth.0001_initial... OK

 Applying admin.0001_initial... OK

 Applying admin.0002_logentry_remove_auto_add... OK

 Applying contenttypes.0002_remove_content_type_name... OK

 Applying auth.0002_alter_permission_name_max_length... OK

 Applying auth.0003_alter_user_email_max_length... OK

 Applying auth.0004_alter_user_username_opts... OK

 Applying auth.0005_alter_user_last_login_null... OK

 Applying auth.0006_require_contenttypes_0002... OK

 Applying auth.0007_alter_validators_add_error_messages... OK

 Applying auth.0008_alter_user_username_max_length... OK

 Applying auth.0009_alter_user_last_name_max_length... OK

 Applying sessions.0001_initial... OK

(env) PS C:\Users\pawel\desktop\projekt\mysite>

Stwórzmy superusera / admina naszej aplikacji (python manage.py createsuperuser). U mnie jak zawsze: admin / [email protected] / admin12345678. Nic skomplikowanego.

python manage.py createsuperuser

Podłączenie aplikacji blog pod cały projekt

Oczywiście samo stworzenie aplikacji blog to nie wszystko, teraz musimy podłączyć ją pod cały projekty. Posłuży do tego nasz plik settings.py. Poszukaj czegoś takiego:

INSTALLED_APPS = [

  'django.contrib.admin',

  'django.contrib.auth',

  'django.contrib.contenttypes',

  'django.contrib.sessions',

  'django.contrib.messages',

  'django.contrib.staticfiles',

  'blog',
]

Aplikację podłączamy wpisując jej nazwę do tablicy INSTALLED_APPS. Od teraz Django wie, że coś takiego jak bloga istnieje.

No dobra, czas odpalić nasz serwer deweloperski (python manage.py runserver).

(env) PS C:\Users\pawel\desktop\projekt\mysite> python manage.py runserver

Performing system checks...


System check identified no issues (0 silenced).

February 09, 2018 - 22:00:25

Django version 2.0.2, using settings 'mysite.settings'

Starting development server at http://127.0.0.1:8000/

Quit the server with CTRL-BREAK.

Pod adresem 127.0.0.1:8000/ mamy naszą aplikację z wiadomością powitalną.

django strona

Pierwszy Hello World

Napisanie prostego projektu Hello World zajmie nam dosłownie kilka minut. Nie będziemy tutaj tworzyć żadnych modeli, tylko skorzystamy z generycznego widoku TemplateView. Klasa TemplateView odpowiada za pobranie pliku html i wyświetlenie go pod wskazanym adresem. Nic więcej.

Najpierw musimy utworzyć w folderze naszej aplikacji (blog) nowy katalog templates. To w nim będziemy umieszczać wszystkie pliki html. Jak już to zrobisz to stwórz w nim plik html pt index.html z taką treścią:

<!DOCTYPE html>

<html lang="en">

<head>

  <meta charset="UTF-8">

  <title>Title</title>

</head>

<body>

  <h1>Hello World</h1>

</body>

</html>

Teraz musimy otworzyć plik views.py i stworzyć w niej klasę, która będzie odpowiadać za pobieranie naszego pliku html.

from django.views.generic import TemplateView


class BlogIndex(TemplateView):

    template_name = ‘index.html’

W pierwszej linii musimy zaciągnąć klasę TemplateView by móc wyświetlić statyczny plik w przeglądarce. Nasza klasa BlogInex musimy dziedziczyć klasę TemplateView. template_name to zmienna, która wskazuje na plik szablonu.

Teraz musimy stworzyć adres strony głównej bloga. Stwórzy plik urls.py, i skopiuj do niego coś takiego:

from django.urls import path

from .views import BlogIndex


urlpatterns = [

  path('', BlogIndex.as_view(), name='blog-index'),

]

Path odpowiada za tworzenie naszych URL. Puste miejsce między ‘ ’ nie ma czego wskazać, czyli w ostateczności wskaże stronę główną bloga, as_view() to metoda, która najprościej mówiąc robi z naszej klasy widok rozumiany przez serwer.

Path to nowość w Django 2.0. Przedtem było klasyczne url. Moim zdaniem od v2.0 tworzenie URL jest w końcu na cywilizowanym poziomie. Dla ciekawskich re_path odpowiada za tworzenie urli według starego schematu (opiszemy różnicę w jednym z kolejnych artykułów).

Gdy już mamy stworzony adres wewnątrz naszej aplikacji to czas dołączyć naszą aplikację do głównego adresu naszego projektu.

Otwórz urls.py, z folderu mysite i skopiuj to co poniżej:

from django.contrib import admin

from django.urls import path, include


urlpatterns = [

  path('admin/', admin.site.urls),

  path('blog/', include('blog.urls')),

]

Pierwsza linia zaciąga nam panel admina, która jest pod adresem admin/. O path już pisaliśmy wyżej. Natomiast Include to metoda, która służy do dołączenia całej aplikacji konkretny adres URL, tutaj blog/.

Teraz jak odświeżysz adres 127.0.0.1:8000/blog to powinieneś ujrzeć napis Hello World. No to napisałeś najprostszą aplikację w Django.

W kolejnych artykułach rozszerzymy naszą aplikację o modele, formularze i kolejne widoki generyczne. Myślę, że w międzyczasie powstanie artykuł na temat settings.py, urli oraz wspomnianych widokach generycznych.