Tutoriel Django : Démarrer avec Django 5.0

Django est un framework Web Python unique qui a été inspiré par Ruby on Rails et utilise bon nombre des mêmes métaphores pour rendre le développement Web rapide et facile. Entièrement chargé et flexible, Django est devenu l'un des frameworks Web les plus utilisés de Python.

Django comprend pratiquement tout ce dont vous avez besoin pour créer une application Web de toute taille, et sa popularité facilite la recherche d'exemples et d'aide pour divers scénarios. De plus, Django fournit des outils pour permettre à votre application d'évoluer et d'ajouter des fonctionnalités en douceur, et de migrer son schéma de données (s'il en existe un).

Django a également la réputation d'être complexe, avec de nombreux composants et une bonne partie de la configuration « sous le capot » requise. En vérité, vous pouvez rendre une application Python simple opérationnelle dans un délai relativement court, puis étendre ses fonctionnalités si nécessaire.

Cet article vous guide dans la création d'une application Django 5.0 de base. Nous aborderons également les fonctionnalités les plus cruciales pour les développeurs Web dans la version Django 5.

Installation des bibliothèques principales de Django

Pour installer Django 5.0, vous aurez besoin de Python 3.10 ou supérieur. Si vous êtes bloqué sur une version antérieure de Python, vous pourrez peut-être utiliser la version 4 ; consultez le tableau des versions Python de Django pour savoir quelles versions vous pouvez utiliser. Idéalement, utilisez la version Python la plus récente qui prend en charge tout ce que vous souhaitez faire avec votre projet Django.

La première étape consiste à créer un environnement virtuel dans lequel vous installerez Django. Cela permet de séparer Django et ses bibliothèques associées de votre installation de base Python, ce qui est toujours une bonne pratique.

Ensuite, installez Django dans l'environnement virtuel de votre choix via Python pip utilitaire:

pip install django

Cela installe les bibliothèques principales de Django et le django-admin utilitaire de ligne de commande utilisé pour gérer les projets Django.

Créer un nouveau projet Django

Les instances Django sont organisées en deux niveaux : projets et applications.

• UN projet est une instance de Django avec sa propre configuration de base de données, ses paramètres et ses applications. Il est préférable de considérer un projet comme un endroit où stocker toutes les configurations au niveau du site que vous utiliserez.
• Un application est une subdivision d'un projet, avec son propre itinéraire et sa propre logique de rendu. Plusieurs applications peuvent être placées dans un seul projet Django.

Pour créer un nouveau projet Django à partir de zéro, entrez le répertoire dans lequel vous souhaitez stocker le projet et tapez :

django-admin startproject 

Le est le nom du projet et du sous-répertoire dans lequel le projet sera stocké. Assurez-vous de choisir un nom qui ne risque pas d'entrer en collision avec un nom utilisé par Python ou Django en interne. Un nom comme myproj fonctionne bien.

Le répertoire nouvellement créé doit contenir un manage.py fichier, qui est utilisé pour contrôler le comportement de l'application à partir de la ligne de commande, et un autre sous-répertoire (également avec le nom du projet) qui contient les fichiers suivants :

• Un __init__.py fichier, qui est utilisé par Python pour désigner un sous-répertoire en tant que module de code.
• settings.py, qui contient les paramètres utilisés pour le projet. La plupart des paramètres les plus courants seront pré-remplis pour vous.
• urls.pyqui répertorie les routes ou les URL disponibles pour votre projet Django, ou pour lesquelles le projet renverra des réponses.
• wsgi.pyqui est utilisé par les serveurs Web compatibles WSGI, tels qu'Apache HTTP ou Nginx, pour servir les applications de votre projet.
• asgi.py, qui est utilisé par les serveurs Web compatibles ASGI pour servir les applications de votre projet. ASGI est une norme relativement nouvelle pour les serveurs et applications asynchrones et nécessite un serveur qui la prend en charge, comme uvicorn. Django n'a ajouté que récemment la prise en charge native des applications asynchrones, qui devront également être hébergées sur un serveur compatible asynchrone pour être pleinement efficaces.

Ensuite, testez le projet pour vous assurer qu'il fonctionne. Depuis la ligne de commande dans le répertoire contenant le fichier de votre projet manage.py fichier, exécutez :

python manage.py runserver

Cela devrait démarrer un serveur Web de développement disponible sur http://127.0.0.1:8000/. Visitez ce lien et vous devriez voir une simple page de bienvenue qui vous indique que l'installation a réussi.

Notez que le serveur Web de développement doit pas être utilisé pour servir un projet Django au public. Il est uniquement destiné aux tests locaux et n'est pas conçu pour s'adapter aux applications publiques.

Créer une application Django

Ensuite, nous allons créer une application dans ce projet. Accédez au même répertoire que manage.py et lancez cette commande :

python manage.py startapp myapp

Cela crée un sous-répertoire pour une application nommée myapp qui contient les éléments suivants :

• UN migrations répertoire : contient le code utilisé pour migrer le site entre les versions de son schéma de données. Les projets Django ont généralement une base de données, donc le schéma de la base de données, y compris les modifications apportées au schéma, est géré dans le cadre du projet.
• admin.py: Contient les objets utilisés par les outils d'administration intégrés de Django. Si votre application dispose d'une interface d'administration ou d'utilisateurs privilégiés, vous configurerez ici les objets associés.
• apps.py: Fournit des informations de configuration sur l'application au projet dans son ensemble, par le biais d'un AppConfig objet.
• models.py: contient des objets qui définissent les structures de données utilisées par votre application pour s'interfacer avec les bases de données.
• tests.py: contient tous les tests utilisés pour garantir que les fonctions et modules de votre site fonctionnent comme prévu.
• views.py: Contient des fonctions qui restituent et renvoient des réponses.

Pour commencer à travailler avec l'application, vous devez d'abord l'enregistrer auprès du projet. Modifier myproj/settings.py comme suit, en ajoutant une ligne en haut du INSTALLED_APPS liste:

INSTALLED_APPS = (
    "myapp.apps.MyappConfig",
    "django.contrib.admin",
    ...

Si tu regardes dedans myproj/myapp/apps.pyvous verrez un objet pré-généré nommé MyappConfigque nous avons référencé ici.

Ajouter des itinéraires et des vues à votre application Django

Les applications Django suivent un modèle de base pour traiter les requêtes :

• Lorsqu'une requête entrante est reçue, Django analyse l'URL pour un itinéraire pour l'appliquer.
• Les itinéraires sont définis dans urls.pychaque itinéraire étant lié à un voir, c'est-à-dire une fonction qui renvoie les données à renvoyer au client. Les vues peuvent être situées n'importe où dans un projet Django, mais il est préférable de les organiser dans leurs propres modules.
• Les vues peuvent contenir les résultats d'un modèlequi est un code qui formate les données demandées selon une certaine conception.

Pour avoir une idée de la façon dont tous ces éléments s’assemblent, modifions la route par défaut de notre exemple d’application pour renvoyer un message personnalisé.

Les itinéraires sont définis dans urls.py dans une liste nommée urlpatterns. Si vous ouvrez l'échantillon urls.pytu verras urlpatterns déjà prédéfini :

urlpatterns = (
    path('admin/', admin.site.urls),
)

Le path La fonction (intégrée à Django) prend une fonction de route et une fonction de vue comme arguments et génère une référence à un chemin d'URL. Par défaut, Django crée un admin chemin utilisé pour l'administration du site, mais nous devons créer nos propres itinéraires.

Ajoutez une autre entrée pour que l'ensemble du fichier ressemble à ceci :

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

urlpatterns = (
    path('admin/', admin.site.urls),
    path('myapp/', include('myapp.urls'))
)

Le include la fonction indique à Django de rechercher plus d'informations sur le modèle de route dans le fichier myapp.urls. Toutes les routes trouvées dans ce fichier seront attachées à la route de niveau supérieur myapp (par exemple, http://127.0.0.1:8080/myapp).

Ensuite, créez un nouveau urls.py dans myapp et ajoutez ce qui suit :

from django.urls import path
from . import views

urlpatterns = (
    path('', views.index)
)

Django ajoute une barre oblique au début de chaque URL, afin de spécifier la racine du site (/), nous fournissons simplement une chaîne vide comme URL.

Maintenant, éditez le fichier myapp/views.py donc ça ressemble à ça :

from django.http import HttpResponse

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

django.http.HttpResponse est un Django intégré qui génère une réponse HTTP à partir d'une chaîne fournie. Noter que requestqui contient les informations d'une requête HTTP entrante, doit être transmis comme premier paramètre à une fonction d'affichage.

Arrêtez et redémarrez le serveur de développement, puis accédez à http://127.0.0.1:8000/myapp/. Vous devriez voir « Hello, world ! » apparaître dans le navigateur.

Ajout de routes avec des variables dans Django

Django peut accepter des routes qui intègrent des variables dans leur syntaxe. Supposons que vous vouliez accepter les URL au format year/. Vous pouvez y parvenir en ajoutant l'entrée suivante à urlpatterns:

path('year/', views.year)

La fonction de visualisation views.year serait alors invoqué via des itinéraires comme year/1996, year/2010et ainsi de suite, avec la variable year passé en paramètre à views.year.

Pour essayer cela par vous-même, ajoutez ce qui précède urlpatterns entrée à myapp/urls.pypuis ajoutez cette fonction à myapp/views.py:

def year(request, year):
    return HttpResponse('Year: {}'.format(year))

Si vous naviguez vers /myapp/year/2010 sur votre site, vous devriez voir Year: 2010 affiché en réponse. Notez que des itinéraires comme /myapp/year/rutabaga générera une erreur car le int: la contrainte sur la variable année autorise uniquement un nombre entier dans cette position. De nombreuses autres options de formatage sont disponibles pour les itinéraires.

Les versions antérieures de Django avaient une syntaxe plus complexe pour les routes, difficile à analyser. Si vous devez toujours ajouter des routes en utilisant l'ancienne syntaxe (par exemple, pour une compatibilité descendante avec un ancien projet Django), vous pouvez utiliser la fonction django.urls.re_path, qui fait correspondre les routes à l'aide d'expressions régulières.

Modèles Django

Le langage de modèle intégré de Django peut être utilisé pour générer des pages Web à partir de données.

Les modèles utilisés par les applications Django sont stockés dans un répertoire central du projet : /templates//. Pour notre myapp projet, le répertoire serait myapp/templates/myapp/. Cette structure de répertoires peut sembler délicate, mais permettre à Django de rechercher des modèles à plusieurs endroits évite les collisions de noms entre des modèles portant le même nom dans plusieurs applications.

Dans ton myapp/templates/myapp/ répertoire, créez un fichier nommé year.html avec le contenu suivant :

Year: {{year}}

Toute valeur entre doubles accolades dans un modèle est traitée comme une variable. Tout le reste est traité littéralement.

Modifier myapp/views.py pour ressembler à ceci :

from django.shortcuts import render
from django.http import HttpResponse

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

def year(request, year):
    data = {'year':year}
    return render(request, 'myapp/year.html', data)

Le render fonction — un « raccourci » Django (une combinaison de plusieurs éléments intégrés pour plus de commodité) — prend l'existant request objet, recherche le modèle myapp/year.html dans la liste des emplacements de modèles disponibles et transmet le dictionnaire data à cela comme contexte pour le modèle. Le modèle utilise le dictionnaire comme espace de noms pour les variables utilisées dans le modèle. Dans ce cas, la variable {{year}} dans le modèle est remplacé par la valeur de la clé year dans le dictionnaire data (c'est, data("year")).

La quantité de traitement que vous pouvez effectuer sur les données dans les modèles Django est intentionnellement limitée. La philosophie de Django est d'imposer la séparation de la présentation et de la logique métier autant que possible. Ainsi, vous pouvez parcourir un objet itérable et effectuer if/then/else tests, mais la modification des données dans un modèle est déconseillée.

Par exemple, vous pouvez coder un simple test « if » de cette façon :

{% if year > 2000 %}
21st century year: {{year}}
{% else %}
Pre-21st century year: {{year}}
{% endif %}

Le {% et %} les marqueurs délimitent des blocs de code pouvant être exécutés dans le langage de modèle de Django.

Si vous souhaitez utiliser un langage de traitement de modèles plus sophistiqué, vous pouvez échanger quelque chose comme Jinja2 ou Mako. Django inclut une intégration back-end pour Jinja2, mais vous pouvez utiliser n'importe quel langage de modèle qui renvoie une chaîne, par exemple en renvoyant cette chaîne dans un HttpResponse objet comme dans le cas de notre "Hello, world!" itinéraire.

Prochaines étapes avec Django

Ce que vous avez vu ici ne couvre que les éléments les plus élémentaires d'une application Django. Django inclut de nombreux autres composants à utiliser dans les projets Web. Tous ces éléments méritent d’être discutés en détail séparément, mais je vous laisse avec un bref aperçu :

• Bases de données et modèles de données: L'ORM intégré de Django vous permet de définir des structures de données et des relations entre elles pour votre application, ainsi que des chemins de migration entre les versions de ces structures.
• Formes: Django fournit un moyen cohérent pour les vues de fournir des formulaires de saisie à un utilisateur, de récupérer des données, de normaliser les résultats et de fournir un rapport d'erreurs cohérent.
• Sécurité et utilitaires: Django inclut de nombreuses fonctions intégrées pour la mise en cache, la journalisation, la gestion des sessions, la gestion des fichiers statiques et la normalisation des URL. Il regroupe également des outils pour les besoins de sécurité courants, tels que l'utilisation de certificats cryptographiques ou la protection contre la falsification entre sites ou le détournement de clics.