Tutoriel Django: Premiers pas avec Django 2.0

Django est un framework Web Python unique qui a été inspiré par Ruby on Rails et utilise plusieurs des mêmes métaphores pour rendre le développement Web rapide et facile. Complètement 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 gracieusement, et de migrer son schéma de données (s'il en a un).

Django a aussi la réputation d'être complexe, avec de nombreux composants et beaucoup de configuration «sous le capot» requis. En vérité, vous pouvez obtenir une application simple opérationnelle dans un délai relativement court, puis étendre ses fonctionnalités à partir de là si nécessaire.

Dans ce guide, nous vous présenterons la création d'une application Django 2.0 rudimentaire et aborderons brièvement les fonctionnalités les plus cruciales qu'elle offre aux développeurs Web.

Mise à niveau depuis Django 1.x

Si vous avez de l'expérience avec une précédente édition 1.x de Django, voici les changements de rupture les plus importants à prendre en compte:

  • Django 2.0 ne prend en charge que Python 3.4 et plus. Python 2.x ne sera pas pris en charge dans les futures versions de Django.
  • Django 2 suit le modèle de Python 3 d'utilisation des chaînes Unicode natives dans la mesure du possible. Certaines fonctions Django n'accepteront plus les chaînes d'octets en entrée. 

Il existe de nombreux autres changements rétrocompatibles, mais ce sont deux des plus importants, en particulier lors du démarrage de nouveaux projets.

Installer les bibliothèques principales de Django

Pour installer Django 2.0, vous aurez besoin de Python 3.4 ou supérieur. Ensuite, le moyen le plus simple d'installer Django est via l' piputilitaire de Python :

pip install django

Cela installe les bibliothèques Django de base et l' django-adminutilitaire de ligne de commande utilisé pour gérer les projets Django.

Si vous souhaitez travailler avec plusieurs versions de Django côte à côte, créez un environnement virtuel, installez-y la version souhaitée de Django et utilisez-la pour le projet Django en question.

Notez que vous n'avez pas besoin d'utiliser des environnements virtuels pour créer plusieurs projets avec une seule instance de Django. Vous n'en avez besoin que pour utiliser différentes révisions ponctuelles du framework Django  avec différents projets.

Créer un nouveau projet Django

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

  • Un projet est une instance de Django avec sa propre configuration de base de données, ses propres paramètres et applications. Il est préférable de considérer un projet comme un endroit pour stocker toutes les configurations au niveau du site que vous utiliserez.
  • Une 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

est le nom du projet et du sous-répertoire où le projet sera stocké. Assurez-vous de choisir un nom qui ne risque pas d'entrer en conflit avec un nom utilisé par Python ou Django en interne. Un nom comme myprojcela fonctionnera très bien.

Le répertoire résultant doit contenir un  manage.pyfichier, 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__.pyfichier, qui est utilisé par Python pour désigner un sous-répertoire comme 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.py, qui répertorie les routes ou URL disponibles pour votre projet Django, ou pour lesquelles le projet renverra des réponses.
  • wsgi.py, qui est utilisé par les serveurs Web compatibles WSGI, tels que Apache HTTP ou Nginx, pour servir les applications de votre projet.

Avant toute chose, testez le projet pour vous assurer qu'il fonctionne. Depuis la ligne de commande dans le répertoire contenant le manage.pyfichier de votre projet , exécutez:

python manage.py runserver

Cela devrait démarrer un serveur Web de développement disponible sur //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 ne doit pas être utilisé pour servir un projet Django au public. Il ne s'adapte pas pour gérer le trafic nécessaire.

Créer une application Django

Ensuite, nous devons créer une application dans ce projet. Accédez au même répertoire que manage.pyet exécutez 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 migrationsannuaire. Contient le code utilisé pour migrer le site entre les versions de son schéma de données.
  • admin.py. Contient des 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 devez configurer les objets associés ici.
  • apps.py. Fournit des informations de configuration sur l'application au projet dans son ensemble, au moyen d'un AppConfigobjet.
  • 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 les modules de votre site fonctionnent comme prévu.
  • views.py. Contient des fonctions qui rendent et retournent des réponses.

Pour commencer à travailler avec l'application, nous devons d'abord l'enregistrer avec le projet. Pour ce faire, modifiez myproj/settings.pyet ajoutez une ligne en haut de la INSTALLED_APPSliste:

INSTALLED_APPS = [ ‘myapp.apps.MyappConfig’, ‘django.contrib.admin’, ... 

Si vous regardez dedans myapp.apps, vous verrez un objet pré-généré nommé MyappConfig, qui est ce que nous référencons ici.

Ajouter des routes et des vues à votre application Django

Les applications Django suivent un modèle de base pour le traitement des requêtes:

  • Lorsqu'une requête entrante est reçue, Django analyse l'URL d'une route à laquelle l'appliquer.
  • Les routes sont définies dans urls.py, chaque route étant liée à une vue , c'est-à-dire une fonction qui renvoie des 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.
  • Views can contain the results of a template, i.e. code that formats requested data according to a certain design.

To get an idea of how all these pieces fit together, let’s modify the default route of our sample app to return a custom message.

Routes are defined in urls.py in a list named urlpatterns. If you open the sample urls.py, you’ll see urlpatterns already predefined:

urlpatterns = [ path(‘admin/’, admin.site.urls), ] 

The path function—a Django built-in—takes a route and a view function as arguments and generates a reference to a URL path. By default, Django creates an admin path that is used for site administration, but we need to create our own routes.

Add another entry, so that the whole file looks like:

from django.contrib import admin from django.urls import include, path urlpatterns = [ path(‘admin/’, admin.site.urls), path(‘myapp/’, include(‘myapp.urls’)) ] 

The include function tells Django to look for more route pattern information in the file myapp.urls. All of the routes found in that file will be attached to the top-level route myapp (e.g., //127.0.0.1:8080/myapp).

Next, create a new urls.py in myapp and add the following:

from django.urls import path from . import views urlpatterns = [ path(‘’, views.index) ] 

Django prepends a slash to the beginning of each URL, so to specify the root of the site (/), we just supply a blank string as the URL.

Now edit the file myapp/views.py so it looks like this:

from django.http import HttpResponse def index(request): return HttpResponse(“Hello, world!”) 

django.http.HttpResponse is a Django built-in that generates an HTTP response from a supplied string. Note that request, which contains the information for an incoming HTTP request, must be passed as the first parameter to a view function.

Stop and restart the development server, and navigate to //127.0.0.1:8000/myapp/. You should see Hello, world! appear in the browser.

Adding routes with variables in Django

Django can accept routes that incorporate variables as part of their syntax. Let’s say you wanted to accept URLs that had the format year/. You could accomplish that by adding the following entry to urlpatterns:

path(‘year/’, views.year) 

The view function views.year would then be invoked through routes like year/1996, year/2010, and so on, with the variable year passed as a parameter to views.year.

To try this out for yourself, add the above urlpatterns entry to myapp/urls.py, then add this function to myapp/views.py:

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

If you navigate to /myapp/year/2010 on your site, you should see Year: 2010 displayed in response. Note that routes like /myapp/year/rutabaga will yield an error, because the int: constraint on the variable year allows only an integer in that position. Many other formatting options are available for routes.

Earlier versions of Django had a more complex and difficult-to-parse syntax for routes. If you still need to add routes using the old syntax—for instance, for backward compatibility with an old Django project—you can do so by using the django.urls.re_path function.

Django templates

Django’s built-in template language can be used to generate web pages from data.

Templates used by Django apps are stored in a directory that is central to the project: /templates//. For our myapp project, the directory would be myapp/templates/myapp/. This directory structure may seem a little awkward, but Django can look for templates in multiple places, so this avoids name collisions between templates with the same names across multiple apps.

In your myapp/templates/myapp/ directory, create a file named year.html with the following content:

Year: {{year}} 

Any value within double curly braces in a template is treated as a variable. Everything else is treated literally.

Modify myapp/views.py to look like this:

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) 

The render function, a Django “shortcut” (a combination of multiple built-ins for convenience), takes the existing request object, looks for the template myapp/year.html in the list of available template locations, and passes the dictionary data to it as context for the template.

The amount of processing you can perform on data within Django templates is intentionally quite limited. Django’s philosophy is to enforce separation of presentation and business logic whenever possible. Thus you can loop through an iterable object, and you can perform if/then/else tests, but modifying the data within a template is frowned upon.

For instance, a simple “if” test can be encoded this way:

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

The {% and %} markers delimit blocks of code that can be executed in Django’s template language.

If you want to use a more sophisticated template processing language, you can swap in others, such as Jinja2 or Mako. Django includes back-end integration for Jinja2, but any template language that returns a string can be used—for instance, by returning that string in a HttpResponse object as in the case of our ”Hello, world!” route.

Next steps with Django

What we’ve seen here covers only the most basic elements of a Django application. Django includes a great many other components that can be employed in a web project. All of these are worth discussing in detail separately, but I will leave you with a brief overview:

  • Databases and data models. Django’s built-in ORM can be used to define data structures and relationships between them for your app, as well as migration paths between versions of those structures.

  • Formulaires . Django offre aux vues un moyen cohérent de fournir des formulaires d'entrée à un utilisateur, de récupérer des données, de normaliser les résultats et de fournir des rapports d'erreur cohérents.

  • Sécurité et utilitaires . Django comprend de nombreuses fonctions intégrées pour la mise en cache, la journalisation, la gestion de session, 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 intersite ou le détournement de clics.