Django Samouczek
Rozpoczęcie pracy z Django

Uwagi

Wersje

Rozpoczęcie projektu

Django to framework programistyczny oparty na języku Python. Django 1.11 (najnowsza stabilna wersja) wymaga zainstalowania Python 2.7 , 3.4 , 3.5 lub 3.6 . Zakładając, że pip jest dostępny, instalacja jest tak prosta, jak uruchomienie następującego polecenia. Pamiętaj, że pominięcie wersji pokazanej poniżej spowoduje zainstalowanie najnowszej wersji django:

$ pip install django

Aby zainstalować konkretną wersję django, załóżmy, że jest to wersja django 1.10.5 , uruchom następującą komendę:

$ pip install django==1.10.5

Aplikacje internetowe zbudowane przy użyciu Django muszą znajdować się w projekcie Django. Możesz użyć polecenia django-admin aby rozpocząć nowy projekt w bieżącym katalogu:

$ django-admin startproject myproject

gdzie myproject to nazwa, która jednoznacznie identyfikuje projekt i może składać się z cyfr , liter i znaków podkreślenia .

Spowoduje to utworzenie następującej struktury projektu:

myproject/
    manage.py
    myproject/
        __init__.py
        settings.py
        urls.py
        wsgi.py

Aby uruchomić aplikację, uruchom serwer programistyczny

$ cd myproject
$ python manage.py runserver

Teraz, gdy serwer działa, odwiedź http://127.0.0.1:8000/ w przeglądarce internetowej. Zobaczysz następującą stronę:

Domyślnie polecenie runserver uruchamia serwer programistyczny na wewnętrznym adresie IP na porcie 8000 . Serwer zostanie automatycznie zrestartowany po wprowadzeniu zmian w kodzie. Ale w przypadku dodania nowych plików konieczne będzie ręczne zrestartowanie serwera.

Jeśli chcesz zmienić port serwera, przekaż go jako argument wiersza polecenia.

$ python manage.py runserver 8080

Jeśli chcesz zmienić adres IP serwera, przekaż go wraz z portem.

$ python manage.py runserver 0.0.0.0:8000

Zauważ, że runserver służy tylko do kompilacji debugowania i testowania lokalnego. Specjalistyczne programy serwerowe (takie jak Apache) powinny zawsze być używane w środowisku produkcyjnym.

Dodawanie aplikacji Django

Projekt Django zwykle zawiera wiele apps . Jest to po prostu sposób na uporządkowanie projektu w mniejsze, łatwe do utrzymania moduły. Aby utworzyć aplikację, przejdź do folderu projektu (gdzie znajduje się manage.py ) i uruchom komendę startapp (zmień myapp na cokolwiek chcesz):

python manage.py startapp myapp

Spowoduje to wygenerowanie folderu myapp i niektórych niezbędnych plików, takich jak models.py i views.py .

Aby Django wiedział o mojej aplikacji , dodaj ją do pliku settings.py :

# myproject/settings.py

# Application definition
INSTALLED_APPS = [
    ...
    'myapp',
]

Strukturę folderów projektu Django można zmienić zgodnie z własnymi preferencjami. Czasami nazwa folderu projektu jest zmieniana na /src aby uniknąć powtarzania nazw folderów. Typowa struktura folderów wygląda następująco:

Koncepcje Django

django-admin to narzędzie wiersza polecenia dostarczane z Django. Zawiera kilka użytecznych poleceń do rozpoczęcia i zarządzania projektem Django. Polecenie jest takie samo jak ./manage.py , z tą różnicą, że nie musisz znajdować się w katalogu projektu. Należy DJANGO_SETTINGS_MODULE zmienną środowiskową DJANGO_SETTINGS_MODULE .

Projekt Django jest bazą kodu Python, która zawiera plik ustawień Django. Projekt może zostać utworzony przez administratora Django za pomocą komendy django-admin startproject NAME . Projekt zazwyczaj ma plik najwyższego poziomu o nazwie manage.py i główny plik URL o nazwie urls.py manage.py to specyficzna dla projektu wersja programu django-admin , która umożliwia uruchamianie poleceń zarządzania dla tego projektu. Na przykład, aby uruchomić projekt lokalnie, użyj python manage.py runserver . Projekt składa się z aplikacji Django.

Aplikacja Django to pakiet Python zawierający plik modeli (domyślnie models.py ) i inne pliki, takie jak adresy URL i widoki specyficzne dla aplikacji. Aplikację można utworzyć za pomocą komendy django-admin startapp NAME (ta komenda powinna zostać uruchomiona z katalogu projektu). Aby aplikacja była częścią projektu, musi znajdować się na liście INSTALLED_APPS w pliku settings.py . Jeśli korzystałeś ze standardowej konfiguracji, Django ma fabrycznie zainstalowanych kilka własnych aplikacji, które zajmą się na przykład uwierzytelnieniem . Z aplikacji można korzystać w wielu projektach Django.

Django ORM zbiera wszystkie modele baz danych zdefiniowane w models.py i tworzy tabele baz danych na podstawie tych klas modeli. Aby to zrobić, najpierw skonfiguruj bazę danych, modyfikując ustawienie DATABASES w DATABASES settings.py . Następnie, po zdefiniowaniu modeli baz danych , uruchom python manage.py makemigrations a następnie python manage.py migrate aby utworzyć lub zaktualizować schemat bazy danych na podstawie modeli.

Kompletny przykład witaj na świecie.

Krok 1 Jeśli masz już zainstalowany Django, możesz pominąć ten krok.

pip install Django

Krok 2 Utwórz nowy projekt

django-admin startproject hello

Spowoduje to utworzenie folderu o nazwie hello który będzie zawierał następujące pliki:

hello/
├── hello/
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
└── manage.py

Krok 3 W module hello (folder zawierający __init.py__ ) utwórz plik o nazwie views.py :

hello/
├── hello/
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   ├── views.py  <- here
│   └── wsgi.py
└── manage.py

i wprowadź następującą treść:

from django.http import HttpResponse

def hello(request):
    return HttpResponse('Hello, World')

Nazywa się to funkcją widoku.

Krok 4 Edytuj hello/urls.py w następujący sposób:

from django.conf.urls import url
from django.contrib import admin
from hello import views

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^$', views.hello)
]

który łączy funkcję widoku hello() z adresem URL.

Krok 5 Uruchom serwer.

python manage.py runserver

Krok 6

Przejdź do http://localhost:8000/ w przeglądarce, a zobaczysz:

Witaj świecie

Wirtualne środowisko

Chociaż nie jest to bezwzględnie wymagane, zdecydowanie zaleca się rozpoczęcie projektu w „środowisku wirtualnym”. Środowisko wirtualne to kontener (katalog), który zawiera określoną wersję Pythona i zestaw modułów (zależności) i który nie koliduje z natywnym systemem operacyjnym Python lub innymi projektami na tym samym komputerze.

Poprzez skonfigurowanie innego środowiska wirtualnego dla każdego projektu, nad którym pracujesz, różne projekty Django mogą działać na różnych wersjach Pythona i mogą utrzymywać własne zestawy zależności bez ryzyka konfliktu.

Python 3.3+

Python 3.3+ zawiera już standardowy moduł venv , który zwykle można nazwać pyvenv . W środowiskach, w których polecenie pyvenv nie jest dostępne, można uzyskać dostęp do tej samej funkcji, bezpośrednio wywołując moduł jako python3 -m venv .

Aby utworzyć środowisko wirtualne:

$ pyvenv <env-folder>
# Or, if pyvenv is not available
$ python3 -m venv <env-folder>

Python 2

Jeśli używasz Python 2, możesz najpierw zainstalować go jako osobny moduł niż pip:

$ pip install virtualenv

A następnie utwórz środowisko za pomocą polecenia virtualenv :

$ virtualenv <env-folder>

Aktywuj (dowolna wersja)

Środowisko wirtualne jest teraz skonfigurowane. Aby go użyć, należy go aktywować w terminalu, z którego chcesz go korzystać.

Aby „aktywować” środowisko wirtualne (dowolna wersja Python)

Linux jak:

$ source <env-folder>/bin/activate

Windows jak:

<env-folder>\Scripts\activate.bat

To zmienia monit o wskazanie, że środowisko wirtualne jest aktywne. (<env-folder>) $

Od teraz wszystko zainstalowane za pomocą pip będzie instalowane w twoim wirtualnym folderze env, a nie w całym systemie.

Aby wyjść ze środowiska wirtualnego, użyj opcji deactivate :

(<env-folder>) $ deactivate

Alternatywnie: użyj virtualenvwrapper

Możesz również rozważyć użycie virtualenvwrapper, który sprawia, że tworzenie i aktywacja virtualenv jest bardzo przydatne, a także oddzielenie go od kodu:

# Create a virtualenv
mkvirtualenv my_virtualenv

# Activate a virtualenv
workon my_virtualenv

# Deactivate the current virtualenv
deactivate

Alternatywnie: użyj pyenv + pyenv-viritualenv

W środowiskach, w których musisz obsługiwać wiele wersji Pythona, możesz korzystać z virtualenv wraz z pyenv-virtualenv:

# Create a virtualenv for specific Python version
pyenv virtualenv 2.7.10 my-virtual-env-2.7.10

# Create a vritualenv for active python verion
pyenv virtualenv venv34

# Activate, deactivate virtualenv
pyenv activate <name>
pyenv deactivate

Podczas korzystania z virtualenvs często przydatne jest ustawienie PYTHONPATH i DJANGO_SETTINGS_MODULE w skrypcie postactivate .

#!/bin/sh
# This hook is sourced after this virtualenv is activated

# Set PYTHONPATH to isolate the virtualenv so that only modules installed
# in the virtualenv are available
export PYTHONPATH="/home/me/path/to/your/project_root:$VIRTUAL_ENV/lib/python3.4"

# Set DJANGO_SETTINGS_MODULE if you don't use the default `myproject.settings`
# or if you use `django-admin` rather than `manage.py`
export DJANGO_SETTINGS_MODULE="myproject.settings.dev"

Ustaw ścieżkę projektu

Często pomocne jest również ustawienie ścieżki projektu w specjalnym pliku .project znajdującym się w twoim podstawowym <env-folder> . Robiąc to, za każdym razem, gdy aktywujesz środowisko wirtualne, zmieni on katalog aktywny na określoną ścieżkę.

Utwórz nowy plik o nazwie <env-folder>/.project . Zawartość pliku powinna być TYLKO ścieżką do katalogu projektu.

/path/to/project/directory

Teraz zainicjuj swoje środowisko wirtualne (używając source <env-folder>/bin/activate lub workon my_virtualenv ), a twój terminal zmieni katalogi na katalog /path/to/project/directory .

Przykład pojedynczego pliku Hello World

Ten przykład pokazuje minimalny sposób utworzenia strony Hello World w Django. Pomoże to uświadomić sobie, że django-admin startproject example polecenie django-admin startproject example tworzy w zasadzie kilka folderów i plików i że niekoniecznie potrzebujesz tej struktury do uruchomienia projektu.

1. Utwórz plik o nazwie file.py

2. Skopiuj i wklej następujący kod w tym pliku.

    import sys
    
    from django.conf import settings
    
    settings.configure(
        DEBUG=True,
        SECRET_KEY='thisisthesecretkey',
        ROOT_URLCONF=__name__,
        MIDDLEWARE_CLASSES=(
            'django.middleware.common.CommonMiddleware',
            'django.middleware.csrf.CsrfViewMiddleware',
            'django.middleware.clickjacking.XFrameOptionsMiddleware',
        ),
    )
    
    from django.conf.urls import url
    from django.http import HttpResponse
    
    # Your code goes below this line.
   
    def index(request):
        return HttpResponse('Hello, World!')
   
    urlpatterns = [
        url(r'^$', index),
    ]
   
    # Your code goes above this line
    
    if __name__ == "__main__":
        from django.core.management import execute_from_command_line
    
        execute_from_command_line(sys.argv)
   

3. Przejdź do terminala i uruchom plik za pomocą tego polecenia python file.py runserver .

4. Otwórz przeglądarkę i przejdź do 127.0.0.1:8000 .

Projekt przyjazny dla wdrażania ze wsparciem Docker.

Domyślny szablon projektu Django jest w porządku, ale kiedy będziesz mógł wdrożyć swój kod i na przykład deweloperzy położyli ręce na projekt, robi się bałagan. Możesz oddzielić kod źródłowy od reszty, która musi znajdować się w repozytorium.

Na GitHub można znaleźć użyteczny szablon projektu Django.

Struktura projektu

PROJECT_ROOT
├── devel.dockerfile
├── docker-compose.yml
├── nginx
│   └── project_name.conf
├── README.md
├── setup.py
└── src
    ├── manage.py
    └── project_name
        ├── __init__.py
        └── service
            ├── __init__.py
            ├── settings
            │   ├── common.py
            │   ├── development.py
            │   ├── __init__.py
            │   └── staging.py
            ├── urls.py
            └── wsgi.py

Chciałbym utrzymać service o nazwie katalogu service dla każdego projektu, dzięki, że mogę korzystać z tego samego Dockerfile we wszystkich moich projektach. Podział wymagań i ustawień jest już dobrze udokumentowany tutaj:
Korzystanie z wielu plików wymagań
Korzystanie z wielu ustawień

Plik Docker

Przy założeniu, że tylko programiści używają Dockera (nie wszyscy deweloperzy ufają mu w dzisiejszych czasach). Może to być środowisko devel.dockerfile :

FROM python:2.7
ENV PYTHONUNBUFFERED 1

RUN mkdir /run/service
ADD . /run/service
WORKDIR /run/service

RUN pip install -U pip
RUN pip install -I -e .[develop] --process-dependency-links

WORKDIR /run/service/src
ENTRYPOINT ["python", "manage.py"]
CMD ["runserver", "0.0.0.0:8000"]

Dodanie tylko wymagań zwiększy pamięć podręczną Dockera podczas budowania - wystarczy przebudować po zmianie wymagań.

Komponować

Przydaje się komponowanie Docker - zwłaszcza, gdy masz wiele usług do uruchamiania lokalnego. docker-compose.yml :

version: '2'
services:
  web:
    build:
      context: .
      dockerfile: devel.dockerfile
    volumes:
      - "./src/{{ project_name }}:/run/service/src/{{ project_name }}"
      - "./media:/run/service/media"
    ports:
      - "8000:8000"
    depends_on:
      - db
  db:
    image: mysql:5.6
    environment:
      - MYSQL_ROOT_PASSWORD=root
      - MYSQL_DATABASE={{ project_name }}
  nginx:
    image: nginx
    ports:
      - "80:80"
    volumes:
      - "./nginx:/etc/nginx/conf.d"
      - "./media:/var/media"
    depends_on:
      - web

Nginx

Twoje środowisko programistyczne powinno być jak najbardziej zbliżone do środowiska produkcyjnego, więc od samego początku lubię używać Nginx. Oto przykładowy plik konfiguracyjny nginx:

server {
    listen   80;
    client_max_body_size 4G;
    keepalive_timeout 5;

    location /media/ {
        autoindex on;
        alias /var/media/;
    }

    location / {
        proxy_pass_header Server;
        proxy_set_header Host $http_host;
        proxy_redirect off;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Scheme $scheme;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Ssl on;
        proxy_connect_timeout 600;
        proxy_read_timeout 600;
        proxy_pass http://web:8000/;
    }
}

Stosowanie

$ cd PROJECT_ROOT
$ docker-compose build web  # build the image - first-time and after requirements change
$ docker-compose up  # to run the project
$ docker-compose run --rm --service-ports --no-deps  # to run the project - and be able to use PDB
$ docker-compose run --rm --no-deps <management_command>  # to use other than runserver commands, like makemigrations
$ docker exec -ti web bash  # For accessing django container shell, using it you will be inside /run/service directory, where you can run ./manage shell, or other stuff
$ docker-compose start  # Starting docker containers
$ docker-compose stop  # Stopping docker containers