Chapitre no 1
Modularité - API
I. Modularité
La modularité dans l’écriture d’un projet informatique consiste à le découper en différentes parties réalisant chacune
des tâches précises et en étant indépendantes les unes des autres.
Pour cela il faut :
• écrire des fonctions élémentaires ;
• combiner ces fonctions pour construire des fonctions plus complexes.
En Python, ces parties sont appelées modules. Ce sont des fichiers d’extension « .py » contenant des constantes, des
fonctions, etc...
Certains de ces modules sont installés par défaut, par exemple :
• math : contient différentes fonctions mathématiques ;
• random : contient les outils nécessaires à la création de nombres aléatoires.
• turtle : permet de faire des dessins ;
• Tkinter : contient les outils nécessaires à la création d’interfaces graphiques.
Pour utiliser le module « nom_module », soit :
• on écrit l’instruction « import nom_module » et toutes les fonctions et les constantes du module sont importées et
sont appelées par l’instruction « nom_module.nom_fonction() » ou « nom_module.nom_constante ».Par exemple :
>>> import math
>>> [Link](16)
4.0
Remarque L’écriture nom_module.nom_fonction() peut être un peu longue à écrire. On peut la simpli-
fier en créant un alias du nom du module. Par exemple :
>>> import math as mt
>>> [Link](16)
4.0
On crée l’alias mt de math avec le mot-clé « as ».
• on écrit l’instruction « from nom_module import * » et toutes les fonctions et les constantes du module sont
importées et sont appelées par l’instruction « nom_fonction() » ou « nom_constante ». Par exemple :
>>> from math import *
>>> sqrt(16)
4.0
Remarque Il est possible d’importer seulement quelques fonctions ou constantes du module en écrivant :
« from nom_module import nom_fonc1(), nom_fonc2(), nom_const1 ». Par exemple
>>> from math import cos, pi
>>> cos(pi)
-1.0
Chaque module est caractérisé par :
• son interface qui est la liste des fonctions contenues dans le module.
• sa réalisation (son implémentation), à savoir le code lui-même.
L’interface est lié à la documentation expliquant ce que l’on doit connaitre pour utiliser les fonctions du module sans
en connaître nécessairement la façon dont elles ont été construites, c’est le principe d’encapsulation.
Les instructions python permettant d’accéder à ces informations sont :
• « dir(nom_module) » : affiche le contenu du module nom_module ;
• « help(nom_module) » : afficher l’interface du module nom_module ;
• « help(nom_module.nom_fonction) » : affiche la documentation de la fonction nom_fonction.
Exercice no 1
a) Afficher la documentation du module math.
b) Quelles sont les constantes définies dans ce module ?
c) Afficher la documentation de la fonction « pow » du module math.
Exercice no 2
On considère le module [Link] :
"""
Le module périmètre calcule les périmètres de figures géométriques du plan.
Il contient deux fonctions : rectangle(long, larg), carre(c) et la constante pi
"""
from math import pi
def rectangle(long, larg):
"""
Retourne le périmètre d'un rectangle
- de longueur long de type float
- de largeur larg de type float
"""
assert type(long) is float or type(long) is int, 'Erreur de type de la longueur'
assert type(larg) is float or type(larg) is int, 'Erreur de type de la largeur'
return 2. * (long + larg)
def cercle(r):
""" Retourne le périmètre d'un cercle de rayon r de type float"""
assert type(r) is float or type(r) is int, 'Erreur de type du rayon'
return 2 * pi * r
et le fichier [Link] se trouvant dans le même dossier que le fichier [Link] :
import perimetre
print([Link](2,3))
print([Link](5))
a) Écrire et tester les programmes ci-dessus.
b) Afficher le contenu et l’interface du module « perimetre ».
c) Écrire le module « aire » contenant les fonctions permettant de calculer : l’aire d’un rectangle et l’aire d’un
disque. Tester ce module dans le fichier [Link].
Une bibliothèque est un ensemble de modules. Il en existe de nombreuse en Python, elles viennent compléter la
bibliothèque standard (celle qui est déjà installée) :
• matplotlib : utilisée pour la réalisation de graphiques ;
• numpy : permet la manipulation de grands volumes de données de même type, sous forme de tableaux, de
manière bien plus efficace que les listes Python.
• scipy : utilisée pour le calcul scientifique ;
• etc ...
Exemple
pyplot est un module de la bibliothèque matplotlib regroupant un grand nombre de fonctions servant à créer des
graphiques.
£ ¤
Le script ci-dessous permet de tracer la courbe de la fonction carré sur l’intervalle −2 ; 2
import numpy as np
import [Link] as plt
n = 50
a = -2
b = 2
# Crée le tableau x de n nombres compris entre a et b
x = [Link](a, b, n)
# Crée le tableau y dont les valeurs sont les carres des nombres de x
y = x ** 2
# Crée et trace la figure
[Link](x, y)
[Link]()
[Link]()
On peut trouver une documentation du module pyplot à l’adresse ci-dessous :
[Link]
Exercice no 3
1. Écrire dans le fichier [Link] une fonction « courbe(f, a, b, n) » où
• f est le nom fonction python représentant la fonction mathématique dont on veut tracer la courbe ;
• a et b sont les bornes de l’intervalle où la courbe est tracée ;
• n est le nombre de points nécessaires au tracé de la courbe.
£ ¤
2. Tester cette fonction afin de représenter sur l’intervalle 0 ; 1 les courbes d’équations :
p
• y =x • y= x • y = x2 • y = x3
II. API
Une API, « Application Programming Interface », est un moyen mis en place par une application pour que d’autres
applications puissent interagir avec elle.
Elle est composée de constantes, de fonctions, etc... et peut être éventuellement proposée par un service Web avec une
documentation décrivant son utilisation.
De nombreuses API disposent d’un wrapper Python : c’est un module Python qui permet d’interroger la base de
données du fournisseur de façon simplifiée, sans avoir à écrire les requêtes Web, ni à interpréter les réponses. Celles-ci
sont généralement écrites au format JSON, qui est un format d’échange de données. À partir de ces réponses, le wrapper
Python génère des listes ou des dictionnaires, facilement manipulables.
Exercice no 4
La description de l’API Mars Rover Photos est disponible à cette adresse : [Link]
1. Installation du wrapper Python nasaapi dans Edupython :
⋆ Aller dans « installer un module avec pip » :
⋆ dans la boite de dialogue, écrire « python-nasa-api » :
2. On veut la 2ème photo prise par le rover Curiosity, le 40ème jour martien avec sa caméra frontale nommée Front
Hazard Avoidance Camera ou FHAZ.
a) Écrire pour le code ci-dessous dans le fichier [Link].
# importation du module webbrowser
import webbrowser
# importation du sous module MarsRovers du module nasaapi
from nasaapi import MarsRovers
# initialisation de la connexion avec l’API et creation de l'objet rovers
rovers = MarsRovers("DEMO_KEY", 40, "FHAZ")
# recuperation des donnees de Curiosity (dictionnaire)
cur = [Link]()
# acces à l’URL de la premiere photo
url_photo = cur["photos"][1]["img_src"]
# envoi de l’URL dans le navigateur
webbrowser.open_new_tab(url_photo)
Remarque DEMO_KEY est une clé de démonstration donnant accès à un nombre restreint de re-
quêtes.
Pour créer une clé d’identification donnant plus de possibilités voir :
[Link]
b) Tester le programme puis modifier le afin d’afficher la première photo du 40ème jour martien de la caméra
arrière Rear Hazard Avoidance Camera ou RHAZ.
3. Donner d’autres informations que l’on peut récupérer avec cette API.