• 1.10
  • dev
  • Documentation version: 1.11

Django w skrócie

Jako że Django było rozwijane w dynamicznym środowisku prasowego newsroomu, zostało zaprojektowane w taki sposób, aby robić częste web-deweloperskie zadania szybko i prosto. Poniżej przedstawiamy nieformalny opis jak napisać opartą na bazie danych aplikację webową z Django.

Celem tego dokumentu jest prezentacja takiej ilości technicznej specyfiki, abyś zrozumiał jak Django działa, ale nie jest on przeznaczony do bycia tutorialem lub dokumentacją – mamy ich oboje! Kiedy będziesz gotowy, aby zacząć projekt, możesz rozpocząć tutorial lub zanurzyć się w bardziej szczegółowej dokumentacji.

Zaprojektuj swój model

Pomimo że możesz używać Django bez bazy danych, ma on wbudowany mapper obiektowo-relacyjny, za pomocą którego możesz opisać układ swojej bazy danych pythonowym kodem.

Składnia modeli danych oferuje wiele bogatych sposobów przedstawiania modeli – do tej pory było to rozwiązywanie trwających wiele lat problemów schematu bazy danych. Oto krótki przykład:

mysite/news/models.py
from django.db import models

class Reporter(models.Model):
    full_name = models.CharField(max_length=70)

    def __str__(self):              # __unicode__ on Python 2
        return self.full_name

class Article(models.Model):
    pub_date = models.DateField()
    headline = models.CharField(max_length=200)
    content = models.TextField()
    reporter = models.ForeignKey(Reporter, on_delete=models.CASCADE)

    def __str__(self):              # __unicode__ on Python 2
        return self.headline

Zainstaluj

Następnie uruchom narzędzie linii poleceń Django, aby automatycznie stworzyć tabele w bazie danych:

$ python manage.py migrate

Komenda migrate spogląda na wszystkie dostępne modele i tworzy tabele w bazie danych, jeśli jeszcze nie istnieją, oraz opcjonalnie daje wiele bogatszą kontrolę nad schematem </topics/migrations>.

Ciesz się wolnym API

Przez wolne i bogate pythonowe API masz dostęp do swoich danych. API jest tworzone w locie, nie wymaga generowania kodu:

# Import the models we created from our "news" app
>>> from news.models import Reporter, Article

# No reporters are in the system yet.
>>> Reporter.objects.all()
<QuerySet []>

# Create a new Reporter.
>>> r = Reporter(full_name='John Smith')

# Save the object into the database. You have to call save() explicitly.
>>> r.save()

# Now it has an ID.
>>> r.id
1

# Now the new reporter is in the database.
>>> Reporter.objects.all()
<QuerySet [<Reporter: John Smith>]>

# Fields are represented as attributes on the Python object.
>>> r.full_name
'John Smith'

# Django provides a rich database lookup API.
>>> Reporter.objects.get(id=1)
<Reporter: John Smith>
>>> Reporter.objects.get(full_name__startswith='John')
<Reporter: John Smith>
>>> Reporter.objects.get(full_name__contains='mith')
<Reporter: John Smith>
>>> Reporter.objects.get(id=2)
Traceback (most recent call last):
    ...
DoesNotExist: Reporter matching query does not exist.

# Create an article.
>>> from datetime import date
>>> a = Article(pub_date=date.today(), headline='Django is cool',
...     content='Yeah.', reporter=r)
>>> a.save()

# Now the article is in the database.
>>> Article.objects.all()
<QuerySet [<Article: Django is cool>]>

# Article objects get API access to related Reporter objects.
>>> r = a.reporter
>>> r.full_name
'John Smith'

# And vice versa: Reporter objects get API access to Article objects.
>>> r.article_set.all()
<QuerySet [<Article: Django is cool>]>

# The API follows relationships as far as you need, performing efficient
# JOINs for you behind the scenes.
# This finds all articles by a reporter whose name starts with "John".
>>> Article.objects.filter(reporter__full_name__startswith='John')
<QuerySet [<Article: Django is cool>]>

# Change an object by altering its attributes and calling save().
>>> r.full_name = 'Billy Goat'
>>> r.save()

# Delete an object with delete().
>>> r.delete()

Dynamiczny interfejs administracyjny: to nie tylko rusztowanie – to cały dom

Gdy twoje modele są już zdefiniowane, Django może automatycznie stworzyć profesjonalny, gotowy na produkcję interfejs administracyjny – witrynę, która pozwala uwierzytelnionym użytkownikom dodawać, zmieniać i usuwać obiekty. Wystarczy tylko zarejestrować model w witrynie administracyjnej:

mysite/news/models.py
from django.db import models

class Article(models.Model):
    pub_date = models.DateField()
    headline = models.CharField(max_length=200)
    content = models.TextField()
    reporter = models.ForeignKey(Reporter, on_delete=models.CASCADE)
mysite/news/admin.py
from django.contrib import admin

from . import models

admin.site.register(models.Article)

Filozofia tutaj jest następująca: twoja strona jest edytowana przez obsługę, klienta lub może po prostu ciebie – i nie chcesz musieć tworzyć backendowych interfejsów tylko do zarządzania treścią.

Jednym z typowych workflow w tworzeniu aplikacji Django jest stworzenie modelu i uruchomienie administracji tak szybko jak to możliwe, aby obsługa (lub klienci) mogli zacząć uzupełniać dane. Następnie, skupienie się na sposobie prezentacji tych danych odbiorcom.

Zaprojektuj swoje URL-e

Prosty, elegancki schemat URL-i jest ważnym detalem w wysokiej jakości aplikacji webowej. Django wspiera piękne projekty URL i nie dodaje żadnych wstawek do URL-i, typu .php lub .asp.

Aby zaprojektować URL-e dla aplikacji, tworzysz moduł Pythona zwany URLconf. Spis treści dla twojej aplikacji, zawiera proste mapowanie pomiędzy wzorcami URL i pythonowymi funkcjami callback. Pliki URLconf służą również do oddzielania URL-i z kodu Python.

Tak mógłby wyglądać URLconf dla powyższego przykładu Reporter/Article:

mysite/news/urls.py
from django.conf.urls import url

from . import views

urlpatterns = [
    url(r'^articles/([0-9]{4})/$', views.year_archive),
    url(r'^articles/([0-9]{4})/([0-9]{2})/$', views.month_archive),
    url(r'^articles/([0-9]{4})/([0-9]{2})/([0-9]+)/$', views.article_detail),
]

Kod powyżej mapuje URL-e, jako proste wyrażenia regularne, do lokalizacji pythonowych funkcji callback („widoków”). Wyrażenia regularne używają nawiasów, aby „zebrać” wartośc z URL-i. Gdy użytkownik wysyła żądanie strony, Django przelatuje przez wszystkie wzorce, po kolei, i zatrzymuje się na pierwszym, który spełnia żądany URL. (Jeśli żaden z nich nie pasuje, Django wywołuje specjalny widok 404.) Działa to niesamowicie szybko, gdyż wyrażenia regularne są kompilowane w czasie ładowania.

Gdy któreś z wyrażeń regularnych pasuje, Django wywołuje podany widok, który jest pythonową funkcją. Każdy widok dostaje w parametrze obiekt „request” – który zawiera metadane żądania – i wartości zebrane w wyrażeniu regularnym.

Na przykład, jeśli użytkownik zażądałby URL-a „/articles/2005/05/39323/”, Django wywołałoby funkcję news.views.article_detail(request, '2005', '05', '39323').

Napisz swoje widoki

Każdy widok jest odpowiedzialny za zrobienie jednej z dwóch rzeczy: Zwrócenie obiektu HttpResponse zawierającego treść dla żądanej strony lub rzucenie wyjątku takiego jak Http404. Reszta zależy od ciebie.

W ogólności, widok pobiera dane stosowne do parametrów, ładuje szablon i renderuje go z pobranymi danymi. Tutaj jest przykładowy widok dla year_archive z powyżej:

mysite/news/views.py
from django.shortcuts import render

from .models import Article

def year_archive(request, year):
    a_list = Article.objects.filter(pub_date__year=year)
    context = {'year': year, 'article_list': a_list}
    return render(request, 'news/year_archive.html', context)

Ten przykład wykorzystuje system szablonów Django, który ma kilka potężnych funkcji, ale stara się pozostać wystarczająco prosty w użyciu dla nie-programistów.

Zaprojektuj swoje szablony

Kod powyżej ładuje szablon news/year_archive.html.

Django ma ścieżkę wyszukiwania szablonów, która pozwala ci minimalizować redundancję pomiędzy szablonami. W swoich ustawieniach Django podajesz listę katalogów do szukania w nich szablonów z DIRS. Jeśli szablon nie istnieje w pierwszym katalogu, sprawdzany jest drugi i tak dalej.

Powiedzmy, że szablon news/year_archive.html został odnaleziony. Tak mógłby wyglądać:

mysite/news/templates/news/year_archive.html
{% extends "base.html" %}

{% block title %}Articles for {{ year }}{% endblock %}

{% block content %}
<h1>Articles for {{ year }}</h1>

{% for article in article_list %}
    <p>{{ article.headline }}</p>
    <p>By {{ article.reporter.full_name }}</p>
    <p>Published {{ article.pub_date|date:"F j, Y" }}</p>
{% endfor %}
{% endblock %}

Zmienne są otoczone podwójnymi nawiasami klamrowymi. {{ article.headline }} znaczy „wypisz wartość atrybutu »headline« artykułu”. Ale kropki nie są używane tylko do odwoływania się do atrybutów. Mogą one być odwołaniami do klucza w słowniku, do indeksu tablicy i wywołaniami funkcji.

Zwróć uwagę, że {{ article.pub_date|date:"F j, Y" }} używa uniksowego „pipe” (znak „|”). Jest on nazywany filtrem szablonu i jest sposobem na przefiltrowanie wartości zmiennej. W tym przypadku filtr „date” formatuje pythonowy obiekt datetime do żądanego formatu (tak jak w funkcji „date” w PHP).

Możesz układać w łańcuchy tyle filtrów, na ile masz ochotę. Możesz napisać własne filtry szablonów, które uruchamiają pod spodem własny kod Pythona.

I na koniec, Django wykorzystuje koncept „dziedziczenia szablonów”. To to co robi {% extends "base.html" %}. To znaczy „najpierw załaduj szablon nazwany »base«, który definiuje zestaw bloków i wypełnij te bloki poniższymi blokami”. W skrócie, pozwoli to drastycznie wyciąć powtórzenia w szablonach: każdy szablon musi definiować tylko to, co jest dla niego unikalne.

Tak może wyglądać szablon „base.html”, wliczając użycie plików statycznych:

mysite/templates/base.html
{% load static %}
<html>
<head>
    <title>{% block title %}{% endblock %}</title>
</head>
<body>
    <img src="{% static "images/sitelogo.png" %}" alt="Logo" />
    {% block content %}{% endblock %}
</body>
</html>

Prostszymi słowami, definiuje on look-and-feel strony (z logiem strony) i zawiera „dziury” do wypełnienia przez szablony-dzieci. To powoduje, że redesign strony sprowadza się do zmiany w jednym pliku – szablonie bazowym.

Pozwala ci także stworzyć wiele wersji strony, z różnymi szablonami bazowymi, w czasie gdy wykorzystujesz te same szablony-dzieci. Twórcy Django użyli tej techniki, by stworzyć kompletnie inne mobilne wersje stron – po prostu przez stworzenie nowych szablonów bazowych.

Zwróć uwgę, że nie musisz używać systemu szablonów Django jeśli wolisz inny system. Pomimo że system szablonów Django jest szczególnie dobrze zintegrowany z warstwą modelu Django, nic nie zmusza cię do jego używania. Tak naprawdę nie musisz używać też bazodanowego API Django. Możesz użyć inną warstwę abstrakcji bazy danych, możesz czytać pliki XML, możesz czytać pliki z dysku lub cokolwiek co chcesz. Każdy kawałek Django – modele, widoki, szablony – jest rozdzielony od następnego.

To tylko powierzchnia

To był tylko szybki przegląd funkcjonalności Django. Niektóre bardziej przydatne funkcje:

  • Framework cache’owania, który integruje się z Memcached lub innymi back-endami.
  • Framework syndykacyjny, który sprowadza tworzenie feedów RSS i Atom do napisania małej klasy w Pythonie.
  • Bardziej seksowne automatycznie wygenerowane funkcje panelu administracyjnego – ten przegląd ledwo musnął powierzchnię.

Następne kroki w sposób oczywisty to pobranie Django, przeczytanie tutoriala i dołączenie do społeczności. Dziękujemy za zainteresowanie!

Back to Top