Guide d'introduction à Django : Créez rapidement votre premier site Web
2/20/2026
6 min read
# Guide d'introduction à Django : Créez rapidement votre premier site Web
Django est un cadre de développement Web Python efficace et puissant, adapté à la construction d'applications Web et de sites complexes. Ce cadre intègre de nombreuses fonctionnalités utiles, permettant aux développeurs de créer rapidement des applications robustes. Que vous soyez débutant ou développeur ayant une certaine expérience, Django peut vous offrir de nombreux avantages. Dans cet article, nous allons vous apprendre, étape par étape, comment utiliser Django pour créer votre premier site Web.
## 1. Préparation de l'environnement
Avant de commencer, assurez-vous que votre environnement de développement a Python et pip (l'outil de gestion de paquets Python) installés. Django nécessite Python 3.6 ou une version supérieure.
### Installation de Python et pip
Vous pouvez télécharger et installer la version adaptée à votre système d'exploitation depuis [le site officiel de Python](https://www.python.org/downloads/). Une fois installé, vérifiez la version de Python et pip via la ligne de commande :
```bash
python --version
pip --version
```
### Installation de Django
Il est très simple d'installer Django via pip. Tapez la commande suivante dans la ligne de commande :
```bash
pip install django
```
Une fois l'installation terminée, assurez-vous de pouvoir trouver la version de Django dans la ligne de commande :
```bash
django-admin --version
```
## 2. Création d'un projet Django
Après avoir installé Django, nous pouvons commencer à créer un nouveau projet. Un projet est la structure de base de Django, contenant vos applications et configurations.
### Création du projet
Dans le répertoire où vous souhaitez créer le projet, exécutez la commande suivante :
```bash
django-admin startproject myproject
```
Cela créera un nouveau répertoire nommé `myproject`, contenant quelques fichiers et une structure de répertoire par défaut.
### Structure du répertoire
Vous verrez la structure de répertoire suivante :
```
myproject/
manage.py
myproject/
__init__.py
settings.py
urls.py
asgi.py
wsgi.py
```
- `manage.py` : Outil de gestion de Django, utilisé pour gérer le projet.
- `settings.py` : Fichier de configuration du projet, où vous pouvez configurer la base de données, les fichiers statiques, etc.
- `urls.py` : Configuration des routes URL du projet.
- `asgi.py` et `wsgi.py` : Configurations d'interface pour le déploiement.
## 3. Exécution du serveur de développement
Dans le répertoire du projet, utilisez la commande suivante pour démarrer le serveur de développement de Django :
```bash
python manage.py runserver
```
Si tout fonctionne correctement, vous devriez pouvoir accéder à la page d'accueil de Django dans votre navigateur à l'adresse [http://127.0.0.1:8000/](http://127.0.0.1:8000/).
## 4. Création de la première application
Un projet Django peut être composé de plusieurs applications. Chaque application est responsable d'un module fonctionnel spécifique.
### Création de l'application
Dans le répertoire `myproject`, exécutez la commande suivante pour créer une application nommée `myapp` :
```bash
python manage.py startapp myapp
```
Cela créera un nouveau répertoire `myapp` dans votre répertoire de projet, avec une structure similaire à :
```
myapp/
migrations/
__init__.py
admin.py
apps.py
models.py
tests.py
views.py
```
### Modification de settings.py
Dans `settings.py`, enregistrez votre application. Trouvez la liste `INSTALLED_APPS` et ajoutez `'myapp',` :
```python
INSTALLED_APPS = [
...
'myapp',
]
```
## 5. Créer des vues et des modèles
Django utilise le modèle MVC, les vues et les modèles se complètent.
### Créer une vue
Définissez une vue simple dans `myapp/views.py` :
```python
from django.http import HttpResponse
def home(request):
return HttpResponse("Hello, Django!")
```
### Configurer l'URL
Créez un fichier nommé `urls.py` dans le répertoire `myapp` et configurez le routage des URL :
```python
from django.urls import path
from . import views
urlpatterns = [
path('', views.home, name='home'),
]
```
Ensuite, importez l'URL de `myapp` dans le `urls.py` du projet :
```python
from django.contrib import admin
from django.urls import include, path
urlpatterns = [
path('admin/', admin.site.urls),
path('', include('myapp.urls')),
]
```
## 6. Accéder à votre page
Maintenant, vous pouvez redémarrer le serveur de développement et accéder à [http://127.0.0.1:8000/](http://127.0.0.1:8000/). Vous devriez voir le message "Hello, Django!".
## 7. Ajouter le support de la base de données
Django utilise par défaut la base de données SQLite, mais prend également en charge d'autres bases de données comme MySQL et PostgreSQL. Voici comment configurer SQLite.
### Paramètres de la base de données
Dans `settings.py`, trouvez la section `DATABASES`, la configuration par défaut ressemble à ceci :
```python
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': BASE_DIR / "db.sqlite3",
}
}
```
Vous pouvez le modifier selon vos besoins pour d'autres bases de données. Par exemple, pour utiliser PostgreSQL :
```python
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql',
'NAME': 'yourdbname',
'USER': 'yourusername',
'PASSWORD': 'yourpassword',
'HOST': 'localhost',
'PORT': '5432',
}
}
```
Assurez-vous d'installer le pilote de base de données correspondant, par exemple pour PostgreSQL, vous devez installer `psycopg2`.
```bash
pip install psycopg2
```
## 8. Créer des modèles et migrer la base de données
Ensuite, définissons un modèle simple et migrons-le vers la base de données.
### Créer un modèle
Ajoutez le code suivant dans `myapp/models.py` pour définir un modèle simple :
Contenu : python
from django.db import models
class Item(models.Model):
name = models.CharField(max_length=100)
description = models.TextField()
def __str__(self):
return self.name
Générer des migrations
Exécutez la commande suivante pour générer des fichiers de migration de base de données :
bash
python manage.py makemigrations
Ensuite, appliquez ces migrations :
bash
python manage.py migrate
9. Créer une interface d'administration
Django vient avec une interface d'administration puissante, facilitant la gestion des données.
Créer un super utilisateur
Créez un compte administrateur avec la commande suivante :
bash
python manage.py createsuperuser
Ajouter des modèles à l'interface d'administration
Enregistrez vos modèles dans myapp/admin.py :
python
from django.contrib import admin
from .models import Item
admin.site.register(Item)
Maintenant, redémarrez le serveur de développement, accédez à http://127.0.0.1:8000/admin, connectez-vous avec le super utilisateur créé, et vous pourrez voir le modèle que vous venez d'enregistrer.
Conclusion
Django est un puissant cadre de développement Web qui peut vous aider à construire rapidement des applications Web. Grâce aux méthodes décrites dans cet article, vous pouvez facilement mettre en place un site Django simple et étendre ses fonctionnalités. À mesure que vous approfondissez votre compréhension de Django, vous pouvez explorer d'autres fonctionnalités avancées telles que l'authentification des utilisateurs, les API RESTful, les tests, etc. J'espère que ce guide d'introduction pourra vous aider à faire le premier pas et à commencer votre voyage avec Django !Published in Technology
