Django Tutorial
Iniziare con Django

Osservazioni

Versioni

Avvio di un progetto

Django è un framework di sviluppo web basato su Python. Django 1.11 (l'ultima versione stabile) richiede l'installazione di Python 2.7 , 3.4 , 3.5 o 3.6 . Supponendo che pip sia disponibile, l'installazione è semplice come eseguire il seguente comando. Tieni presente che, omettendo la versione come mostrato di seguito, verrà installata l'ultima versione di django:

$ pip install django

Per installare una versione specifica di django, supponiamo che la versione sia django 1.10.5 , esegui il seguente comando:

$ pip install django==1.10.5

Le applicazioni Web create con Django devono risiedere all'interno di un progetto Django. È possibile utilizzare il comando django-admin per avviare un nuovo progetto nella directory corrente:

$ django-admin startproject myproject

dove myproject è un nome che identifica in modo univoco il progetto e può essere composto da numeri , lettere e caratteri di sottolineatura .

Questo creerà la seguente struttura di progetto:

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

Per eseguire l'applicazione, avviare il server di sviluppo

$ cd myproject
$ python manage.py runserver

Ora che il server è in esecuzione, visita http://127.0.0.1:8000/ con il browser web. Vedrai la seguente pagina:

Per impostazione predefinita, il comando runserver avvia il server di sviluppo sull'IP interno sulla porta 8000 . Questo server si riavvierà automaticamente quando apporti modifiche al tuo codice. Ma nel caso si aggiungano nuovi file, sarà necessario riavviare manualmente il server.

Se si desidera modificare la porta del server, passarla come argomento della riga di comando.

$ python manage.py runserver 8080

Se si desidera modificare l'IP del server, passarlo insieme alla porta.

$ python manage.py runserver 0.0.0.0:8000

Nota che runserver è solo per le build di debug e test locali. I programmi server specializzati (come Apache) dovrebbero sempre essere utilizzati in produzione.

Aggiunta di un'app Django

Un progetto Django di solito contiene più apps . Questo è semplicemente un modo per strutturare il tuo progetto in moduli più piccoli e manutenibili. Per creare un'app, vai alla tua cartella di progetto (dove manage.py è), ed esegui il comando startapp (cambia myapp in quello che vuoi):

python manage.py startapp myapp

Questo genererà la cartella myapp e alcuni file necessari per te, come models.py e views.py .

Per rendere Django consapevole di myapp , aggiungilo alle tue settings.py :

# myproject/settings.py

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

La struttura di cartelle di un progetto Django può essere modificata in base alle tue preferenze. A volte la cartella del progetto viene rinominata in /src per evitare di ripetere i nomi delle cartelle. Una tipica struttura di cartelle si presenta così:

Concetti di Django

django-admin è uno strumento da riga di comando fornito con Django. Viene fornito con diversi comandi utili per iniziare e gestire un progetto Django. Il comando è lo stesso di ./manage.py , con la differenza che non è necessario essere nella directory del progetto. La variabile di ambiente DJANGO_SETTINGS_MODULE deve essere impostata.

Un progetto Django è un codice Python che contiene un file di impostazioni Django. Un progetto può essere creato dall'amministratore di Django tramite il comando django-admin startproject NAME . manage.py il progetto ha un file chiamato manage.py al livello più alto e un file URL di root chiamato urls.py manage.py è una versione specifica del progetto di django-admin e consente di eseguire comandi di gestione su quel progetto. Ad esempio, per eseguire il progetto localmente, utilizzare python manage.py runserver . Un progetto è costituito da app Django.

models.py Django è un pacchetto Python che contiene un file di modelli ( models.py per impostazione predefinita) e altri file come URL e viste specifici dell'app. django-admin startapp NAME può essere creata tramite il comando django-admin startapp NAME (questo comando dovrebbe essere eseguito all'interno della directory del progetto). Affinché un'app faccia parte di un progetto, deve essere inclusa nell'elenco INSTALLED_APPS in settings.py . Se hai usato la configurazione standard, Django viene fornito con diverse app delle sue app preinstallate che gestiranno cose come l' autenticazione per te. Le app possono essere utilizzate in più progetti Django.

Django ORM raccoglie tutti i modelli di database definiti in models.py e crea tabelle di database in base a tali classi di modelli. Per fare ciò, innanzitutto, imposta il tuo database modificando l'impostazione DATABASES in settings.py . Quindi, una volta definiti i modelli di database , eseguire python manage.py makemigrations seguito da python manage.py migrate per creare o aggiornare lo schema del database in base ai modelli.

Un esempio di ciao mondo completo.

Passaggio 1 Se hai già installato Django, puoi saltare questo passaggio.

pip install Django

Passaggio 2 Creare un nuovo progetto

django-admin startproject hello

Questo creerà una cartella chiamata hello che conterrà i seguenti file:

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

Passaggio 3 All'interno del modulo hello (la cartella contenente __init.py__ ) crea un file chiamato views.py :

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

e inserire il seguente contenuto:

from django.http import HttpResponse

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

Questa è chiamata funzione di visualizzazione.

Passaggio 4 Modifica hello/urls.py come segue:

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)
]

che collega la funzione view hello() a un URL.

Passaggio 5 Avviare il server.

python manage.py runserver

Passaggio 6

Passare a http://localhost:8000/ in un browser e vedrete:

Ciao mondo

Ambiente virtuale

Sebbene non sia strettamente necessario, si consiglia vivamente di avviare il progetto in un "ambiente virtuale". Un ambiente virtuale è un contenitore (una directory) che contiene una versione specifica di Python e un insieme di moduli (dipendenze), e che non interferisce con il Python nativo del sistema operativo o altri progetti sullo stesso computer.

Impostando un ambiente virtuale diverso per ogni progetto su cui lavori, vari progetti di Django possono essere eseguiti su diverse versioni di Python e possono mantenere i loro set di dipendenze, senza il rischio di conflitti.

Python 3.3+

Python 3.3+ include già un modulo venv standard, che di solito si chiama pyvenv . In ambienti in cui il comando pyvenv non è disponibile, è possibile accedere alla stessa funzionalità invocando direttamente il modulo come python3 -m venv .

Per creare l'ambiente virtuale:

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

Python 2

Se si utilizza Python 2, è possibile prima installarlo come un modulo separato da pip:

$ pip install virtualenv

E quindi creare l'ambiente usando invece il comando virtualenv :

$ virtualenv <env-folder>

Attiva (qualsiasi versione)

L'ambiente virtuale è ora impostato. Per poterlo utilizzare, deve essere attivato nel terminale che si desidera utilizzare.

Per 'attivare' l'ambiente virtuale (qualsiasi versione di Python)

Linux come:

$ source <env-folder>/bin/activate

Windows come:

<env-folder>\Scripts\activate.bat

Questo cambia la tua richiesta di indicare che l'ambiente virtuale è attivo. (<env-folder>) $

D'ora in poi, tutto ciò che verrà installato usando pip sarà installato nella tua cartella env virtuale, non in tutto il sistema.

Per abbandonare l'ambiente virtuale usa deactivate :

(<env-folder>) $ deactivate

In alternativa: usa virtualenvwrapper

Potresti anche considerare l'utilizzo di virtualenvwrapper che rende molto utile la creazione e l'attivazione di virtualenv e la separazione dal codice:

# Create a virtualenv
mkvirtualenv my_virtualenv

# Activate a virtualenv
workon my_virtualenv

# Deactivate the current virtualenv
deactivate

In alternativa: usa pyenv + pyenv-viritualenv

Negli ambienti in cui è necessario gestire più versioni Python, è possibile trarre vantaggio da virtualenv con 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

Quando si usano virtualenvs, è spesso utile impostare PYTHONPATH e DJANGO_SETTINGS_MODULE nello script 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"

Imposta il tuo percorso del progetto

Spesso è anche utile impostare il percorso del progetto all'interno di uno speciale file .project che si trova nella tua base <env-folder> . Quando lo fai, ogni volta che attivi il tuo ambiente virtuale, cambierà la directory attiva nel percorso specificato.

Crea un nuovo file chiamato <env-folder>/.project . Il contenuto del file dovrebbe essere SOLO il percorso della directory del progetto.

/path/to/project/directory

Ora avvia il tuo ambiente virtuale (usando source <env-folder>/bin/activate o workon my_virtualenv ) e il tuo terminale cambierà directory in /path/to/project/directory .

Esempio di file singolo Hello World

Questo esempio mostra un modo minimo per creare una pagina Hello World in Django. Questo ti aiuterà a capire che il comando di django-admin startproject example crea fondamentalmente un sacco di cartelle e file e che non hai necessariamente bisogno di quella struttura per eseguire il tuo progetto.

1. Crea un file chiamato file.py

2. Copia e incolla il seguente codice in quel file.

    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. Vai al terminale ed esegui il file con questo comando python file.py runserver .

4. Apri il browser e vai su 127.0.0.1:8000 .

Progetto di facile impiego con supporto Docker.

Il modello di progetto Django di default va bene, ma una volta che hai implementato il tuo codice e per esempio gli sviluppatori hanno messo le mani sul progetto, le cose si complicano. Quello che puoi fare è separare il tuo codice sorgente dal resto che è necessario che sia nel tuo repository.

Puoi trovare un modello di progetto Django utilizzabile su GitHub .

Struttura del progetto

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

Mi piace mantenere la directory dei service denominata service per ogni progetto grazie al fatto che posso utilizzare lo stesso Dockerfile su tutti i miei progetti. La suddivisione dei requisiti e delle impostazioni è già ben documentata qui:
Utilizzo di più file di requisiti
Utilizzando più impostazioni

Dockerfile

Partendo dal presupposto che solo gli sviluppatori fanno uso di Docker (non tutti gli sviluppatori si fidano di questi tempi). Questo potrebbe essere un dev devel.dockerfile dell'ambiente di 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"]

L'aggiunta di soli requisiti consentirà di sfruttare la cache Docker durante la creazione: sarà necessario ricostruire solo in base alla modifica dei requisiti.

Comporre

La composizione di Docker è utile, specialmente quando si dispone di più servizi per l'esecuzione locale. 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

Il tuo ambiente di sviluppo dovrebbe essere il più vicino possibile all'ambiente prod, quindi mi piace usare Nginx sin dall'inizio. Ecco un esempio di file di configurazione di 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/;
    }
}

uso

$ 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