4 - Fonctions

Remarque : tous vos modules devront contenir obligatoirement, dans l'en-tête, un commentaire
indiquant ce que fait le programme, en précisant le numéro de l'exercice correspondant. (ce
commentaire est appelé “ documentation ” du module.)
Exercices et programmes à rendre dans le compte-rendu de TP : ex 1 (TP41_1), ex 2 (TP41_2), ex
3 (TP41_3), ex 4 (TP41_4), ex 5 (TP42_5), ex 6 (TP42_6), ex 7 (TP43_7), ex 8 (TP44_8)
Ne pas rendre les tableaux du compte rendu de TP.

4.1 - Fonctions simples

4.1.1 - Rappels de cours
Rappel : la forme générale d'une fonction est :
def maFonction(p_param1, p_param2, p_param3, etc) :
"""documentation de la fonction"""
ligne ou bloc d'instructions 1
ligne ou bloc d'instructions 2
etc...
return valeur_retournée
L'exécution de l'instruction return provoque la sortie immédiate de la fonction en retournant la
valeur spécifiée. Si une fonction ne retourne rien, Python lui fait retourner la valeur None.
Convention pour les TP : on préfixe les noms des paramètres d'une fonction par p_ pour bien les
distinguer des variables locales à la fonction et des variables globales au module.

Exercice 1 : Carrés de Sinus

Créez un script TP41_1.py (à rendre) avec l'en-tête standard, qui contienne la définition de la
fonction suivante :
from math import sin, pi
def sin2(p_x):
"""Calcul du carré du sinus."""
res = sin(p_x) ** 2
print(res)
Dans le programme principal, après la définition de la fonction, testez cette fonction avec un angle
π
4 , et comparez le résultat avec un appel direct à sin(pi/4)**2.
Toujours dans le programme principal, dans une boucle while5, remplissez une liste sincarres
π
(initialement vide) avec les carrés des angles de 0 à 2 radians, avec une incrémentation de 0,05
radian à chaque itération, en faisant appel à votre fonction sin2() pour le calcul. La variable
contenant l'angle s'appellera simplement angle.
Affichez la liste ainsi créée, corrigez le bug de sin2() concernant le retour du résultat si ce n'est
pas déjà fait, et indiquez la raison de ce bug en commentaire dans votre fichier script.
Note : Après le cour et cet exercice de TP, vous n'avez plus le droit de confondre la fonction
d'affichage print() et l'instruction return de retour de valeur d'une fonction.

5 Une boucle for x in range() serait pratique, mais range() ne fonctionne qu'avec des nombres entiers.

info - TP4 page 37

Convention pour les TP : toutes les fonctions auront une instruction return qui termine leur
exécution ; soit avec un résultat calculé (ex. return res), soit sans résultat (ex. return None).

Exercice 2 : Calcul de discriminant

Créez un script TP41_2.py (à rendre) avec l'en-tête standard, qui contient la définition d'une fonc­
tion discriminant() sous la forme :
def discriminant(p_a, p_b, p_c):
"""Calcul du discriminant pour ax²+bx+c=0"""
p_a = float(input("Valeur de a:"))
p_b = float(input("Valeur de b:"))
p_c = float(input("Valeur de c:"))
delta = p_b ** 2 - 4 * p_a * p_c
return delta
On s'attend à ce que cette fonction prenne ses trois paramètres, calcule la valeur du discriminant, et
retourne le résultat. Commencez par tester cette fonction en ajoutant à la suite de sa définition des
appels avec le code de test suivant :
print(discriminant(1, -3, 2), "==> discriminant 1")
print(discriminant(1, 2, 1), "==> discriminant 0")
print(discriminant(3, 4, 2), "==> discriminant -8")
Corrigez le bug de discriminant() qui rend cette fonction horripilante, et indiquez la raison de
ce bug en commentaire dans votre fichier script.
Note : Après le cour et cet exercice de TP, vous n'avez plus le droit de faire re-saisir un paramètre
donné à une fonction.
Mettez les trois lignes de test en commentaire, et ajoutez au script une fonction racines() qui
prenne trois paramètre et retourne les racines réelles de l'équation ax²+bx+c=0. S'il n'y a aucune
racine, la fonction retournera None, s'il y a une seule racine la fonction retournera la valeur flot­
tante correspondante, et s'il y a deux racines, la fonction retournera une liste contenant les deux
valeurs flottantes.
Rappel : dans le module math, la fonction sqrt() calcule la racine carrée (square-root).
Ajoutez trois lignes de tests pour les différents cas possibles, et vérifiez que la fonction est valide :
print(racines(1, -3, 2), "==> racines 1 et 2")
print(racines(1, 2, 1), "==> racine -1")
print(racines(3, 4, 2), "==> pas de racine")
Règle générale : sauf spécification dans le sujet d'un exercice6, une fonction ne demande rien à
l'utilisateur et ne fait aucun affichage.
4.1.2 - Traitements de listes
Exercice 3 : Calcul de maximum
Pour cet exercice, il est interdit d'utiliser les fonctions standard de Python max() et min() !
Créez un script TP41_3.py (à rendre) avec l'en-tête standard.
a) Définir dans ce script une fonction maximum() qui :
• prend trois nombres p_n1, p_n2, p_n3 en arguments
• retourne un entier maxi égal au plus grand de ces trois nombres.
Note : On utilisera l'algorithme qui était attendu pour le TP2_2, à savoir :

6 Dans le "cahier des charges" en termes professionnels.

info - TP4 page 38

1 - mémoriser le premier nombre dans la variable maxi,
2 - comparer le second nombre avec maxi et changer maxi si le second nombre est plus grand,
3 - comparer le troisième nombre avec maxi et changer maxi si le troisième nombre est plus grand.
4 - retourner maxi
Dans le programme principal, écrire un jeu d'essais pour cette fonction. C'est à dire : tester cette
fonction sur des entiers convenablement choisis, utiliser des valeurs simples pour faciliter les véri­
fications, coder directement ces valeurs "en dur" dans les tests (pour les tests on évite d'avoir à faire
de la saisie à chaque exécution).
b) On veut maintenant déterminer le maximum d'une série quelconque de nombres. Pour cela, défi ­
nissez la fonction maxiliste() qui :
• prend en argument une liste de nombres p_listeNombres,
• retourner le maximum de cette liste de nombres.
Note : Reprenez l'algorithme défini pour la fonction maximum() et généralisez-le pour qu'il traite
une liste dans une boucle.
Ajoutez au programme principal un jeu d'essais pour cette nouvelle fonction.
c) Écrire de même une fonction miniliste(p_listeNombres) qui devra retourner le minimum
d'un nombre quelconque de nombres.

Exercice 4 : Filtrage de mots selon un critère

On veut écrire un programme pour enlever d'une liste de mots donnée, tous les mots contenant une
certaine voyelle (par exemple le e).
Pour cela, créez un script TP41_4.py (à rendre) avec l'en-tête standard, contenant une fonction
laDisparition()qui :
• prend en arguments une liste de chaînes p_mots (où chaque élément contient un mot) et
une chaîne contenant une seule lettre p_disparue.
• retourne une liste resultat, qui contient seulement les mots de p_mots ne contenant pas
la lettre p_disparue.
Attention : La liste p_mots donnée en paramètre ne doit pas être modifiée par le traitement.
Dans le programme principal, écrire un jeu d'essais pour cette fonction laDisparition().
Note : pour tester la présence, on pourra utilisera la méthode find des chaînes ou encore l'opéra­
teur in. Voir la documentation en ligne et/ou faire des tests en mode interactif si vous avez des
doutes sur leur fonctionnement.

4.2 - Fonctions et effets de bord

4.2.1 - Modification de paramètre / accès globales
Exercice 5 : Fonction passe-bande
On a besoin d'une fonction de filtrage passe-bande pour des valeurs de fréquences vocales à trans ­
mettre par ligne téléphonique, qui limite ces valeurs entre un minimum et un maximum. Ces
limites sont toujours les mêmes, et la fonction de filtrage est utile en de nombreux endroits, on
préfère donc ne pas avoir à spécifier les limites à chaque fois.

info - TP4 page 39

Créez un script TP42_5.py (à rendre) avec l'en-tête standard, contenant une fonction
filtrage() qui prend en argument une liste de nombres p_valeurs, et ajuste les valeurs de
cette liste pour qu'elles soient comprises entre un minimum FILTRE_BAS et un maximum
FILTRE_HAUT définis comme variables globales du programme.
FILTRE_BAS = 300
FILTRE_HAUT = 3000
def filtrage(p_valeurs):
...
Le filtrage remplace toute valeur de la liste inférieure au minimum par le minimum, et toute valeur
supérieure au maximum par le maximum. Afin de ne pas dupliquer en mémoire la liste
p_valeurs, qui peut être volumineuse, on modifie directement les valeurs dans la liste. Et pour
que l'utilisateur ait conscience que la liste fournie est modifiée, la fonction ne retourne rien (en
Python elle retourne donc None).
Dans le programme principal, écrire un jeu d'essais pour cette fonction filtrage().
Note : la convention de nommage Python indique que les variables dont les noms sont tout en
majuscules sont considérées comme des constantes dont la valeur ne change pas au cour de
l'exécution du programme.
Bons usages : on évite autant que possible de modifier les paramètres d'une fonction, et si cela est
nécessaire on insiste alors beaucoup sur ce point dans la documentation.
4.2.2 - Modification de globale
Exercice 6 : Comptage d'erreurs
Dans le cadre d'un gros projet, on a besoin d'une fonction qui permette de lister une série de
problèmes identifiés et de les compter.
Créez un script TP42_6.py (à rendre) avec l'en-tête standard, contenant une fonction traceur()
qui prend en argument une chaîne p_message et ne retourne rien. Cette fonction affiche le
message donné en paramètre7 (là cela vous est explicitement demandé dans le sujet !), et incré­
mente un compteur contenu dans une variable globale g_traces.
Dans le programme principal, écrire un jeu d'essais avec diverses boucles et messages pour cette
fonction traceur(). Et faites afficher le compteur de traces à la fin, sa valeur devant être égale au
nombre de fois où la fonction traceur() a été appelée.
Note : On pourra éventuellement utiliser la fonction asctime() du module time pour récupérer
puis afficher la date et l'heure avant le message.
Bons usages : on évite autant que possible d'avoir à utiliser des globales, et on documente bien les
fonctions qui réalisent ces modifications

7 Généralement ce genre de fonction remplit un « fichier de logs » sur disque afin de permettre de
revenir sur les problèmes à posteriori. Les fichiers sont abordés dans un autre cours.

info - TP4 page 40

4.3 - Combinaison de fonctions

Exercice 7 : Diviseurs d'un nombre et décomposition en facteurs premiers

Rappels : tout nombre entier supérieur à 1 a au moins deux diviseurs : 1 et lui-même. Un nombre d
est un diviseur d'un nombre n si le reste de la division entière de n par d est nul. Un nombre
premier n'a que deux diviseurs. Le nombre 1 n'est pas premier.
a) Créez un script TP43_7.py (à rendre) avec l'en-tête standard, contenant une fonction divi­
seurs() qui prend en argument un nombre entier p_nombre et retourne la liste des diviseurs de
ce nombre.
Si le p_nombre est négatif ou nul, cette fonction lève une condition d'exception avec l'instruction 8 :
raise ValueError("Nombre négatif ou nul interdit")
Note : si vous l'avez fait, vous pouvez vous inspirer de l'exercice 10 du TP3.
Écrivez une seconde fonction nbDiviseurs(p_nombre) qui prend en argument un nombre
entier et retourne le nombre de diviseurs de ce nombre. Cette fonction devra bien sûr appeler la
fonction diviseurs().
Écrivez un jeu d'essais pour ces deux fonctions dans le programme principal.
b) On veut maintenant déterminer si un nombre est premier ou pas. Dans ce même programme,
écrivez une nouvelle fonction premier(p_nbr) qui prend en argument un nombre entier nommé
p_nbr, et retourne un booléen vrai si le nombre est premier, faux sinon. Si le nombre est négatif ou
nul, la fonction lève une condition d'exception comme indiqué précédemment.
Cette fonction devra appeler la fonction diviseurs() ou la fonction nbDiviseurs().
c) Écrivez une fonction facteursPremiers(p_nombre) qui prend en argument un nombre, et
qui retourne la décomposition en facteurs premiers de ce nombre sous forme d'une liste. Cette fonc­
tion devra appeler les fonctions précédentes. Si le nombre est égal à 1, la liste contiendra 1. Sinon
si le nombre est supérieur ou égal à 2, ne pas faire apparaître 1 dans la décomposition en facteurs
premiers. Si le nombre est négatif ou nul, la fonction lève une condition d'exception comme
indiqué précédemment.

4.4 - Fonctions prédéfinies du module random

Le module random contient des fonctions qui permettent de générer pseudo-aléatoirement des
nombres selon différentes lois de probabilité (uniforme discrète, uniforme continue, normale, etc).
Nous en aurons régulièrement besoin lors des TP suivants.
Dans un interpréteur python, taper les instructions suivantes et remplir le tableau ci-dessous - ceci
est nécessaire pour pouvoir faire l'exercice qui suit :

Tableau 1 : importer et utiliser les fonctions du module random

instruction à saisir résultat obtenu + commentaire ou explication
from random import random

random()

8 Une petite introduction au traitement des erreurs, qui sera abordé plus en détails ultérieurement.

info - TP4 page 41

random()

random()

random(4)

from random import randrange

randrange(3)
(répéter plusieurs fois cette instruction)

randrange(100,200)
(répéter plusieurs fois cette instruction)

randrange(0,1001,100)
(répéter plusieurs fois cette instruction)

help(random)

help(randrange)

uniform(2,3)

import random

random.uniform(2,3)
(répéter plusieurs fois cette instruction)

help(random)

help(random.uniform)

help(random.random)

help(random.randrange)

random()

random.random()

maListe=["alpha","bravo",
"charlie","delta","oscar",
"papa","romeo","tango",
"yankee","zulu"]
choice(maListe)

random.choice(maListe)
(répéter plusieurs fois cette instruction)

random.shuffle(maListe)

maListe

random.choice(range(10))
(répéter plusieurs fois cette instruction)

info - TP4 page 42

random.sample(maListe,3)
(répéter plusieurs fois cette instruction)

random.sample(range(10),2)
(répéter plusieurs fois cette instruction)

random.gauss(0,1)
(répéter plusieurs fois cette instruction)

Les principales fonctions du module random sont :

random() renvoie un nombre flottant aléatoire entre 0 et 1.
randrange(p,n,pas) renvoie un nombre entier aléatoire entre p inclus et n exclu, tous les
pas.
uniform(a,b) renvoie un nombre flottant aléatoire entre a et b.
choice(maListe) renvoie un élément choisi aléatoirement dans la liste maListe.
sample(maListe,k) renvoie un échantillon de k éléments choisis aléatoirement dans la liste
maListe. (cela fonctionne aussi avec un range).
shuffle(maListe) mélange aléatoirement les éléments de maListe (cette fonction modifie
la liste en la mélangeant).
triangular(a,b) renvoie un nombre flottant entre a et b choisi aléatoirement selon la loi
triangulaire.
gauss(m,) renvoie un nombre flottant choisi aléatoirement selon la loi normale de moyenne
m et d'écart-type .
seed() permet d'initialiser le générateur de nombres aléatoires 9 à partir de l'heure interne du
système d'exploitation de l'ordinateur ou de la valeur qu'on lui donne en paramètre.
On retrouve la documentation du module random sur http://docs.python.org/3.2/library/random

Exercice 8 : jeu du nombre à trouver

Créez un script TP44_8.py (à rendre) avec l'en-tête standard, pour réaliser le jeu suivant : le joueur
(qui est l'utilisateur) doit trouver, en moins de 10 essais, un nombre compris entre 1 (inclus) et 100
(inclus), généré aléatoirement par l'ordinateur.
On stockera ce nombre aléatoire dans une variable nommée g_alea (il sera généré au début d'une
partie et ne changera pas pendant tout la partie).
A chaque essai du joueur, on lui indique le numéro de son essai, le nombre d'essais restants, et si le
nombre qu'il a donné est plus grand ou plus petit que le nombre à trouver.

4.4.1 - Documentation des modules et des fonctions

Ouvrez et exécutez le programme TP4_ras qui contient les lignes suivantes :
#!/usr/bin/python3
# -*- encoding: utf-8 -*-
# Fichier:TP4_ras.py
"""Ce module permet de tester le système d'auto-documentation de Python.
9 Chaque nombre de ces séries pseudo-aléatoires résulte d'un calcul basé sur le nombre précédent, il
s'agit donc d'une suite définie par la première valeur. La fonction seed() permet de fixer cette valeur
initiale (donc éventuellement d'avoir des suites pseudo-aléatoires identiques pour faire des comparai­
sons d'algorithmes sur les mêmes données).

info - TP4 page 43

Il définit simplement deux fonctions, bien documentées.
"""

def fct_ras() :
"""Cette fonction se contente d'imprimer un message"""
print ("rien à signaler")
return None

def fct_rienadire():
"""cette fonction ne fait rien du tout"""
return None

if __name__ == '__main__' :
print("\n+++ Documentation de la fonction fct_ras:")
print(fct_ras.__doc__)
print("\n+++ Exemple d'appel à la fonction fct_ras:")
fct_ras()
Dans un interpréteur python, tapez les instructions suivantes :

Tableau 2 : afficher la documentation d'une fonction ou d'un module avec help()

instruction à saisir résultat obtenu + commentaire ou explication
import TP4_ras

help(TP4_ras)

help(TP4_ras.fct_ras)

from TP4_ras import fct_ras

help(fct_ras)

help(TP4_ras.fct_rienadire)

info - TP4 page 44