graphes-l3/programmation/chapitre_4/TD.ipynb

TD - Les fonctions

1. Exemple introductif

La mention au bac se calcule en fonction de la moyenne selon les critères suivants :

Moyenne	Mention
Inférieur à 10 (exclu)	Aucune
De 10 à 12 (exclu)	Passable
De 12 à 14 (exclu)	Assez bien
De 14 à 16 (exclu)	Bien
De 16 à +	Très Bien

Imaginons que l'on souhaite connaitre la mention pour 2 élèves, il est possible d'écrire et d'exécuter les instructions suivantes :

moyenne = 13.5 # moyenne de l'élève 1
if moyenne < 10:
    mention = "Aucune"
elif moyenne < 12:
    mention = "Passable"
elif moyenne < 14:
    mention = "Assez Bien"
elif moyenne < 16:
    mention = "Bien"
else:
    mention = "Très Bien"
print("la mention pour l'élève 1 est : ", mention)
moyenne = 10.75 # moyenne de l'élève 2
if moyenne < 10:
    mention = "Aucune"
elif moyenne < 12:
    mention = "Passable"
elif moyenne < 14:
    mention = "Assez Bien"
elif moyenne < 16:
    mention = "Bien"
else:
    mention = "Très Bien"
print("la mention pour l'élève 2 est : ", mention)

On constate que l'on doit répéter le bloc d'instructions conditionnelles.

Y a-t-il un moyen de factoriser ce bloc d'instuctions ?

2. Solution : les fonctions

Utilisons la syntaxe suivante :

In [2]:

def obtenir_mention(moyenne):
    if moyenne < 10:
        mention = "Aucune"
    elif moyenne < 12:
        mention = "Passable"
    elif moyenne < 14:
        mention = "Assez Bien"
    elif moyenne < 16:
        mention = "Bien"
    else:
        mention = "Très Bien"
    return mention
    
print("la mention pour l'élève 1 est : ", obtenir_mention(13.5))
print("la mention pour l'élève 2 est : ", obtenir_mention(10.75))

la mention pour l'élève 1 est :  Assez Bien
la mention pour l'élève 2 est :  Passable

\Rightarrow Le bloc calculant la mention est défini une et une seule fois !!

2. Déclaration d'une fonction

Dans un langage de programmation, on utilise ce qu'on appelle des fonctions. Une fonction est un ensemble d'instructions qui peut recevoir des arguments et qui peut renvoyer un résultat qui est souvent le contenu d'une ou plusieurs variables.

En Python, on définit une fonction en utilisant l'instruction def (de l'anglais define, qui veut dire "définir") :

def nom_de_la_fonction(parametre1, parametre2, ..., parametreN):
    corps_de_la_fonction

• l'instruction def est suivie du nom de la fonction ;
• les paramètres de la fonction sont ensuite écrits entre parenthèses et séparés par des virgules ;
• il existe des fonctions sans paramètre, les parenthèses sont néanmoins obligatoires et restent vides ;
• il ne faut pas oublier les deux points après les parenthèses de la première ligne ;
• le corps de la fonction est un bloc d'instructions qui contient toutes les lignes qui doivent être exécutées lorsque la fonction est appelée. Le corps de la fonction doit nécessairement être indenté, c'est-à-dire qu'il doit être décalé d'une tabulation par rapport à l'instruction def.

Très souvent, le corps de la fonction se terminera par l'instruction return suivie de la ou des valeurs que la fonction doit renvoyer. Si la fonction doit renvoyer plusieurs valeurs, celles-ci sont à séparer par des virgules.

Ainsi, le schéma général d'une fonction Python est :

def nom_de_la_fonction(parametre1, parametre2, ..., parametreN):
    instructions                            # sur plusieurs lignes éventuellement
    return valeur1, valeur2, valeur3, etc.  # souvent une fonction ne renvoie qu'une valeur

Exemple : Voici la fonction inverse implantée en Python

def inverse(x):
    y = 1 / x
    return y

que l'on peut aussi écrire plus simplement :

def inverse(x):
    return 1 / y

Identifiez dans ces deux fonctions écrites différemment : leur nom, leur(s) paramètre(s), leur corps, leur(s) valeur(s) renvoyée(s).

Remarque : il existe des fonctions qui ne renvoient aucune valeur, l'instruction return n'est donc pas utilisée dans le corps de ces fonctions.

3. Appel à une fonction

Lorsque l'on exécute le code qui définit une fonction, aucune valeur n'est renvoyée ! Cela a seulement pour objectif d'enregistrer la fonction en mémoire.

In [3]:

# à exécuter : il ne se passera rien (visuellement)
def inverse(x):
    return 1 / x

Pour utiliser une fonction il faut l'appeler. On appelle une fonction par son nom en donnant des arguments (des valeurs) à ses paramètres. Dans ce cas, la fonction va renvoyer la ou les valeurs attendues.

In [4]:

# appel à la fonction : qui renvoie alors ce qu'il faut !

inverse(2)

Out [4]:

0.5

In [5]:

# un autre appel à la fonction : qui renvoie alors ce qu'il faut !

inverse(10)

Out [5]:

0.1

• Une fonction est définie une et une seule fois,
• À chaque appel, la fonction calcule et produit un résultat dépendant des valeurs des paramètres passés,
• Pour un même ensemble de valeurs de paramètres, le résultat produit est toujours le même. On dit qu'une fonction est déterministe (ou pure).

Remarque : au premier return rencontré l'exécution de la fonction est stoppée : si on veut renvoyer plusieurs valeurs on ne peut pas utiliser plusieurs return ; il faut séparer les valeurs à renvoyer par des virgules.

À Faire

1. Écrire une fonction obtenir_mention qui prend en paramètre une note, sous la forme d'un flottant et renvoie une mention, sous la forme d'une chaine de caractères.
2. Quelles instructions permettent d'appeller la fonction pour les moyennes des 2 élèves de l'exemple introductif ?

In [ ]:

4. Prototyper une fonction

Pour expliquer le fonctionnement d'une fonction, on lui ajoute un prototype juste sous la ligne de définition. En Python les prototypes sont appelés docstrings. On peut y accéder dans le code source ou simplement en utilisant la fonction help().

Le prototype doit décrire le rôle de la fonction, le type des paramètres, type de la valeur de retour et les conditions d'utilisation.

In [1]:

def inverse(x):
    '''
    Calcule l'inverse de x
    :param x: (int) un entier
    :return: l'inverse de x
    '''
    return 1 / x

Que se passe-t-il pour x = 0 ?

Il faut a minima que le prototype contienne les cas d'utilisation et les pré-conditions sur les paramètres.

In [2]:

def inverse(x):
    '''
    Calcule l'inverse de x
    :param x: (int) un entier
    :return: l'inverse de x
    :C.U: x != 0
    '''
    return 1 / x

In [3]:

help(inverse)

Help on function inverse in module __main__:

inverse(x)
    Calcule l'inverse de x
    :param x: (int) un entier
    :return: l'inverse de x
    :C.U: x != 0

N.B : Toute fonction doit comporter un prototype clair et explicite car la fonction peut être utilisée par une personne qui ne l'a pas programmé et doit savoir ce qu'elle fournit comme service sans devoir lire et comprendre son code.

6. Valeur de paramètre par défaut

7. Portée des variables

Les variables définies dans les fonctions, ses paramètres ou autres, sont appelés des variables locales, par opposition aux variables globales, qui sont définies dans flot d'exécution du programme.

In [4]:

# Je défini une variable globale x
x = 3
# Je défini une fonction avec comme paramètre x
def double(x):
  # Il s'agit d'une nouvelle variable locale x non liée à la variable globale x
  return 2 * x

# J'appelle la fonction double avec x = 2
double(2)

print(x)

3

La variable globale x reste inchangée

7.1. Mauvaise pratique

In [19]:

# Je défini une variable globale x
x = 3
# Je défini une fonction sans paramètre
def double():
  # Je modifie la variable globale x
    global x
    x = 2 * x

# J'appelle la fonction double, x = 3 à ce stade
double()

print(x)

6

La fonction double ne prend aucun paramètre mais utilise une variable globale, ce qui est une mauvaise pratique car potentiellement source d'erreurs.

In [20]:

double()
print(x)

12

In [21]:

double()
print(x)

24

N.B : Le résultat calculé et obtenu par une fonction doit dépendre et manipuler uniquement des paramètres et variables locales définis.

Exercices

• calcule le min de 2 valeurs passées en paramètre

• calcule le nombre de voyelles d'une chaine

• calcule le pgcd de 2 entiers

• remplace les voyelles par des nombres

• Convertir de Farenheit à Celsius et inversement

• calculer le discriminant

• vérification du format d'une plaque d'immatriculation

• tortue qui trace des formes géomatriques

• différence print / return

Exercice X

L'énergie cinétique d'un objet de masse m se déplaçant à la vitesse v est:

Ec = \frac{1}{2} m v^{2}

Créer une fonction energie_cinetique qui calcule sa valeur à partir des paramètres masse et vitesse.

Exercice X

Construire une fonction, utilisant le module random, qui tire au sort un nombre entier entre deux bornes données en arguments.

Exercice X

Écrire une fonction pour calculer la factorielle d'un nombre (un entier non négatif). La fonction accepte le nombre en tant qu'argument.

Exemple: factorielle de 5: 5! = 5x4x3x2x1 = 120

Exercice X

Écrire une fonction Python qui prend un nombre en paramètre et vérifiez si le nombre est premier ou non.

Remarque: Un nombre premier est un nombre naturel supérieur à 1 et qui n'a pas de diviseur positif autre que 1 et lui-même.

In [ ]: