---
title: "Écriture de votre première application Django, 1ère partie"
version: 1.11
locale: fr
source: https://docs.djangoproject.com/fr/1.11/intro/tutorial01/
canonical: https://djangodocs.dev/fr/1.11/intro/tutorial01/
---
# Écriture de votre première application Django, 1ère partie

Apprenons avec un exemple.

Tout au long de ce tutoriel, nous vous guiderons dans la création d’une application simple de sondage.

Cela consistera en deux parties :

- Un site public qui permet à des gens de voir les sondages et d’y répondre.
- Un site d’administration qui permet d’ajouter, de modifier et de supprimer des sondages.

Nous supposerons que [Django est déjà installé](/fr/1.11/intro/install/). Vous pouvez savoir si Django est installé et sa version en exécutant la commande suivante dans un terminal (indiqué par le préfixe $) :

```console
$ python -m django --version
```

Si Django est installé, vous devriez voir apparaître la version de l’installation. Dans le cas contraire, vous obtiendrez une erreur disant « No module named django » (aucun module nommé django).

Ce didacticiel est écrit pour Django 1.11 et Python 3.4 (ou plus récent). Si la version de Django ne correspond pas, référez-vous au didacticiel correspondant à votre version de Django en utilisant le sélecteur de version au bas de cette page, ou mettez à jour Django à la version la plus récente. Si vous utilisez encore Python 2.7, il sera nécessaire d’ajuster légèrement les exemples de code, comme expliqué dans les commentaires.

Consultez [Comment installer Django](/fr/1.11/topics/install/) pour tout conseil sur la manière de supprimer d’anciennes versions de Django pour en installer une nouvelle.

> **Où obtenir de l’aide :**
>
> Si vous avez des problèmes au long de ce tutoriel, écrivez un message sur [django-users](/fr/1.11/internals/mailing-lists/#django-users-mailing-list) (anglophone) ou passez sur [#django-fr sur irc.freenode.net](irc://irc.freenode.net/django-fr) pour discuter avec d’autres utilisateurs de Django qui pourraient vous aider.

## Création d’un projet

Si c’est la première fois que vous utilisez Django, vous devrez vous occuper de quelques éléments de configuration initiaux. Plus précisément, vous devrez lancer la génération automatique de code qui mettra en place un [projet](/fr/1.11/glossary/#term-project) Django – un ensemble de réglages particuliers à une instance de Django, qui comprend la configuration de la base de données, des options spécifiques à Django et d’autres propres à l’application.

Depuis un terminal en ligne de commande, déplacez-vous à l’aide de la commande `cd` dans un répertoire dans lequel vous souhaitez conserver votre code, puis lancez la commande suivante :

```console
$ django-admin startproject mysite
```

Cela va créer un répertoire `mysite` dans le répertoire courant. Si cela ne fonctionne pas, consultez [Problèmes d’exécution de django-admin](/fr/1.11/faq/troubleshooting/#troubleshooting-django-admin).

> **Note**
>
> Vous devez éviter de nommer vos projets en utilisant des noms réservés de Python ou des noms de composants de Django. Cela signifie en particulier que vous devez éviter d’utiliser des noms comme `django` (qui entrerait en conflit avec Django lui-même) ou `test` (qui entrerait en conflit avec un composant intégré de Python).

> **À quel endroit ce code devrait-il se trouver ?**
>
> Si vous avez une expérience en PHP, vous avez probablement l’habitude de placer votre code dans le répertoire racine de votre serveur Web (comme `/var/www/`). Avec Django, ne le faites pas. Ce n’est pas une bonne idée de mettre du code Python dans le répertoire racine de votre serveur Web, parce que cela crée le risque que l’on puisse voir votre code sur le Web, ce qui n’est pas bon pour la sécurité.
>
> Mettez votre code dans un répertoire en dehors de la racine de votre serveur Web, comme par exemple `home/moncode`.

Voyons ce que [`startproject`](/fr/1.11/ref/django-admin/#django-admin-startproject) a créé :

```
mysite/
    manage.py
    mysite/
        __init__.py
        settings.py
        urls.py
        wsgi.py
```

Ces fichiers sont :

- Le premier répertoire racine `mysite/` n’est qu’un contenant pour votre projet. Son nom n’a pas d’importance pour Django ; vous pouvez le renommer comme vous voulez.
- `manage.py` : un utilitaire en ligne de commande qui vous permet d’interagir avec ce projet Django de différentes façons. Vous trouverez toutes les informations nécessaires sur `manage.py` dans [django-admin et manage.py](/fr/1.11/ref/django-admin/).
- Le sous-répertoire `mysite/` correspond au paquet Python effectif de votre projet. C’est le nom du paquet Python que vous devrez utiliser pour importer ce qu’il contient (par ex. `mysite.urls`).
- `mysite/__init__.py` : un fichier vide qui indique à Python que ce répertoire doit être considéré comme un paquet. Si vous êtes débutant en Python, lisez [les informations sur les paquets](https://docs.python.org/3/tutorial/modules.html#tut-packages) (en) dans la documentation officielle de Python.
- `mysite/settings.py` : réglages et configuration de ce projet Django. [Les réglages de Django](/fr/1.11/topics/settings/) vous apprendra tout sur le fonctionnement des réglages.
- `mysite/urls.py` : les déclarations des URL de ce projet Django, une sorte de « table des matières » de votre site Django. Vous pouvez en lire plus sur les URL dans [Distribution des URL](/fr/1.11/topics/http/urls/).
- `mysite/wsgi.py` : un point d’entrée pour les serveurs Web compatibles WSGI pour déployer votre projet. Voir [Comment déployer avec WSGI](/fr/1.11/howto/deployment/wsgi/) pour plus de détails.

## Le serveur de développement

Vérifions que votre projet Django fonctionne. Déplacez-vous dans le répertoire `mysite` si ce n’est pas déjà fait, et lancez les commandes suivantes :

```console
$ python manage.py runserver
```

Vous verrez les messages suivants défiler en ligne de commande :

```
Performing system checks...

System check identified no issues (0 silenced).

You have unapplied migrations; your app may not work properly until they are applied.
Run 'python manage.py migrate' to apply them.

09 août 2026 - 15:50:53
Django version 1.11, using settings 'mysite.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.
```

> **Note**
>
> Ignorez pour l’instant l’avertissement au sujet des migrations de base de données non appliquées ; nous nous occuperons de la base de données tantôt.

Vous avez démarré le serveur de développement de Django, un serveur Web léger entièrement écrit en Python. Nous l’avons inclus avec Django de façon à vous permettre de développer rapidement, sans avoir à vous occuper de la configuration d’un serveur de production – comme Apache – tant que vous n’en avez pas besoin.

C’est le moment de noter soigneusement ceci : **n’utilisez jamais** ce serveur pour quoi que ce soit qui s’approche d’un environnement de production. Il est fait seulement pour tester votre travail pendant le développement (notre métier est le développement d’environnements Web, pas de serveurs Web).

Maintenant que le serveur tourne, allez à l’adresse <http://127.0.0.1:8000> avec votre navigateur Web. Vous verrez une page avec le message « Welcome to Django » sur un joli fond bleu pastel. Ça marche !

> **Modification du port**
>
> Par défaut, la commande [`runserver`](/fr/1.11/ref/django-admin/#django-admin-runserver) démarre le serveur de développement sur l’IP interne sur le port 8000.
>
> Si vous voulez changer cette valeur, passez-la comme paramètre sur la ligne de commande. Par exemple, cette commande démarre le serveur sur le port 8080 :
>
> ```console
> $ python manage.py runserver 8080
> ```
>
> Si vous voulez changer l’IP du serveur, passez-la comme paramètre avec le port. Par exemple, pour écouter toutes les IP publiques disponibles (ce qui est utile si vous exécutez Vagrant ou que souhaitez montrer votre travail à des personnes sur d’autres ordinateurs de votre réseau), faites :
>
> ```console
> $ python manage.py runserver 0:8000
> ```
>
> **0** est un raccourci pour **0.0.0.0**. La documentation complète du serveur de développement se trouve dans la référence de [`runserver`](/fr/1.11/ref/django-admin/#django-admin-runserver).

> **Rechargement automatique de runserver**
>
> Le serveur de développement recharge automatiquement le code Python lors de chaque requête si nécessaire. Vous ne devez pas redémarrer le serveur pour que les changements de code soient pris en compte. Cependant, certaines actions comme l’ajout de fichiers ne provoquent pas de redémarrage, il est donc nécessaire de redémarrer manuellement le serveur dans ces cas.

## Création de l’application Polls

Maintenant que votre environnement – un « projet » – est en place, vous êtes prêt à commencer à travailler.

Chaque application que vous écrivez avec Django est en fait un paquet Python qui respecte certaines conventions. Django est livré avec un utilitaire qui génère automatiquement la structure des répertoires de base d’une application, ce qui vous permet de vous concentrer sur l’écriture du code, plutôt que sur la création de répertoires.

> **Projets vs. applications**
>
> Quelle est la différence entre un projet et une application ? Une application est une application Web qui fait quelque chose – par exemple un système de blog, une base de données publique ou une application de sondage. Un projet est un ensemble de réglages et d’applications pour un site Web particulier. Un projet peut contenir plusieurs applications. Une application peut apparaître dans plusieurs projets.

Vos applications peuvent se trouver à n’importe quel endroit de votre [chemin de recherche Python](https://docs.python.org/3/tutorial/modules.html#tut-searchpath). Dans ce didacticiel, nous allons créer une application de sondage au même niveau que le fichier `manage.py` pour qu’elle puisse être importée comme module de premier niveau plutôt que comme sous-module de `monsite`.

Pour créer votre application, assurez-vous d’être dans le même répertoire que `manage.py` et saisissez cette commande :

```console
$ python manage.py startapp polls
```

Cela va créer un répertoire `polls`, qui est structuré de la façon suivante :

```
polls/
    __init__.py
    admin.py
    apps.py
    migrations/
        __init__.py
    models.py
    tests.py
    views.py
```

Cette structure de répertoire accueillera l’application de sondage.

## Écriture d’une première vue

Écrivons la première vue. Ouvrez le fichier `polls/views.py` et placez-y le code Python suivant :

*polls/views.py*

```
from django.http import HttpResponse

def index(request):
    return HttpResponse("Hello, world. You're at the polls index.")
```

C’est la vue Django la plus simple possible. Pour appeler cette vue, il s’agit de l’associer à une URL, et pour cela nous avons besoin d’un URLconf.

Pour créer un URLconf dans le répertoire polls, créez un fichier nommé `urls.py`. Votre répertoire d’application devrait maintenant ressembler à ceci :

```
polls/
    __init__.py
    admin.py
    apps.py
    migrations/
        __init__.py
    models.py
    tests.py
    urls.py
    views.py
```

Dans le fichier `polls/urls.py`, insérez le code suivant :

*polls/urls.py*

```
from django.conf.urls import url

from . import views

urlpatterns = [
    url(r'^$', views.index, name='index'),
]
```

L’étape suivante est de faire pointer l’URLconf racine vers le module `polls.urls`. Dans `mysite/urls.py`, ajoutez une importation `django.conf.urls.include` et insérez un appel [`include()`](/fr/1.11/ref/urls/#django.conf.urls.include) dans la liste `urlpatterns`, ce qui donnera :

*mysite/urls.py*

```
from django.conf.urls import include, url
from django.contrib import admin

urlpatterns = [
    url(r'^polls/', include('polls.urls')),
    url(r'^admin/', admin.site.urls),
]
```

La fonction [`include()`](/fr/1.11/ref/urls/#django.conf.urls.include) permet de référencer d’autres configurations d’URL. Remarquez que les expressions régulières dans la fonction [`include()`](/fr/1.11/ref/urls/#django.conf.urls.include) n’ont pas de `$` (caractère de fin de correspondance) mais plutôt une barre oblique finale. Quand Django rencontre un [`include()`](/fr/1.11/ref/urls/#django.conf.urls.include), il tronque le bout d’URL qui correspondait jusque là et passe la chaîne de caractères restante à la configuration d’URL incluse pour continuer le traitement.

L’idée derrière [`include()`](/fr/1.11/ref/urls/#django.conf.urls.include) est de faciliter la connexion d’URL. Comme l’application de sondages possède son propre URLconf (`polls/urls.py`), ses URL peuvent être injectés sous « /polls/ », sous « /fun\_polls/ » ou sous « /content/polls/ » ou tout autre chemin racine sans que cela change quoi que ce soit au fonctionnement de l’application.

> **Quand utiliser include()**
>
> Il faut toujours utiliser `include()` lorsque l’on veut inclure d’autres motifs d’URL. `admin.site.urls` est la seule exception à cette règle.

> **Cela ne correspond pas à ce que vous voyez ?**
>
> Si vous voyez `include(admin.site.urls)` au lieu d’un simple `admin.site.urls`, il est alors probable que vous utilisez une version de Django qui ne correspond pas à la version de ce tutoriel. Consultez une version plus ancienne de ce tutoriel ou installez une version plus récente de Django.

Vous avez maintenant relié une vue `index` dans la configuration d’URL. Vérifions qu’elle fonctionne en lançant la commande suivante :

```console
$ python manage.py runserver
```

Ouvrez <http://localhost:8000/polls/> dans votre navigateur et vous devriez voir le texte « *Hello, world. You’re at the polls index.* » qui a été défini dans la vue `index`.

La fonction [`url()`](/fr/1.11/ref/urls/#django.conf.urls.url) reçoit quatre paramètres, dont deux sont obligatoires : `regex` et `view`, et deux facultatifs : `kwargs` et `name`. À ce stade, il est interessant d’examiner le rôle de chacun de ces paramètres.

### Paramètre d”[`url()`](/fr/1.11/ref/urls/#django.conf.urls.url) : regex

Le terme « regex » est communément utilisé comme raccourci pour « expression régulière », qui consiste en une syntaxe pour retrouver des motifs dans des chaînes de caractères, ou dans ce cas, dans des modèles d’URL. Django commence par la première expression régulière puis continue de parcourir la liste en comparant l’URL reçue avec chaque expression jusqu’à ce qu’il en trouve une qui correspond.

Notez que ces expressions régulières ne cherchent pas dans les paramètres GET et POST, ni dans le nom de domaine. Par exemple, dans une requête vers `https://www.example.com/myapp/`, l’URLconf va chercher `myapp/`. Dans une requête vers `https://www.example.com/myapp/?page=3`, l’URLconf va aussi chercher `myapp/`.

Si vous avez besoin d’aide avec les expressions régulières, jetez un oeil à l”[article Wikipedia](http://fr.wikipedia.org/wiki/Expression_rationnelle) et à la documentation du module Python [`re`](https://docs.python.org/3/library/re.html#module-re). À noter aussi que le livre « Mastering Regular Expressions », écrit par Jeffrey Friedl, est remarquable. En pratique, il n’y a cependant pas besoin d’être un expert des expressions régulières, car il suffit de savoir capturer des motifs simples. En fait, les expressions complexes risquent de pénaliser les performances, et il faut plutôt éviter de faire appel à tout le potentiel des expressions régulières.

Enfin, une note sur la performance : ces expressions régulières sont compilées la première fois que le module contenant l’URLconf est chargé. Elles sont extrêmement rapides (tant qu’elles ne sont pas trop complexes, comme indiqué ci-dessus).

### Paramètre d”[`url()`](/fr/1.11/ref/urls/#django.conf.urls.url) : view

Lorsque Django trouve une expression régulière qui correspond, il appelle la fonction de vue spécifiée, avec un objet [`HttpRequest`](/fr/1.11/ref/request-response/#django.http.HttpRequest) comme premier paramètre et toutes valeurs « capturées » par l’expression régulière comme autres paramètres. Si l’expression régulière utilise des captures simples, les valeurs sont passées comme paramètres positionnels ; si ce sont des captures nommées, les valeurs sont passées comme paramètres nommés. Nous montrerons cela par un exemple un peu plus loin.

### Paramètre d”[`url()`](/fr/1.11/ref/urls/#django.conf.urls.url) : kwargs

Des paramètres nommés arbitraires peuvent être transmis dans un dictionnaire vers la vue cible. Nous n’allons pas exploiter cette fonctionnalité dans ce tutoriel.

### Paramètre d”[`url()`](/fr/1.11/ref/urls/#django.conf.urls.url) : name

Le nommage des URL permet de les référencer de manière non ambiguë depuis d’autres portions de code Django, en particulier depuis les gabarits. Cette fonctionnalité puissante permet d’effectuer des changements globaux dans les modèles d’URL de votre projet en ne modifiant qu’un seul fichier.

Lorsque vous serez familiarisé avec le flux de base des requêtes et réponses, lisez la [partie 2 de ce tutoriel](/fr/1.11/intro/tutorial02/) pour commencer de travailler avec la base de données.