I - Fonctions simples 1

TP4 - Fonctions & Procédures

I - Fonctions simples
Rappel : poly de cours chapitre IV (pages 23 à 26, utilisation des fonctions) et chapitre VIII (pages 45 à 51, créer
des sous-programmes).
Vous devez absolument être capable de faire les opérations notées Ψ seuls !

1) Définition et utilisation de petites fonctions

Note : dans Pyzo vous pouvez créer des fchiers module Python, ces petits scripts pouvant faire plusieurs
lignes, cela sera plus pratique pour faire des corrections que le mode shell Python.
Ψ Défnissez une fonction vol_sphere(r) qui calcule et retourne le volume d'une sphère de rayon r avec la
4
formule 3
π r 3 . Écrivez les instructions pour calculer et afcher les volumes pour des sphères de rayon 1 et
2.
Ψ Défnissez une fonction poly(x) qui retourne la valeur du calcul du polynôme x 3−2 x 2 + 4.5 x −4 .
Ψ Écrivez les instructions pour appeler cete fonction et afcher le résultat du calcul du polynôme ci-dessus
pour les valeurs 0, 1, 2, 20.
Ψ Écrivez les instructions pour remplir une liste lst qui contienne les résultats des calculs du polynôme ci-
dessus pour les valeurs entières de 0 à 100 compris.

2) Fonction à plusieurs arguments

Ψ Défnissez une fonction moy(a, b) qui calcule et retourne la moyenne de ses deux paramètres.
Ψ À partir de deux listes contenant le même nombre de valeurs fotantes lstx et lsty, appelez la fonction
moy() dans une boucle avec les valeurs de même indice de lstx et de lsty et afchez le résultat calculé.

3) À éviter… à faire
a) Afichage intempestif
Sauf si l’énoncé le demande, une fonction ne fait pas d’afchage, elle réalise un traitement et produit géné-
ralement un résultat qu’elle retourne.

b) Saisie intempestive
Sauf si l’énoncé le demande, une fonction ne fait pas de saisie, elle trouve ce dont elle a besoin dans ses
paramètres et/ou dans des variables globales.

c) Documentation des fonctions

Dans le cadre du TP, vous devrez documenter vos fonctions, cela fera partie de la note.
#!/usr/bin/python3
# -*- encoding : utf-8 -*-
"""Documentation du module, cadré à gauche dans le module.

Si besoin sur plusieurs lignes (la première est une indication de l'usage).
blabla
"""

def mafonction(params) :
"""Documentation de la fonction, indentée comme le bloc de code.

Si besoin sur plusieurs lignes (la première est un résumé synthétique).

blabla
"""
# le code de la fonction
2 II - Portée des variables

II - Portée des variables

Ouvrez et exécutez le script TP4_portee.py fourni. Regardez les

1) Portée locale (dans la fonction seulement)

La première partie du script montre que les paramètres et les variables locales à une fonction ne sont pas
accessibles à l’extérieur de celle-ci (ils n’existent plus lorsqu’on sort de la fonction).

2) Portée globale (dans le module et dans les fonctions du

module)
La seconde partie du script défnit trois globales, la première gvisible est simplement accédée en lecture (ie.
on utilise simplement sa valeur), la seconde gmasque est redéfnie localement dans la fonction et empêche de
voir la valeur de la globale, la troisième gmodifie est explicitement déclarée globale dans la fonction, ce qui
permet de réafecter sa valeur de l’intérieur de la fonction.

3) Efets de bord
La troisième partie du script montre qu’une fonction peut modifer une variable globale gliste mutable direc-
tement, sans avoir à spécifer la directive globale, car elle accède à la valeur (ici la liste) et modife directement
le contenu de cete valeur sans avoir à passer par une réafectation.
Plus insidieusement, cela montre aussi que si une fonction modife le contenu d’une valeur mutable qui lui est
donnée en paramètre (maliste), cete modifcation persiste dans cete valeur après l’appel de la fonction (tant
que cete valeur existe).
On évitera au maximum d’utiliser ces efets de bords, et autant que possible de modifer des variables globales
à partir de l’intérieur des fonctions.

III - Définition avancée de fonctions

1) Valeurs par défaut pour les paramètres
La mise en place d’une valeur par défaut pour un paramètre permet de ne pas avoir à spécifer d’argument
pour celui-ci lors de l’appel.
 Défnissez une fonction politesse() acceptant trois paramètres chaînes de caractères : identite ,
civilite et formule. Cete fonction retourne la formule de politesse formatée 1 avec l’identité de la personne et
la civilité (généralement Madame ou Monsieur ou Mademoiselle).
Par exemple : politesse("Charlotte", "Madame", "Bonjour, {civilite} {identite}")

retourne "Bonjour, Madame Charlotte".

Ψ Fournissez une valeur par défaut "Madame, Monsieur" pour le paramètre civilite et une valeur par
défaut "Veuillez agréer {civilite} {identite}, l'expression de mes sentiments distingués" pour
le paramètre formule.
Ψ Appelez cete fonction en fournissant les trois paramètres, seulement deux (premier et second, premier et
dernier), seulement le premier.

2) Retour de plusieurs valeurs - « encapulation / décapsulation »

Ψ Défnissez une fonction f(a, b) qui retourne les résultats des calculs de 2a+b et de 2b+a.
Ψ Appelez cete fonction avec les valeurs 1 et 2 et stockez les deux résultats dans une seule variable res. À
partir de cete variable, afchez les deux résultats, le carré du premier résultat et le cube du second résultat.
 Appelez cete fonction et stockez directement les deux résultats dans deux variables x et y. Afchez ces deux
variables.

3) Nombre variable d’arguments

La notation *args, placée en dernier paramètre dans la défnition, permet de recevoir un nombre variable d’ar-
guments dans le paramètre args2, sous la forme d’un tuple qui contient les valeurs.

1 - Voir méthode .format() des chaînes dans le mémento.

III - Défnition avancée de fonctions 3

Ψ Défnissez une fonction stritems() acceptant un nombre variable de valeurs numériques en argument, et
retournant une chaîne de caractères contenant les représentations textuelles de ces nombres séparées par des
deux-points.
Par exemple : stritems(1, 4.3, 6, -3)
retourne "1:4.3:6:-3"
 Défnissez une liste lst avec les nombres de 1 à 100 compris. Écrivez l’appel à stritems() utilisant cete
liste en argument (opération spéciale de « décapsulation de liste » en arguments).

4) Fonctions en tant que variable ou paramètre

Les fonctions sont des « objets de premier niveau », que l’on peut afecter à des variables ou transmetre en
argument à d’autres fonctions.
 Défnissez une fonction afficheur(f,deb,fin,pas) qui reçoit en argument pour le paramètre f une fonc-
tion quelconque acceptant un argument fotant. La fonction afcheur a aussi trois paramètres fotants deb,
fin, pas (en considérant fn>début et pas>0). Cete fonction afche les résultats des calculs f(x) pour x entre
deb et fn en respectant le pas.
 Appliquez cete fonction afficheur() aux fonctions sin puis cos puis floor du module math, entre 0 et π
avec un pas de 0.1.
 Défnissez une variable cosinus qui référence la fonction cos du module math. Appliquez la fonction
afficheur() à votre variable cosinus.

 Défnissez une fonction calcul(x) qui retourne la valeur de 1+2x. Appliquez la fonction afficheur() à
votre fonction calcul().

IV - Travail personnel à rendre

1) Présentation d’informations
Créez un fchier module Python TP4presente.py dans votre répertoire de TP.
Écrivez une fonction print_cols(lstx, lsty, lstz) qui afche d’une façon propre, sur 3 colonnes, en ali-
gnant les valeurs avec deux décimales (on considérera un maximum de 5 chifres avant la virgule), les nombres
fotants issus des trois listes (qui contiennent le même nombre d’éléments). La fonction afchera un en-tête
des noms de colonnes X, Y, Z. Elle ne retourne rien.
Écrivez un appel permetant de tester la fonction.
Par exemple print_cols([1.0, 2.3245, 4254.152], [-3.2, 712, 427.1232], [3.712, -0.032, 11.32])
Afchera :
X Y Z
1.00 -3.20 3.71
2.32 712.00 -0.03
4254.15 427.12 11.32
Note : revoir la section sur le formatage des chaînes dans le mémento.

2) Fonction de saisie
Créez un fchier module Python TP4pourcent.py dans votre répertoire de TP.
Écrivez une fonction saisie_pourcents() qui efectue trois saisies de valeurs fotantes correspondant à des
pourcentages de « pour », « contre » et « abstentions » (demander des valeurs entre 0 % et 100%) et retourne
ces trois valeurs. Note : là on demande explicitement que la fonction fasse faire la saisie à l’utilisateur.
Utiliser cete fonction dans une boucle qui ré-exécute la saisie tant que que la somme des trois valeurs est difé-
rente de 100 (comme les valeurs sont fotantes, on autorisera un epsilon de 10 -10).
Afchez fnalement les trois valeurs valides.

3) Calcul de polynôme
Créez un fchier module Python TP4polynome.py dans votre répertoire de TP.

2 - On utilise args par convention, il est possible de choisir un autre nom de paramètre.
4 IV - Travail personnel à rendre

Défnissez une fonction polynome() qui accepte un premier paramètre x, suivi d’un nombre variable de coefc-
ients d’un polynôme, ordonnés par ordre croissant des puissances (les coefcients peuvent être nuls pour cer-
taines puissances). Cete fonction calcule et retourne la valeur du polynôme appliqué à x.
• polynome(x) calcule 0.
• polynome(x, a) calcule ax0
• polynome(x, a, b) calcule ax0 + bx1.
• polynome(x, a, b, c) calcule ax0 + bx1 + cx2.
• polynome(x, a, b, c, d) calcule ax0 + bx1 + cx2 + dx3.
• etc.
(vérifez votre fonction sur quelques cas faciles)
Demandez à l’utilisateur de saisir un nombre variable de coefcients (sortir de la boucle sur une saisie vide),
puis de saisir une valeur de début, une valeur de fn et une valeur de pas (en considérant fn>début et pas>0).
Afchez les résultats des calculs du polynôme correspondant aux coefcients saisis pour les valeurs de début à
fn avec le pas donné.

4) Tracé de courbe
Créez un fchier module Python TP4courbe.py dans votre répertoire de TP.
En reprenant l'exemple de tracé de courbe du module fourni dans le TP2 TP2_fabricliste.py, écrivez une
fonction courbe(lstx, lsty, labelx, labely, titre) qui trace la courbe des valeurs de la liste lsty en fonc-
tion des valeurs de la liste lstx. Défnissez des valeurs par défaut pour les labels et le titre.
Appliquer cete fonction aux résultats de la fonction poly(x) écrite au début de ce TP, pour des valeurs de x de
-10 à +10 avec un pas de 0.1. Remplissez deux listes listex et listey avec les valeurs correspondantes, et uti-
lisez votre fonction pour tracer la courbe.

5) Suivi d'appels de fonctions

Créez un fchier module Python TP4suivi.py dans votre répertoire de TP.
Écrivez une fonction affiche_memo(s) qui afche la chaîne s qu’on lui fournit et l’ajoute dans une variable
liste globale memoaff Cete fonction met aussi à jour une variable entière globale maxmemo qui contient la lon-
gueur de la plus grande chaîne mémorisée dans memoaff
Écrivez une fonction bilan() qui afche le nombre de chaînes traitées par affiche_memo() depuis le dernier
bilan, la longueur de la plus grande chaîne mémorisée, les trois premières et les trois dernières chaînes mémo -
risées, puis réinitialise à vide memoaffet remet à zéro maxmemo.
Écrivez une boucle programme principal qui appelle un nombre de fois sufsante (une centaine à un millier de
fois) la fonction affiche_memo() avec des séries de chaînes diférentes (vous pouvez utiliser des fonctions du
module random pour assurer des variations lors de la création des chaînes), et qui appelle de temps en temps la
fonction bilan() dans la boucle.
IV - Travail personnel à rendre 5

6) Aficheur 7 segments avec turtle (bonus)

Le but de l’exercice est d’afcher des valeurs numériques dans une représentation
graphique semblable aux afcheurs 7 segments que l’on trouve dans certains
appareils électroniques (cf. illustration ci-contre). Pour simplifer, on tracera des
afcheurs droits, pas obliques, et sans point décimal.
Pour les tracés, on donne en exemple le script TP4_exempleturtle.py qui montre
l’utilisation des fonctions du module turtle permetant la gestion absolue de la position et l’orientation de la
tortue, ainsi que sur le tracé et remplissage de polygones — vous pouvez le reprendre dans votre répertoire de
TP et l’utiliser pour faire des tests.
Créez un fchier module Python TP4afficheur.py dans votre répertoire de TP, qui contiendra les fonctions
nécessaires à un afchage 7 segments. Il commencera par les initialisations de turtle pour tracer rapidement.

a) Aficher un segment
On défni le chemin permetant de tracer un segment :

À partir des paramètres longueur et epaisseur, comment calculer la valeurs petite_longueur des quatre
traits obliques et la valeur grande_longueur des deux grands traits ?
Écrivez une fonction segment(epaisseur, longueur, coultour, coulrempl), qui réalise les déplacements 1 à
6 de ce chemin (le déplacement 0 à la position de départ sera réalisé par ailleurs), d’une façon relative 3 et en
utilisant le remplissage de polygone avec les deux couleurs données pour le trait du contour et le remplissage).
Après le tracé du segment, un déplacement sans tracé doit être réalisé pour replacer la tortue à l’extrémité du
segment (point entre les mouvements 3 et 4) et dans la même direction que la direction initiale — comme si la
fgure constituée par le segment n’était qu’un trait épais. Le crayon sera laissé levé.
On doit arriver à une fgure du style :

Écrivez deux fonctions, seg_horizontal(epaisseur, longueur, coultour, coulrempl) et

seg_vertical(epaisseur, longueur, coultour, coulrempl), qui tracent respectivement un segment hori-
zontal vers la droite ou vertical vers le haut (utilisez l’orientation absolue de la tortue) à partir de la position
courante de la tortue.
Testez cete fonction en traçant un segment horizontal et un segment vertical. Laissez le bloc de votre code de
test dans une condition if False:… (ce qui permet de le réactiver simplement).

b) Aficher… 7 segments
Dans la litérature électronique, les segments sont nommés de A à G comme indiqué dans la
fgure (on a omis le point décimal qui existe en bas à droite sur certains afcheurs, habituel-
lement nommé DP).
Pour savoir quels segments doivent être allumés, on utilisera simplement une chaîne de
caractères contenant les letres des segments correspondants. Représenté sous forme d’un
dictionnaire (cf dernier cours) pour chaque chifre, cela donne :
SEGMENTS = { '0': "ABCDEF",
'1': "BC",
'2': "ABGED",
'3': "ABGCD",
'4': "BCFG",
'5': "ACDFG",
'6': "ACDEFG",
'7': "ABC",
'8': "ABCDEFG",

3 - Relative → le segment doit pouvoir être tracé avec n’importe quelle orientation de base, en n’importe quel
point d’origine.
6 IV - Travail personnel à rendre

'9': "ABCDFG",
}
Écrivez une fonction sept_segments(segments, epaisseur, longueur, coultour, coulallume, couleteint)
chargée de tracer les sept segments d’un afcheur. Si un segment doit être allumé on utilisera pour le remplis-
sage la couleur coulallume, et s’il doit être éteint la couleur couleteint. (note : l’utilisation d’expressions « if
ternaire » valeur1 if cond else valeur2) peut faciliter le code).
Le tracé d’un afcheur se fera en démarrant à la pointe de jonction des segments E et D, en bas à gauche. En
combinant des tracés de segments horizontaux vers la droite et verticaux vers le haut, et en utilisant lorsque
nécessaire la mémorisation de position et le déplacement absolu vers cete position.
À la fn du tracé la tortue sera repositionnée sur le point d’origine, dans son sens d’orientation d’origine.
Testez cete fonction en traçant tous les segments allumés et un peu plus loin tous les segments éteints. Laissez
le bloc de votre code de test dans une condition if False:… (ce qui permet de le réactiver simplement).
Écrivez une fonction chiffre_segments(chiffre, epaisseur, longueur, coultour, coulallume,
couleteint) qui à partir de la représentation textuelle d’un chifre, afche celui-ci sous la forme d’un afcheur
7 segments.
Testez cete fonction en traçant un des chifres. Laissez le bloc de votre code de test dans une condition if
False:… (ce qui permet de le réactiver simplement).

c) Aficher l’heure
Écrivez une fonction affiche_heure(sheure, epaisseur, longueur, coultour, coulallume, couleteint)
qui à partir d’une chaîne de caractères représentant une heure (par exemple "11 45 02"), afche les chifres
sous forme d’afchage 7 segments, en assurant l’espace entre les chifres et un espace plus grand lorsqu’il y a
un espace.
L’afchage se fait à partir d’une position absolue de votre choix (éventuellement 0,0), toujours la même.
Bonus : permetre d’afcher les caractères ‘:’ de séparation entre heures et minutes et minutes et secondes
s’ils sont dans la chaîne.
Testez cete fonction en afchant une heure quelconque fournie directement sous forme de chaîne. Laissez le
bloc de votre code de test dans une condition if False:… (ce qui permet de le réactiver simplement).

d) Une horloge
Créez un module TP4horloge.py qui import la fonction affiche_heure du module TP4afficheur.
Dans le module standard Python time, vous trouverez une fonction strftime() permetant de formater une
heure (par défaut l’heure courante). Elle prend comme premier paramètre une chaîne de formatage qui inter-
prète les séquences%… et utilise entre autres : %H pour l’heure sur deux chifres, %M pour les minutes sur deux
chifres et %S pour les secondes sur deux chifres. Vous trouverez également une fonction sleep() qui permet
de metre en pause le programme durant une durée (nombre fotant) exprimée en secondes.
Faites une boucle qui afche 10 fois l’heure courante, avec une pause de une seconde entre deux afchages.
Ajoutez ensuite les initialisations nécessaires de turtle pour avoir un afchage rapide, ainsi que l’appel à
affiche_heure() pour afcher cete heure.

Note : joli résultat en utilisant un fond noir (t.bgcolor("black")) et des couleurs "#3F3F3F" pour le contour,
"#FFFF00" pour les segments allumés et "#0F0F0F" pour les segments éteints. Une épaisseur de 4 et une lon-
gueur de 20 permetant d’avoir les afcheurs dans la fenêtre. Par exemple pour "12:45 12" :