Résoudre un problème grâce aux paradigmes objet et fonctionnel
L’objectif de ce document est d’illustrer une fois encore l’intérêt des différents paradigmes de programmation.
Cas d’étude : fonction avec paramètres
On considère l’équation qui traduit le mouvement d’une balle lancée verticalement vers le haut avec une vitesse v0 depuis l’origine des altitudes telle que l’écrit un physicien :
y(t)=−21gt2+v0t
Ce physicien a donc tendance à considérer que y est une fonction de la variable t et que cette fonction dépend des paramètres v0 et g.
Comment définir cette fonction en informatique, sachant que g est un paramètre fixe g=9,81m/s2 mais que v0 est un paramètre qu’il peut être utile de faire varier ?
Réponse
defy(t:float,v0:float)->float:"""
Calcule l'altitude d'une balle lancée vers le haut verticalement avec la vitesse v0 au cours du temps depuis l'origine des altitudes.
REMARQUE : la fonction définit un paramètre constant g = 9.81
"""g=9.81return-0.5*g*t**2+v0*t
Problème
Le physicien qui vient de définir la fonction de la question 1. peut vouloir utiliser les fonctions que certains modules, tels que les modules math, numpy ou scipy, proposent. Ces fonctions étant les plus générales possibles, elles implémentent le point de vue du physicien, y est une fonction de t, plutôt que celui de l’informaticien, y est une fonction de t et de v0.
Comment modifier la définition de la fonction y pour qu’elle puisse être utilisée avec n’importe quelle autre fonction ?
Illustration du problème
On peut avoir envie de déterminer la vitesse vy(t) de la balle. La relation mathématique entre vy(t) et y(t) est la suivante
vy(t)=dtdy=y′(t)
vy(t) est la dérivée par rapport au temps de y(t).
On peut montrer, en analyse numérique, que, en un point d’abscisse x0
f′(x0)≈hf(x0+h)−f(x0)
Définir la fonction diff dont la spécification est :
defdiff(f:Callable,x0:float,h:float=1e-7)->float:"""
Calcule la dérivée de la fonction f au point d'abscisse x0.
REMARQUE : le paramètre h est fixé à h = 1e-7 par défaut.
"""
Réponse
defdiff(f:Callable,x0:float,h:float=1e-7)->float:"""
Calcule la dérivée de la fonction f au point d'abscisse x0.
REMARQUE : le paramètre h est fixé à h = 1e-5 par défaut.
"""return(f(x0+h)-f(x0))/h
Tester cette fonction en calculant la dérivée de cos(x) au point x=0.
Rappel :(cos(0))′=−sin(0)=0.
Réponse
importmathasmprint(diff(m.cos,0))
La fonction diff peut-elle être utilisée pour déterminer la dérivée de la fonction y ?
Réponse
Non, puisque diff ne prend que le nom de la fonction à dériver en argument et pas ses paramètres. diff suppose que la fonction f est une fonction à une seule variable.
Première (très mauvaise !) solution : utilisation d’une variable globale
Écrire la fonction y1 dont la spécification est
defy1(t:float)->float:"""
Calcule l'altitude d'une balle lancée vers le haut verticalement avec la vitesse v0 au cours du temps depuis l'origine des altitudes.
REMARQUE : la fonction définit un paramètre constant g = 9.81
REMARQUE : la fonction utilise la variable globale v0.
"""
Déterminer la valeur de la vitesse de la balle à la date t=0,1s en utilisant la fonction y1.
Remarque :v0=3m/s et la réponse attendue est vy=2,02m/s.
Réponse
v0=3t=0.1print(diff(y1,t))
Pourquoi est-ce une mauvaise idée que d’utiliser des variables globales ?
Réponse
Une variable globale peut être utilisée et modifiée à plusieurs endroits d’un programme. Il n’est pas toujours facile, lors de l’appel d’une fonction utilisant une variable globale, de savoir exactement quelle est sa valeur.
Deuxième méthode : représenter une fonction par une classe
Sans utilisation des méthodes spéciales
À retenir
Une classe définit un nouveau type et est constituée d’attributs (variables) et de méthodes (fonctions). Les attributs sont accessibles en lecture et en modification par toutes les méthodes ; ce sont des variables globale à la classe !
Définir la classe Y1 dont la spécification est
classY1:"""
Classe représentant la fonction mathématique y.
Attributs
---------
g : float
Paramètre g dont la valeur est fixée à l'initialisation de l'objet.
v0 : float
Paramètre v0 dont la valeur est récupérée à l'initialisation de l'objet.
Méthode
-------
valeur(self, t: float) -> float
Retourne la valeur de y à la date t passée en argument.
"""
Réponse
classY1:"""
Classe représentant la fonction mathématique y.
Attributs
---------
g : float
Paramètre g dont la valeur est fixée à l'initialisation de l'objet.
v0 : float
Paramètre v0 dont la valeur est récupérée à l'initialisation de l'objet.
Méthode
-------
valeur(self, t: float) -> float
Retourne la valeur de y à la date t passée en argument.
"""def__init__(self,v0:float,g:float=9.81)->None:self.v0=v0self.g=gdefvaleur(self,t:float)->float:"""
Retourne la valeur de y à la date t passée en argument.
"""return-0.5*self.g*t**2+self.v0*t
Créer un objet de type Y1 et vérifier que la valeur de la fonction y à la date t=0,1s, lorsque v0=3m/s est 0,25m.
Réponse
yo=Y1(3)print(yo.valeur(0.1))# ou assert yo.valeur(0.1) == y(0.1, 3)
Déterminer la vitesse de la balle à cet instant.
Réponse
yo=Y1(3)print(diff(yo.valeur,0.1))
En utilisant une méthode spéciale
On peut penser que la définition de la classe Y1 fait trop apparaître le concept d’objet au détriment de celui de fonction. En particulier, l’appel yo.valeur(0.1) n’est pas aussi clair que yo(0.1).
Les classes possèdent cependant, en Python, une méthode spéciale nommée __call__ appelée automatiquement chaque fois que l’on utilise un objet comme une fonction.
Définir la classe Y2 dont le code est proche de celui de Y1 mais qui redéfinit la méthode __call__ à la place de définir la méthode valeur.
Réponse
classY2:"""
Classe représentant la fonction mathématique y.
Attributs
---------
g : float
Paramètre g dont la valeur est fixée à l'initialisation de l'objet.
v0 : float
Paramètre v0 dont la valeur est récupérée à l'initialisation de l'objet.
"""def__init__(self,v0:float,g:float=9.81)->None:self.v0=v0self.g=gdef__call__(self,t:float)->float:"""
Retourne la valeur de y à la date t passée en argument.
"""return-0.5*self.g*t**2+self.v0*t
Déterminer la vitesse de la balle à dans les mêmes conditions qu’à la question 10.
Réponse
yo=Y2(3)print(yo(0.1))
Troisième méthode : premiers pas dans le monde fonctionnel
À retenir
En programmation fonctionnelle, les fonctions sont des objets de première classe : une fonction peut être passée comme argument à une autre fonction, une fonction peut retourner une fonction.
Qu’attend comme argument la fonction fixe_param ?
Réponse
fixe_param possède le paramètre v0.
Que sont les variables v0 et g pour la fonction calcule_y ?
Réponse
Ce sont des variables externes (non locales). En fait calcule_y les considère comme des variables globales (même si elles sont seulement locales à la fonction fixe_param). Le dernier point de ce document précise le vocabulaire.
Quel est le type de y3 ?
Réponse
y3 référence une fonction.
Que signifie l’instruction y3(0.1) ?
Réponse
y3(0.1) est un appel de fonction. On appelle la fonction référencée par la variable y3 avec l’argument 0.1.
Info
Utiliser le site Pythontutor pour bien comprendre l’effet de chacune des instructions.
Quelles lignes de code faudrait-il modifier si maintenant la balle est lancée à la vitesse v0=5m/s et que l’on cherche toujours sa position à la date t=0,1s ?
Réponse
y5=fixe_param(5)print(y5(0.1))
Quel est le rôle de la fonction fixe_param ?
Réponse
fixe_param enveloppe calcule_y, elle permet de réaliser une fermeture (closure).
À retenir
Dans un langage de programmation, une fermeture (en anglais : closure) est une fonction accompagnée de son environnement lexical. L’environnement lexical d’une fonction est l’ensemble des variables non locales qu’elle a capturé, soit par valeur (c’est-à-dire par copie des valeurs des variables), soit par référence (c’est-à-dire par copie des adresses mémoires des variables). Une fermeture est donc créée, entre autres, lorsqu’une fonction est définie dans le corps d’une autre fonction et utilise des paramètres ou des variables locales de cette dernière.