Fonctions et mini-calculatrice

Tes propres fonctions Python

Jusqu'ici, tu utilises des fonctions toutes faites : print, len, int, random.randint… Mais que faire quand tu veux calculer trois fois la même chose dans un programme — par exemple le périmètre de cinq rectangles ? Recopier le calcul cinq fois est une mauvaise idée : tu dupliques du code, tu risques d'oublier une copie quand tu modifies la formule. La solution s'appelle une fonction : tu écris la recette une seule fois, tu lui donnes un nom, et tu peux ensuite la rappeler autant de fois que tu veux.

À la fin de cette fiche, tu sauras définir une fonction avec def, lui passer des paramètres, récupérer une valeur avec return, distinguer une variable locale d'une variable globale, donner une valeur par défaut à un paramètre, et enfin assembler plusieurs fonctions pour construire une mini-calculatrice.

Définir et appeler une fonction

Une fonction se déclare avec le mot-clé def, suivi du nom de la fonction, de parenthèses, et de deux points. Le code de la fonction (son corps) est indenté de 4 espaces sous la ligne def.

Définir une fonction ne l'exécute pas : c'est seulement quand tu écris saluer() (avec les parenthèses) qu'elle se déclenche. Dans l'exemple, le message s'affiche deux fois parce qu'on appelle la fonction deux fois.

def bonjour():
    print('Salut le monde !')

bonjour()
bonjour()
bonjour()

def applaudir():
    for i in range(5):
        print('Bravo !')

applaudir()

def afficher_menu():
    print('1. Jouer')
    print('2. Options')
    print('3. Quitter')

afficher_menu()

Paramètres et arguments

Une fonction sans paramètre fait toujours la même chose. Pour qu'elle s'adapte, on lui donne des paramètres : des variables qu'elle reçoit au moment de l'appel.

Vocabulaire : prenom est un paramètre (vu côté définition), "Léa" est un argument (vu côté appel). Mais en pratique on emploie souvent les deux mots indifféremment.

def carre(n):
    print(n ** 2)

carre(9)

def annoncer_age(prenom, age):
    print(prenom, 'a', age, 'ans')

annoncer_age('Léa', 15)

def table(n):
    for i in range(1, 11):
        print(n, 'x', i, '=', n * i)

table(7)

La valeur de retour : `return`

Une fonction qui se contente d'afficher est utile, mais limitée : tu ne peux pas réutiliser le résultat. Une vraie fonction (au sens mathématique du terme) retourne une valeur avec le mot-clé return, et on récupère cette valeur dans une variable.

Quand Python rencontre return, il quitte immédiatement la fonction et renvoie la valeur. Tout ce qui suit n'est pas exécuté.

Une fonction sans return (comme print ou notre saluer de tout à l'heure) renvoie en réalité une valeur spéciale : None, qui veut dire « rien ».

def double(n):
    return 2 * n

x = double(21)
print(x)

def est_pair(n):
    return n % 2 == 0

print(est_pair(10))
print(est_pair(7))

def maximum(a, b):
    if a > b:
        return a
    return b

print(maximum(7, 3))
print(maximum(2, 9))
print(maximum(5, 5))

Plusieurs paramètres et valeurs par défaut

Une fonction peut prendre autant de paramètres que tu veux. Tu peux aussi donner une valeur par défaut à un paramètre : si l'appel ne fournit pas l'argument, c'est cette valeur qui sert.

Les paramètres avec valeur par défaut doivent figurer à la fin de la liste des paramètres, jamais avant les paramètres obligatoires.

def puissance(base, exposant=2):
    return base ** exposant

print(puissance(5))
print(puissance(2, 10))

def moyenne3(a, b, c):
    return (a + b + c) / 3

print(moyenne3(12, 14, 16))

def prix_ttc(ht, tva=20):
    return round(ht * (1 + tva / 100), 2)

print(prix_ttc(50))
print(prix_ttc(50, 5.5))
print(prix_ttc(99.99, 10))

Variables locales et globales

Une variable créée à l'intérieur d'une fonction n'existe que pendant l'exécution de cette fonction : on dit qu'elle est locale. Dès que la fonction se termine, elle disparaît — comme un brouillon qu'on jette.

Lance la cellule : tu obtiens une NameError sur la dernière ligne, parce que secret n'existe pas en dehors de calcul. C'est une bonne nouvelle : chaque fonction a son espace de travail isolé, elle ne risque pas de modifier par accident une variable d'un autre endroit du programme.

À l'inverse, une variable définie hors de toute fonction est globale : la fonction peut la lire sans formalité.

Mais modifier une variable globale depuis une fonction est plus subtil : par défaut, Python crée une nouvelle variable locale du même nom, et la globale reste intacte. Pour vraiment la modifier, il faut le déclarer explicitement avec global (rarement utile dans la vraie vie — préférer return).

def incrementer(c):
    return c + 1

compteur = 0
compteur = incrementer(compteur)
compteur = incrementer(compteur)
print(compteur)

TVA = 20

def ajouter_tva(ht):
    return ht * (1 + TVA / 100)

print(ajouter_tva(100))

def nombre_voyelles(texte):
    compteur = 0
    for lettre in texte.lower():
        if lettre in 'aeiouy':
            compteur = compteur + 1
    return compteur

print(nombre_voyelles('Bonjour'))
print(nombre_voyelles('Mathematiques'))

Composer : une mini-calculatrice

Le vrai pouvoir des fonctions, c'est qu'on peut les combiner : une fonction en appelle une autre, et on construit ainsi un programme structuré et lisible. Voici une petite calculatrice qui découpe le travail en quatre fonctions élémentaires plus une fonction « chef d'orchestre ».

Chaque fonction fait une seule chose et la fait bien. Si tu dois corriger la division (par exemple ajouter un arrondi), tu n'as qu'un endroit à modifier. C'est l'idée fondamentale du découpage en programmation.

def puissance(a, b):
    return a ** b

def calcule(a, op, b):
    if op == '+':
        return a + b
    if op == '-':
        return a - b
    if op == '^':
        return puissance(a, b)
    return 'Opération inconnue'

print(calcule(2, '^', 10))
print(calcule(7, '+', 5))

def multiplication(a, b):
    return a * b

def division(a, b):
    return a / b

def aire_triangle_rectangle(c1, c2):
    return division(multiplication(c1, c2), 2)

print(aire_triangle_rectangle(6, 4))

formules = {
    'carre': lambda c: c * c,
    'rectangle': lambda L, l: L * l,
    'disque': lambda r: 3.14159 * r * r,
}

def aire(forme, *args):
    return formules[forme](*args)

print(aire('carre', 5))
print(aire('rectangle', 12, 7))
print(aire('disque', 4))