Cours : Modularité des programmes

Bibliothèques logicielles

Dans cette première partie, nous aborderons l'utilisation de modules logiciels préexistants ; puis dans un second temps nous étudierons la création d'un nouveau module.

Les langages informatiques disposent d'un certain nombre de fonctionnalités natives. Ainsi le langage Python nous permet d'effectuer des calculs usuels et de traiter plusieurs types de données. Ces fonctionnalités natives permettent de répondre aux besoins courants et récurrents des développeur·se·s.

Intérêt des bibliothèques logicielles

Les fonctionnalités natives des langages peuvent être étendues en cas de besoin par le recours à des modules complémentaires, appelés de manière générique bibliothèques logicielles.

Ces modules spécialisés permettent d'enrichir le langage en fournissant des outils logiciels dédiés à toutes sortes de problématiques : calcul mathématique, accès au système d'exploitation, cryptographie, communication réseau, protocoles Internet, pour ne citer que quelques familles de bibliothèques.

Cette riche bibliothèque standard peut, en outre, être complétée si nécessaire par le recours à des modules supplémentaires externes, comme nous allons le voir à présent.

Utilisation d'une bibliothèque

Afin d'illustrer de manière concrète l'utilisation d'une bibliothèque, nous choisissons comme exemple le module externe nommé « Requests ».
C'est une bibliothèque HTTP très utilisée et très appréciée par les développeur·se·s Python. Elle ne fait pas partie de la bibliothèque standard, mais elle est officiellement recommandée dans la documentation Python comme interface client HTTP de plus haut niveau.

Son installation, simple et rapide, est présentée dans la documentation en ligne de Requests consultable à cette adresse.

Les documentations en ligne des langages et modules sont toujours disponibles en anglais. Certaines sont traduites dans d'autres langues, mais la traduction n’est pas systématique.

Une fois le module installé, il suffit de l'importer pour accéder aux fonctionnalités qu'il propose, ainsi qu'à une aide intégrée locale, donc accessible en l'absence de connexion Internet. Rédigée en langue anglaise, cette aide destinée à un public international est généralement formulée de manière assez simple.

Depuis Python, on importe le module Requests : import requests

Nous pouvons interroger le système d'aide natif de Python avec help() en précisant le nom du module qui nous intéresse.

help(requests)

Affiche le texte d'aide suivant :

Help on package requests:

NAME

DESCRIPTION

PACKAGE CONTENTS

FUNCTIONS

DATA

VERSION

AUTHOR

On observe que cette aide intégrée propose deux exemples de code illustrant des fonctionnalités du module. Ces exemples sont construits avec les deux requêtes HTTP les plus courantes : GET et POST.

Consultons l'aide applicable à GET.

help(requests.get)

Nous obtenons le texte suivant :

Help on function get in module requests.api:

get(url, params=None, **kwargs)

L'aide contextuelle fournie par les IDE (pour Integrated Development Environment, soit « environnement de développements ») facilite également le travail des développeur·se·s en apportant les éléments de syntaxe dans l'éditeur de code, en regard immédiat de la ligne de code courante.

Voici à quoi ressemble le texte d'aide contextuelle associé à la fonction get() de Requests :

La consultation de la documentation en ligne et de l'aide contextuelle nous guide pour l'utilisation de la bibliothèque. Sa lecture nous apprend que nous pouvons facilement requérir des ressources du web à partir de leur URL.

Effectuons une requête HTTP de type GET sur l'URL correspondant à la page Wikipédia consacrée au langage Python en langue française.

reponse =
requests.get('https://fr.wikipedia.org/wiki/Python_(langage)')

La fonction dir() appelée sur l'objet reponse, correspondant au résultat de notre requête GET, nous permet de connaître ses attributs.

dir(reponse)

Nous obtenons l'affichage suivant :

['__attrs__',

Sans tenir compte des nombreuses méthodes spéciales (celles commençant par les caractères « __ ») nous constatons l'existence d'une vingtaine d'attributs rattachés à notre objet reponse.

L'examen de ces attributs montre qu'il est possible d'accéder facilement à toutes sortes d'informations liées à HTTP, entre autres :

• le code statut retourné par le serveur avec la méthode status_code ;
• les entêtes avec la méthode headers ;
• et le code source html avec la méthode text.

Nous pouvons aussi vérifier avec la méthode is_redirect si une redirection a eu lieu et contrôler l'url finale avec la méthode url.

print(reponse.is_redirect)
# affiche False

print(reponse.status_code)
# affiche 200

Création d'un module

Les développeur·se·s peuvent non seulement utiliser les modules existants, mais aussi créer leurs propres modules logiciels.
Nous allons l'illustrer avec un exemple simple, en créant un module dédié aux conversions de températures entre les degrés Celsius et Fahrenheit. Notre module pourra également indiquer s'il gèle pour toute température exprimée (en Celsius, comme en Fahrenheit).

Nous définissons notre module avec le code ci-après, que nous enregistrons dans un fichier nommé temperatures.py.

"""
Module de conversion de températures Celsius et Fahrenheit.

Ce module permet :
- d'effectuer des conversions de températures entre des degrés Celsius et des degrés Fahrenheit et réciproquement
- d'indiquer si une température, exprimée en Celsius ou en Fahrenheit, est une température de gelée. """

def celsius_en_fahrenheit(degres_celsius):

def fahrenheit_en_celsius(degres_fahrenheit):

def gel(temperature, unite='C'):

Nous pouvons ensuite importer ce module dans nos programmes, et ainsi accéder à l'ensemble des fonctionnalités qu'il propose.

Ils sont utiles non seulement pour la maintenance du code, mais pas seulement, comme nous allons le mettre en évidence dans un instant.

Une fois notre module réalisé, nous pouvons en importer et en utiliser les fonctions en quelques lignes de code.

import temperatures

print(temperatures.celsiusenfahrenheit(0))
# affiche 32.0
print(temperatures.fahrenheitencelsius(212))
# affiche 100.0
print(temperatures.gel(0))
# affiche True
print(temperatures.gel(33, 'F'))
# affiche False
print(temperatures.gel(32, 'F'))
# affiche True

Le fait d'avoir renseigné notre module et ses fonctions avec des docstrings permet à Python de proposer l'aide correspondante avec les fonctions natives de l'aide système.

help(temperatures)

Nous obtenons l'affichage suivant :

Help on module temperatures:

NAME

DESCRIPTION

FUNCTIONS

La docstring figurant au début du module est prise en compte de la manière suivante :

• la première ligne, associée au nom du module, en fournit une description synthétique dans la section « NAME » (nom) ;
• les lignes suivantes apparaissent dans la section « DESCRIPTION » ;
• les docstrings des fonctions sont présentées individuellement dans la section « FUNCTIONS » (fonctions) à la suite de leur nom et de leurs paramètres.

Nous savons maintenant utiliser et créer des modules au niveau local. Découvrons maintenant ce qu'il est possible de réaliser avec une connexion au web.

Accès aux API web

Intéressons-nous aux possibilités d'interactions avec des modules distants par le biais d'API web. Commençons par définir et caractériser ce qu'est une API web.

Définition

Le sigle API désigne de manière générique tout type d'interface applicative. Dans le cadre de ce cours nous nous intéressons aux API du web.

Caractérisation d'une API web

Cette API expose ses données via des points d'accès (endpoints en anglais) qu'il est possible de consulter par le biais de requêtes HTTP. Les URL des points d'accès sont indiquées dans la documentation de l'API. Les réponses sont généralement proposées au format JSON ou parfois en XML.

Il existe différentes manières de proposer une API dans le contexte du web, mais ces API respectent généralement le modèle appelé REST (pour Representational State Transfer).
Ce modèle est basé sur des paires de requêtes et de réponses caractérisées par l'absence de notion d'état entre ces requêtes qui sont totalement indépendantes les unes des autres, en conformité avec la logique du protocole HTTP. Une API respectant le modèle REST est appelée RESTful.

Les interactions avec les API web reposent sur l'emploi de verbes HTTP : principalement GET pour consommer des données, éventuellement complété par POST, PUT et DELETE si l'API permet aussi de créer et d'éditer des données sur le serveur.

Modalités d'accès aux API

Les API web possèdent des modalités d'accès variables. Celles-ci sont définies par le producteur du service et peuvent être caractérisées selon plusieurs critères :

• coût (gratuit ou payant) ;
• utilisateur·rices·s (accessible à tou·te·s ou seulement à un public restreint) ;
• mode d'accès (avec ou sans clé d'accès) ;
• utilisation avec ou sans limitation (en général sous la forme d'un nombre de requêtes par unité de temps) ;
• réutilisation, avec ou sans restriction d'exploitation des données, et le cas échéant une distinction selon que la réutilisation soit ou non à vocation commerciale.

Les points d'accès à l'API sont indiqués par la documentation, ainsi que nous allons l'illustrer en interrogeant de manière concrète une API web.

Interrogation d'une API

L'interrogation de l'API sera effectuée à l'aide de la bibliothèque Requests présentée en première partie de ce cours.

La documentation de l'API est consultable à cette adresse. On y trouve également le code source et la licence d'utilisation.

Cette documentation nous précise que les points d'accès fournissent des données au format JSON, et nous fournit le format de l'URL à laquelle envoyer notre requête pour connaître tous les jours fériés d'une année : https://jours-feries-france.antoine-augusti.fr/api/:annee

Effectuons la requête GET correspondante pour l'année 2020.

import requests

reponse = requests.get('https://jours-feries-france.antoine-augusti.fr/api/2020')
print(reponse.json())

Ce code produit l'affichage suivant :

[{'date': '2020-01-01', 'nom_jour_ferie': "Jour de l'an"},

Nous pourrions ensuite facilement extraire et traiter des éléments parmi ces données obtenues via l'API web. L'accès aux données du web sous forme d'API n'est guère plus compliqué que l'accès à des données stockées dans un fichier local.

Les modalités d'interactions varient d'une API à l'autre : certaines sont très simples et proposent uniquement quelques points d'accès en consultation seule, quand d'autres, plus complexes, peuvent comporter de nombreux points d'accès et supporter plusieurs méthodes, afin de non seulement obtenir mais également transmettre ou éditer des données sur le serveur.