Fonctions.

• Transformer un bloc de code répété en fonction réutilisable.
• Distinguer print (afficher) et return (renvoyer).
• Comprendre pourquoi une variable créée dans une fonction n’existe pas dehors.
• Découper un problème en fonctions avant de coder.

print(), input(), len(), int(), range() sont des fonctions écrites par les créateurs de Python. Aujourd’hui vous écrivez les vôtres. Le mécanisme est identique.

def avancer(distance, vitesse=20): rend vitesse optionnel : avancer(100) utilise 20. Les paramètres avec défaut se placent après ceux sans défaut. C’est ainsi que print(x, end=" ") fonctionne : end a la valeur par défaut "\n".

print montre une valeur à l’humain. return donne une valeur au programme. Une fonction de calcul doit renvoyer ; l’affichage se décide ailleurs. Décommentez la dernière ligne : double_affiche(3) renvoie None, et None * 2 est une TypeError. Règle pratique : si vous écrivez print dans une fonction de calcul, demandez-vous si ce n’est pas return que vous vouliez.

On écrit return n % 2 == 0 et non if n % 2 == 0: return True else: return False : la comparaison est déjà un booléen. Les fonctions qui renvoient un booléen se nomment souvent est_… ou a_… : le if se lit alors comme une phrase.

Une fonction peut lire une variable définie hors d’elle (dite globale), par exemple une constante GRAVITE = 9.81. Mais elle ne peut pas la modifier par simple affectation : elle créerait une locale du même nom. Le mot-clé global l’autorise, mais son usage est presque toujours signe d’un mauvais découpage. Préférez passer des paramètres et renvoyer des résultats : la fonction devient prévisible et testable.

Imaginez un programme de 5000 lignes écrit par cinq personnes. Si chaque fonction pouvait modifier n’importe quelle variable, personne ne pourrait raisonner sur rien. L’isolation des fonctions est ce qui permet de construire des logiciels de la taille d’un système d’exploitation ou d’un robot autonome. En séance 06, une nuance importante : une fonction qui reçoit une liste peut en modifier le contenu.

La docstring (chaîne entre triples guillemets juste sous def) explique ce que fait la fonction ; help() l’affiche. Les assert vérifient des cas connus. Changez le 9 en 8 dans la formule : le premier test échoue immédiatement, avant que l’erreur ne se propage dans un programme de 1000 lignes. Les ingénieurs écrivent souvent les tests avant la fonction : ils savent alors précisément ce qu’ils doivent produire.

Chaque fonction fait une chose et son nom le dit. decider() ne lit pas de capteur et n’affiche rien : on peut la tester seule (assert decider(5) == "reculer"). Quand vous passerez au vrai robot, seules lire_capteur() et agir() changeront ; decider() restera identique. Cette séparation entre perception, décision et action est un principe de base en robotique. Le _ comme variable de boucle signale « je n’utilise pas cette valeur ».

def perimetre_rectangle(l, L):
    return 2 * (l + L)

def maximum3(a, b, c):
    m = a
    if b > m:
        m = b
    if c > m:
        m = c
    return m

def est_majuscule(lettre):
    return "A" <= lettre <= "Z"

assert perimetre_rectangle(2, 3) == 10
assert maximum3(3, 9, 5) == 9 and maximum3(3, 3, 3) == 3
assert est_majuscule("R") and not est_majuscule("r")
print("OK")

Les lettres se comparent par ordre alphabétique (en réalité par code Unicode, séance 07). pass est une instruction qui ne fait rien : utile pour laisser un bloc vide provisoirement.

def est_premier(n):
    if n < 2:
        return False
    for d in range(2, n):
        if n % d == 0:
            return False      # un diviseur trouvé : on sort tout de suite
    return True               # aucun diviseur : premier

for n in range(2, 100):
    if est_premier(n):
        print(n, end=" ")

Le return False dans la boucle joue le rôle d’un break : dès qu’on sait, on répond. Amélioration : il suffit de tester les diviseurs jusqu’à √n (si n = a × b, l’un des deux est ≤ √n). Écrivez range(2, int(n ** 0.5) + 1) et comparez le temps pour n = 10 000 019 avec time.perf_counter(). Ce sera l’objet de la séance 11.

def racine(a, precision=1e-10):
    x = a
    iterations = 0
    while abs(x * x - a) > precision:
        x = (x + a / x) / 2
        iterations += 1
    return x, iterations

for a in (2, 1000, 1_000_000):
    r, n = racine(a)
    print(f"√{a} ≈ {r:.10f} en {n} itérations (Python : {a ** 0.5:.10f})")

Même pour un million, une quinzaine d’itérations suffisent : la convergence est quadratique. Cette méthode est un cas particulier de la méthode de Newton, que vous verrez en prépa, et c’est (à peu près) ce que fait le processeur de votre PC quand il calcule une racine. Question ouverte : pourquoi partir de x = a et pas de x = 1 ? Essayez les deux. Et que se passe-t-il pour a = 0 ?