Programmer en Python en 2nde

Quelques exercices autour des fonctions

Interpréter une fonction

Cet exercice n'a pas d'autre intérêt que permettre aux élèves d'interpréter la définition d'une fonction écrite en Python.

On considère la fonction ci-dessous, écrite en Python : 


def f(x):
    y = 2*(x+3)
    y = y+x
    return y/3-2

On considèrera que le calcul sur les float est mathématiquement correct.

  1. Quelle est la valeur de f(-2) ?
  2. Déterminer les images de 5 puis de 0 par cette fonction f. Que constate-t-on ?
  3. Donner une expression simplifiée de la fonction f en fonction de x. Conclure.
  • Question 1°/
  • Question 2°/
  • Question 3°/
  • Commentaire
Valeur de x en paramètre : -2
1ère valeur de y : 2*(-2+3) = 2
2ème valeur de y : 2 + (-2) = 0
Valeur renvoyée par f : 0/3 - 2 = -2
Valeur de x en paramètre : 0
1ère valeur de y : 2*(0+3) = 6
2ème valeur de y : 6 + 0 = 6
Valeur renvoyée par f : 6/3 - 2 = 0
Valeur de x en paramètre : 5
1ère valeur de y : 2*(5+3) = 16
2ème valeur de y : 16 + 5 = 21
Valeur renvoyée par f : 21/3 - 2 = 5

On constate que la valeur renvoyée par la fonction f semble égale à la valeur entrée en paramètre de f.

Valeur de x en paramètre : x
1ère valeur de y : 2*(x+3) = 2*x + 6
2ème valeur de y : 2*x + 6 + x = 3*x + 6
Valeur renvoyée par f : (3*x + 6)/3 - 2 = x + 2 - 2 = x

Avec un algorithme, on supposera (au moins en classes de Lycée) travailler avec les objets mathématiques.

Avec un programme, l'interprétation est nécessairement soumise à l'implémentation de ces objets mathématiques en machine.

Si l'on teste par exemple le calcul de f(2.11), on obtient 2.1099999999999994, c'est à dire une image distincte de l'antécédent. C'est la raison pour laquelle, l'exercice commence par la phrase "On considèrera que le calcul sur les float est mathématiquement correct.". Et c'est la raison pour laquelle on ne raisonnera pas avec les élèves en général sur un programme : on raisonne sur un algorithme, qui manipule les objets idéaux des mathématiques.

Ci-dessous un programme avec une plage de données sur laquelle environ 50% des valeurs de x sont telles que \( f(x) \neq x \) en machine (où $f$ est la fonction de notre exercice) : 


def f(x):
    y = 2*(x+3)
    y = y+x
    return y/3-2
 
 
compteur_diff = 0


for k in  range(0,1000):   
    x = k/100  # on teste 0, 0.01, 0.02, 0.03, 0.04, ..., 9.99
    if x != f(x) : 
        compteur_diff += 1
	 
 
print(compteur_diff/1000)

Deux paramètres.

Écrire une fonction en Python qui respecte la spécification suivante :

Paramètres deux nombres réels largeur et longueur
Valeur renvoyée l'aire du rectangle dont les côtés ont pour mesure largeur et longueur.

Écrire parallèlement à cette fonction une autre fonction qui sera chargée uniquement d'afficher des résultats. Par exemple avec un message tel que : « L'aire du rectangle de largeur 2 (en unité de longueur) et de longueur 5 (en unité de longueur) est égale à 10 (en unités d'aire) ».

  • Un code possible
  • et plusieurs sorties ?

def aire_du_rectangle(largeur, Longueur):
    return largeur * Longueur
	
def affiche_aire_rectangle(l, L):
    l, L = min(l,L), max(l, L) # échange éventuel pour un message cohérent
    print("L'aire du rectangle de largeur {} et de longueur {} (en unités de longueur)".format(l,L), end = ' ')
    print("est égale à  {} unités d'aire.".format(aire_du_rectangle(l, L)))
 

affiche_aire_rectangle(5, 2)

En langage Python, on peut également avoir plusieurs sorties pour une fonction. L'affectation parralèle des variables permet de récupérer les différentes valeurs de sortie.


def aire_et_perimetre_du_rectangle(largeur, Longueur):
    return largeur * Longueur, 2*(largeur + Longueur)
	
 
l, L = 4, 7
aire, perimetre = aire_et_perimetre_du_rectangle(l, L)
print("L'aire du rectangle de largeur {} et de longueur {}".format(l, L) )
print("est égale à {},".format(aire))
print("et le périmètre est égal à {}.".format(perimetre))

En fait, il n'y a qu'un seul objet en valeur de retour : le tuple (largeur * Longueur, 2*(largeur + Longueur)).

deux paramètres.

  1. Écrire une fonction en Python respectant le cahier des charges suivant :
    Paramètres la vitesse moyenne \(v_1\) sur un parcours aller, la vitesse moyenne \(v_2\) sur le parcours retour
    Valeur renvoyée la vitesse moyenne sur l'aller-retour
  2. Marie a fait un aller à 60 km/h. A quelle vitesse doit-elle rouler au retour pour que sa vitesse moyenne sur l'aller-retour soit le double de sa vitesse à l'aller ? Faîtes quelques essais avec la fonction définie précédemment. Conjecturer une réponse puis prouver.
  • Question 1
  • Question 2 

def vitesse_aller_retour(v1,v2) :
    return 2/(1/v1 + 1/v2)
	
	
print(vitesse_aller_retour(70,80))

Quelques essais semblent montrer l'impossibilité de la demande. Ce peut être l'occasion de parler des approximations en machine : print(vitesse_aller_retour(60,10**20)) renverra par exemple 120.

L'exercice peut alors être poursuivi par un simple exercice de résolution d'équation (ou en première, terminale par un exercice sur les limites).

\( 120 = \frac{2}{\frac{1}{60} + \frac{1}{v_2}} \Longleftrightarrow \frac{1}{60} + \frac{1}{v_2} = \frac{1}{60} \dots\)

trois paramètres.

Écrire une fonction en Python spécifiée comme suit :

Paramètres un entier h, un entier m, un entier s
Valeur renvoyée le temps en secondes correspondant au cumul de h heures, m minutes et s secondes
  • Un code possible

def temps_secondes(h, m, s):
    return h*3600 + m*60 + s
	
h, m, s = 2, 16, 42
print(" {} heures, {} minutes, {} secondes  correspondent à {} secondes.".format(h, m, s, temps_secondes(h, m, s)))

Milieu d'un segment

Écrire une fonction en langage Python prenant en paramètres les coordonnées de deux points et renvoyant les coordonnées du milieu du segment défini par ces deux points.

  • Un code possible


def milieu(xA, yA, xB, yB) :
    return (xA+xB)/2, (yA+yB)/2
	
	
xA, yA = 3, 4
xB, yB = 6, 9
xI, yI = milieu(xA, yA, xB, yB)
print("({} ; {})".format(xI,yI))

De deux à quatre paramètres.

On considère le programme Python suivant : 


def f(a,c):
    return 2*c - a
	
def symetrique(xA, yA, xI, yI):
    return f(xA, xI), f(yA, yI)
	
	
	
	
	
xA, yA = 3, 4
xI, yI = 6, 9
xB, yB = symetrique(xA, yA, xI, yI)
print("({} ; {})".format(xB,yB))

Quel est le rôle de la fonction symetrique ?

  • Réponse

La fonction retourne le couple des coordonnées du point $B$ symétrique de $A$ par rapport à $I$.