Guide de démarrage rapide avec Django : Créez votre première application Web

Django est un framework Web Python de haut niveau, conçu pour un développement rapide et une conception propre. Il suit l'architecture Modèle-Vue-Template (MTV), encourageant la réutilisation du code et la modularisation. Ce guide vous guidera pas à pas dans la création d'une application Django simple, pour vous permettre de démarrer rapidement.

1. Configuration de l'environnement

Tout d'abord, vous devez vous assurer que Python est installé sur votre système. Django recommande d'utiliser Python 3.6 ou une version ultérieure.

1.1 Installation de Python

Si Python n'est pas installé sur votre système, vous pouvez le télécharger et l'installer depuis le site officiel de Python.

1.2 Création d'un environnement virtuel (Virtual Environment)

Pour isoler les dépendances entre différents projets, il est fortement recommandé d'utiliser un environnement virtuel.

Ouvrez un terminal ou une invite de commande.
Créez un répertoire de projet, par exemple myproject :
```
mkdir myproject
cd myproject
```
Créez et activez l'environnement virtuel :
```
python3 -m venv venv  # ou python -m venv venv
source venv/bin/activate  # Linux/macOS
venv\Scripts\activate  # Windows
```
Une fois l'environnement virtuel activé, votre invite de terminal affichera (venv), indiquant que vous utilisez l'environnement virtuel.

1.3 Installation de Django

Dans l'environnement virtuel activé, utilisez pip pour installer Django :

pip install Django

Vérifiez si l'installation a réussi :

python -m django --version

Vous devriez voir le numéro de version de Django.

2. Création d'un projet Django

Après avoir installé Django, vous pouvez créer un nouveau projet Django.

Toujours dans votre répertoire de projet (myproject), exécutez la commande suivante :
```
django-admin startproject mysite
```
Cela créera un répertoire nommé mysite dans le répertoire myproject, contenant l'ossature du projet Django.
Accédez au répertoire mysite :
```
cd mysite
```
La structure du répertoire du projet Django est la suivante :
```
mysite/
    manage.py
    mysite/
        __init__.py
        settings.py
        urls.py
        asgi.py
        wsgi.py
```
- manage.py : Un outil de ligne de commande pour gérer le projet Django.
- mysite/ : Un package Python contenant la configuration du projet.
  - __init__.py : Un fichier vide qui indique à Python que ce répertoire doit être considéré comme un package Python.
  - settings.py : Le fichier de configuration du projet, tel que les paramètres de la base de données, le mode de débogage, etc.
  - urls.py : La configuration du routage URL, qui mappe les URL aux fonctions de vue.
  - asgi.py : Fichier de configuration ASGI (Asynchronous Server Gateway Interface) pour le déploiement d'applications asynchrones.
  - wsgi.py : Fichier de configuration WSGI (Web Server Gateway Interface) pour le déploiement d'applications synchrones traditionnelles.## 3. Démarrer le serveur de développement

Django est livré avec un serveur de développement léger, pratique pour le développement et les tests locaux.

Dans le répertoire mysite, exécutez la commande suivante :
```
python manage.py runserver
```
Ouvrez votre navigateur et accédez à http://127.0.0.1:8000/. Vous devriez voir la page "It worked! Congratulations on your first Django-powered page.".

4. Créer une application Django

Un projet Django peut contenir plusieurs applications. Créons une application nommée myapp.

Ouvrez une nouvelle fenêtre de terminal (gardez le serveur de développement en cours d'exécution).
Dans le répertoire mysite, exécutez la commande suivante :
```
python manage.py startapp myapp
```
Cela créera un répertoire nommé myapp dans le répertoire mysite, contenant les fichiers squelettes de l'application Django.
La structure du répertoire de l'application Django est la suivante :
```
myapp/
    __init__.py
    admin.py
    apps.py
    migrations/
        __init__.py
    models.py
    tests.py
    views.py
```
- __init__.py: Un fichier vide qui indique à Python que ce répertoire doit être considéré comme un package Python.
- admin.py: Utilisé pour configurer l'interface d'administration de Django.
- apps.py: Configuration de l'application.
- migrations/: Utilisé pour gérer les migrations de la base de données.
- models.py: Définit les modèles de données (tables de base de données).
- tests.py: Écriture de cas de test.
- views.py: Définit les fonctions de vue, traite les requêtes et renvoie les réponses.

Dans mysite/settings.py, ajoutez myapp à la liste INSTALLED_APPS :

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'myapp',  # Ajouter myapp
]

5. Créer une vue simple

Maintenant, nous allons créer une vue simple qui affiche "Hello, Django!" dans le navigateur.

Modifiez le fichier myapp/views.py et ajoutez le code suivant :

from django.http import HttpResponse

def index(request):
    return HttpResponse("Hello, Django!")

Créez un fichier myapp/urls.py et mappez l'URL à la fonction de vue :

from django.urls import path
from . import views

urlpatterns = [
    path('', views.index, name='index'),
]

Incluez myapp/urls.py dans mysite/urls.py :

from django.urls import include, path
from django.contrib import admin

urlpatterns = [
    path('admin/', admin.site.urls),
    path('myapp/', include('myapp.urls')),  # Ajoutez la configuration URL de myapp
]

Visitez http://127.0.0.1:8000/myapp/. Vous devriez voir la page "Hello, Django!".

6. Créer un modèle

Créons un modèle simple pour stocker des données.

Modifiez le fichier myapp/models.py et ajoutez le code suivant :

from django.db import models

class Question(models.Model):
    question_text = models.CharField(max_length=200)
    pub_date = models.DateTimeField('date published')

    def __str__(self):
        return self.question_text

Cela définit un modèle nommé Question qui contient deux champs : question_text (CharField) et pub_date (DateTimeField).

Créez et appliquez les migrations de la base de données :
```
python manage.py makemigrations myapp
python manage.py migrate
```
La commande makemigrations créera des fichiers de migration basés sur votre modèle, et la commande migrate appliquera les migrations à la base de données.

7. Utiliser l'interface d'administration de Django

Django fournit une interface d'administration puissante qui vous permet de gérer facilement vos données.

Créez un superutilisateur :
```
python manage.py createsuperuser
```
Suivez les instructions pour entrer un nom d'utilisateur, une adresse e-mail et un mot de passe.

Modifiez le fichier myapp/admin.py et enregistrez le modèle Question :

from django.contrib import admin
from .models import Question

admin.site.register(Question)

Visitez http://127.0.0.1:8000/admin/ et connectez-vous avec le superutilisateur que vous avez créé. Vous devriez voir le module "Questions", où vous pouvez ajouter, modifier et supprimer des questions.

8. Utiliser des modèles

L'utilisation de modèles permet de générer des pages HTML de manière plus flexible.1. Dans le répertoire myapp, créez un répertoire nommé templates, puis dans le répertoire templates, créez un répertoire nommé myapp ( myapp/templates/myapp ).

Dans le répertoire myapp/templates/myapp, créez un fichier nommé index.html et ajoutez le code suivant :

Hello, Django!

The current time is: {{ current_time }}

```

3. Modifiez le fichier myapp/views.py pour utiliser le modèle :

```python
from django.shortcuts import render
import datetime

def index(request):
    now = datetime.datetime.now()
    return render(request, 'myapp/index.html', {'current_time': now})
```

La fonction `render` chargera le modèle et transmettra les données au modèle pour le rendu.

4. Revisitez http://127.0.0.1:8000/myapp/. Vous devriez voir une page contenant l'heure actuelle.

9. Conclusion

Grâce à ce guide, vous avez compris les concepts de base et l'utilisation de Django, notamment la configuration de l'environnement, la création de projets et d'applications, la définition de modèles, la création de vues et l'utilisation de modèles. Ce n'est qu'un début, Django offre de nombreuses fonctionnalités que vous pouvez continuer à apprendre et à explorer pour créer des applications Web plus complexes.