Les fonctions Python

Une fonction est un bloc de code nommé qui accomplit une tâche. Les fonctions natives comme print() et input() te fournissent déjà des tâches utiles à appeler ; def te permet de créer les tiennes. Un bon nom transforme plusieurs lignes de travail en un appel qui indique ce que tu veux faire.

Écrire l’en-tête et le corps

def greet():
    print("Hello!")
    print("Welcome to Python.")

greet()
greet()

L’en-tête commence par def, puis viennent le nom, les parenthèses et les deux-points. Les lignes indentées forment le corps. Utilise quatre espaces pour chaque niveau d’indentation. Les lignes greet() non indentées sont hors de la fonction : ce sont donc des appels dans le programme principal.

Lorsque Python atteint la définition, il crée la fonction et lui donne le nom greet. Il n’affiche encore aucun des deux messages. Le premier appel commence à la première ligne du corps et affiche « Hello! » suivi de « Welcome to Python. ». Le second appel reprend le corps et affiche les deux mêmes lignes. Il y a quatre lignes de sortie en tout.

Un nom et un appel sont différents

Les parenthèses dans greet() en font un appel, même si cette fonction n’a besoin d’aucune entrée. Une ligne contenant seulement greet désigne la fonction et n’exécute rien. print(greet) affiche une description de l’objet fonction, avec une adresse mémoire ; il n’exécute pas le message de bienvenue.

Python doit avoir exécuté une définition avant qu’un appel utilise son nom. Si un fichier commence par greet() et définit greet ensuite, la première ligne déclenche NameError: name 'greet' is not defined. Place la définition avant l’appel au premier niveau du fichier.

Choisir des noms qui expliquent la tâche

Utilise des mots en minuscules reliés par des traits de soulignement, comme print_receipt ou convert_to_miles. Les noms peuvent contenir des lettres, des chiffres et des traits de soulignement, mais ne peuvent pas commencer par un chiffre ni être un mot réservé comme return. Les noms sont sensibles à la casse : greet et Greet sont des noms différents.

Garde les noms natifs disponibles. Après input = "yes", le nom input désigne du texte : input("Name? ") déclenche donc TypeError: 'str' object is not callable. Nommer la variable answer permet de garder la fonction native accessible.

Corriger d’abord la structure

L’absence des deux-points dans l’en-tête produit SyntaxError: expected ':'. Un corps vide ou non indenté produit une IndentationError. Une fonction en cours de conception a tout de même besoin d’une instruction ; pass est une instruction provisoire qui ne fait rien :

def print_receipt():
    pass

print_receipt()

Ce programme s’exécute sans rien afficher. L’appel atteint pass puis la fin du corps. Remplace l’instruction provisoire par la tâche réelle lorsque tu es prêt à l’implémenter. Si une ligne devait appartenir au corps mais s’exécute au mauvais moment, vérifie son indentation avant de modifier l’appel.

Un programme avec des fonctions n’exécute pas chaque corps dans l’ordre où il apparaît sur la page. Un appel modifie le flot d’exécution : Python entre dans la fonction appelée, termine son travail, puis reprend l’exécution dans l’appelant juste après cet appel.

Suivre un appel dans un autre appel

def line():
    print("----------")

def banner():
    line()
    print("  REPORT")
    line()

print("Start")
banner()
print("End")

Python définit d’abord line et banner. Aucun des deux corps ne s’exécute. L’instruction suivante affiche « Start ». L’appel à banner() entre dans son corps, dont la première instruction appelle line().

Python entre alors dans line, affiche « ---------- » et atteint sa fin. Il revient à l’instruction suivante dans banner, qui affiche « REPORT ». Le second appel à line() affiche une autre ligne de tirets. Enfin, banner se termine : le programme principal reprend et affiche « End ».

La sortie est :

Start
----------
  REPORT
----------
End

Suivre les appels non terminés

Pendant que line s’exécute, banner attend qu’elle se termine. Le programme principal attend lui aussi banner. Python enregistre ces appels non terminés dans la pile d’appels. L’appel actif le plus interne se termine en premier, et chaque appelant reprend à son instruction suivante.

Pour suivre l’exécution sur papier, numérote les lignes du programme. Ne note une ligne du corps que lorsque l’exécution l’atteint par un appel. À chaque appel, indique où reprendre. Écris la sortie lorsque son print s’exécute, en conservant les espaces et les sauts de ligne. Cela distingue le parcours dans le code de la sortie produite.

Définir les fonctions auxiliaires avant qu’elles soient nécessaires

La définition d’une fonction auxiliaire peut apparaître sous celle de l’appelant :

def show_report():
    draw_line()
    print("Ready")

def draw_line():
    print("====")

show_report()

Cela fonctionne parce que les deux définitions ont été exécutées avant que l’appel final entre dans show_report. Python cherche draw_line lorsque le corps l’appelle effectivement. Déplacer show_report() au-dessus de def draw_line(): ferait échouer l’appel lorsqu’il essaierait d’utiliser la fonction auxiliaire manquante.

Les appels répétés repartent du début

Un appel dans une boucle entre dans le corps à chaque répétition :

for i in range(3):
    line()

Avec la première définition de line, cela affiche la ligne de tirets trois fois. La fonction commence à la première instruction de son corps à chaque appel.

Si un appel échoue, Python affiche une trace d’appels. Sa dernière ligne donne le type et le message de l’erreur. Les entrées d’appel qui la précèdent vont de l’appel non terminé le plus externe jusqu’à la ligne qui a échoué. Lire d’abord la dernière erreur, puis vérifier la ligne la plus interne et son appelant, aide à repérer l’opération qui a échoué et le chemin par lequel ses données lui sont parvenues.

Une fonction devient réutilisable avec différentes entrées lorsque son en-tête nomme les valeurs dont elle a besoin. Ces noms sont des paramètres. L’appelant fournit des arguments, qui sont les valeurs effectivement utilisées pour un appel donné.

Associer les valeurs aux noms

def rectangle_area(width, height):
    print("Area:", width * height)

rectangle_area(4, 2.5)
rectangle_area(3, 7)

Les paramètres sont width et height. Dans le premier appel, les arguments sont 4 et 2.5. Les arguments positionnels sont associés de gauche à droite : width reçoit 4 et height reçoit 2,5. Le corps affiche « Area: 10.0 ». L’appel suivant donne de nouvelles valeurs aux mêmes noms de paramètres et affiche « Area: 21 ».

Chaque paramètre joue le rôle d’une variable pendant cet appel. Tu n’as pas besoin d’affecter des valeurs à width et height au préalable ; l’appel les fournit. Une fonction sans paramètres a quand même besoin de parenthèses vides dans sa définition et dans ses appels.

L’ordre peut changer le sens

def describe_pet(animal, name):
    print(name, "is a", animal)

describe_pet("cat", "Milo")
describe_pet("Milo", "cat")

Le premier appel affiche « Milo is a cat ». Le second affiche « cat is a Milo ». Les deux appels sont valides en Python : aucune erreur ne signale donc l’inversion du sens. Lis l’ordre de l’en-tête avant de choisir les arguments positionnels, surtout lorsque plusieurs paramètres acceptent le même type de valeur.

Les arguments peuvent être des expressions

Python évalue chaque expression utilisée comme argument avant que le corps commence. Avec side = 6, l’appel rectangle_area(side, side) transmet deux fois 6 et affiche « Area: 36 ». Le nom de la variable de l’appelant n’a besoin de correspondre à aucun des deux noms de paramètres. L’appel rectangle_area(side + 1, 2) transmet 7 et 2 ; il ne transmet pas le texte « side + 1 ».

Lire une erreur de nombre d’arguments

Chaque paramètre sans valeur par défaut a besoin d’un argument. Avec la fonction d’aire ci-dessus :

Le premier déclenche TypeError: rectangle_area() missing 1 required positional argument: 'height'. Le second déclenche TypeError: rectangle_area() takes 2 positional arguments but 3 were given. Vérifie l’en-tête de la fonction indiquée, puis compte comment l’appel renseigne ses paramètres.

Transmettre le type de valeur nécessaire à la tâche

Python n’impose pas un type simplement parce qu’un paramètre s’appelle width. rectangle_area("4", 2) affiche « Area: 44 », car multiplier du texte par un entier répète ce texte. Comme input() renvoie du texte, convertis une saisie numérique avant de la transmettre :

width = float(input("Width: "))
rectangle_area(width, 2)

Ici, float() transforme le texte saisi en nombre avant que la fonction d’aire le reçoive.

Un argument nommé indique dans l’appel le paramètre auquel il est destiné. Cela rend l’appel plus facile à lire lorsque plusieurs valeurs pourraient être confondues. Python associe le nom indiqué à celui de l’en-tête au lieu d’utiliser sa position.

Associer par nom

def describe_pet(animal, name):
    print(name, "is a", animal)

describe_pet(name="Milo", animal="cat")
describe_pet(animal="cat", name="Milo")

Les deux appels affichent « Milo is a cat ». L’ordre des arguments nommés peut changer, car chaque valeur indique le paramètre qu’elle renseigne. La même idée rend rectangle_area(width=4, height=2.5) lisible sans vérifier quelle dimension vient en premier.

Un nom indiqué dans un argument nommé n’est pas une nouvelle variable dans le code appelant. Dans describe_pet(name="Milo", animal="cat"), name= dirige « Milo » vers le paramètre. Il n’affecte pas « Milo » à une variable appelée name au premier niveau du fichier. Écris les arguments nommés sans espaces autour de =, conformément au style habituel de Python.

Combiner des arguments positionnels et nommés

describe_pet("cat", name="Milo")

Le premier argument renseigne animal par sa position. L’argument nommé renseigne name : chaque paramètre reçoit donc exactement une valeur. Les arguments positionnels doivent venir en premier. L’appel describe_pet(name="Milo", "cat") est rejeté avec SyntaxError: positional argument follows keyword argument.

Pour examiner un appel mixte, renseigne les emplacements positionnels de gauche à droite, puis associe les arguments nommés. Vérifie qu’aucun emplacement n’est renseigné deux fois et qu’aucun emplacement obligatoire ne reste vide.

Corriger les noms en double ou inconnus

Le doublon déclenche TypeError: describe_pet() got multiple values for argument 'animal'. La faute de frappe déclenche TypeError: describe_pet() got an unexpected keyword argument 'nmae'. Compare les noms caractère par caractère ; les majuscules et les minuscules comptent aussi. Changer l’ordre des arguments ne corrige pas une double affectation à un même paramètre.

Reconnaître les arguments nommés dans les fonctions natives

print("a", "b", "c", sep="-")
print("Loading", end="...")
print("done")

La première ligne affiche « a-b-c ». sep fournit le texte entre les valeurs affichées. Les deux appels suivants produisent « Loading...done » sur une seule ligne : end remplace le saut de ligne habituel après « Loading ».

Certaines fonctions natives acceptent aussi des arguments nommés ; par exemple, round(3.14159, ndigits=2) donne 3,14. Utilise les noms de paramètres documentés pour la fonction que tu appelles. Un mot descriptif que tu inventes n’est pas reconnu simplement parce qu’il semble convenir à la tâche.

Une valeur par défaut permet à un appel d’omettre un argument lorsqu’un choix courant convient. Écris la valeur par défaut à côté de son paramètre dans l’en-tête. Fournir un argument remplace la valeur par défaut pour cet appel.

Rendre un paramètre facultatif

def greet(name, greeting="Hello"):
    print(greeting + ",", name + "!")

greet("Ana")
greet("Ana", "Welcome")
greet("Ana", greeting="Hi")

La sortie est « Hello, Ana! », « Welcome, Ana! » et « Hi, Ana! ». name est obligatoire car il n’a pas de valeur par défaut. greet() déclenche donc une TypeError, même si l’autre paramètre est facultatif.

Dans ces en-têtes, les paramètres obligatoires précèdent les paramètres avec valeurs par défaut. def greet(greeting="Hello", name): est invalide. Python signale une erreur de syntaxe parce qu’un paramètre sans valeur par défaut suit un paramètre qui en a une. Déplace name avant greeting pour qu’il reste obligatoire.

Modifier un choix facultatif

def order_coffee(size, shots=1, milk="none"):
    print(size, "coffee,", shots, "shot(s), milk:", milk)

order_coffee("large", milk="oat")

Cet appel affiche « large coffee, 1 shot(s), milk: oat ». L’argument nommé atteint milk, tandis que shots garde 1. Un appel positionnel order_coffee("medium", 2) modifie shots et laisse milk à « none ». L’association positionnelle ne saute pas un paramètre facultatif pour atteindre le suivant.

Les fonctions natives proposent aussi des valeurs par défaut : un print() ordinaire sépare les valeurs par une espace et termine par un saut de ligne. round(3.7) donne l’entier 4 ; round(3.14159, 2) demande deux décimales et donne 3,14.

Les valeurs par défaut sont créées lors de l’exécution de la définition

rate = 0.05

def price_with_tax(price, tax_rate=rate):
    return price * (1 + tax_rate)

rate = 0.08
print(price_with_tax(100))
print(price_with_tax(100, rate))

La valeur par défaut stocke la valeur 0,05 lorsque def s’exécute. Modifier rate ensuite ne change pas cette valeur par défaut stockée. Les appels affichent « 105.0 » et « 108.0 » : seul le second fournit explicitement le nouveau taux.

Éviter de partager une liste par accident

Une liste contient des éléments, et append ajoute un élément à cette même liste. Avec une liste comme valeur par défaut, les appels qui omettent l’argument la partagent tous :

def add_item(item, basket=[]):
    basket.append(item)
    print(basket)

add_item("apple")
add_item("pear")

Cela affiche ['apple'] puis ['apple', 'pear']. La liste par défaut a été créée une seule fois, et non une fois par appel. Pour créer une nouvelle liste chaque fois que l’argument est omis, utilise None comme signal :

def add_item(item, basket=None):
    if basket is None:
        basket = []
    basket.append(item)
    print(basket)

Ces deux appels affichent maintenant ['apple'] et ['pear']. Une liste fournie explicitement est toujours utilisée telle quelle. Décris les paramètres facultatifs et leurs valeurs par défaut dans la docstring afin que les appelants sachent quelles valeurs sont choisies en cas d’omission.

Une fonction peut fournir à l’appelant un résultat à utiliser. L’instruction return termine l’appel et renvoie sa valeur. Au point d’appel, l’appel représente cette valeur renvoyée.

Stocker et combiner des résultats

def rectangle_area(width, height):
    return width * height

area = rectangle_area(4, 2.5)
print(area)
print(rectangle_area(3, 4) + rectangle_area(2, 5))

Le premier appel renvoie 10,0, qui est affecté à area ; le premier print l’affiche. Dans la dernière ligne, les deux appels renvoient 12 et 10. Python additionne ces résultats et affiche « 22 ». La fonction elle-même ne contient pas de print : elle peut donc fournir un résultat à stocker ou une partie d’un calcul plus large.

Une valeur renvoyée peut aussi être testée dans une condition ou transmise à une autre fonction. Cela distingue la tâche de calcul de la décision de l’appelant sur la façon d’utiliser la réponse.

Afficher et renvoyer ont des rôles différents

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

result = double_print(5)
print(result)

L’appel affiche « 10 », mais ce nombre affiché n’est pas renvoyé comme résultat. double_print atteint la fin de son corps et renvoie donc None. La dernière ligne affiche par conséquent « None ».

double_print(5) + 1 affiche d’abord « 10 », puis déclenche TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'. Remplace le corps par return n * 2 lorsque l’appelant a besoin du nombre doublé. Une fonction destinée uniquement à produire un effet, comme afficher un message, peut tout à fait renvoyer None ; on appelle parfois ces fonctions des procédures. Une fonction qui renvoie un résultat utile est parfois appelée fonction avec valeur de retour.

S’arrêter au premier return exécuté

def to_fahrenheit(celsius):
    return celsius * 9 / 5 + 32
    print("Converted")

print(to_fahrenheit(20))

Cela affiche « 68.0 ». Le print dans le corps n’est jamais atteint, car return a déjà terminé l’appel. Supprime cette instruction inaccessible ou déplace une action nécessaire avant le return. La conversion renvoie des flottants car / produit un flottant. Les entrées 100 et -40 donnent 212,0 et -40,0.

Un return seul, sans expression, termine aussi un appel en renvoyant None. Chaque appel de fonction a un résultat, même lorsqu’aucune valeur utile n’a été fournie.

Rendre les résultats visibles dans un fichier programme

Dans un fichier, un rectangle_area(3, 4) placé seul calcule 12 puis abandonne le résultat inutilisé. Utilise print(rectangle_area(3, 4)) pour l’afficher ou affecte-le à une variable. La console interactive affiche les résultats des expressions sauf None : un essai réussi dans la console peut donc sembler différent de l’exécution de la même ligne dans un fichier.

Des entrées différentes peuvent nécessiter des réponses différentes. Une fonction peut avoir plusieurs instructions return, mais un appel s’arrête à la première qu’il exécute. Suis le chemin réellement emprunté dans ses branches et ses boucles pour trouver le résultat.

Ordonner les tests qui se recoupent

def letter_grade(score):
    if score >= 90:
        return "A"
    if score >= 80:
        return "B"
    if score >= 70:
        return "C"
    return "F"

Pour 85, le premier test est faux et le deuxième est vrai. La fonction renvoie « B » sans tester les conditions restantes. Pour 42, les trois tests sont faux : le return final fournit donc « F ». Des instructions if distinctes fonctionnent parce que chaque branche dont le test est vrai termine l’appel.

Le seuil le plus élevé doit ici être vérifié en premier. Si score >= 70 venait en premier, un score de 95 renverrait « C ». Lorsque des intervalles se recoupent, une condition large placée tôt peut masquer une réponse ultérieure plus précise.

Couvrir le chemin sans branche correspondante

def sign(n):
    if n > 0:
        return "positive"
    elif n < 0:
        return "negative"
    return "zero"

La dernière ligne traite zéro. Sans elle, sign(0) atteindrait la fin et renverrait None. Suis une entrée pour chaque branche et pour tout cas restant ; tester seulement des entrées positives et négatives laisserait passer cet oubli.

Renvoyer une comparaison booléenne

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

if is_even(10):
    print("Even")

La comparaison produit déjà True ou False. is_even(10) renvoie True, tandis que is_even(7) renvoie False. Utilise directement le résultat dans une condition. Un == True supplémentaire n’apporte rien au test.

Terminer une recherche avant de conclure à l’absence de correspondance

def smallest_divisor(n):
    for d in range(2, n):
        if n % d == 0:
            return d
    return n

Pour 91, les diviseurs possibles de 2 à 6 échouent, puis 7 le divise sans reste. Renvoyer 7 termine à la fois la boucle et la fonction. Pour 13, la boucle ne trouve aucun diviseur : le return final donne donc 13.

Un test de primalité doit permettre à la recherche de continuer après l’échec d’un diviseur possible :

def is_prime(n):
    if n < 2:
        return False
    for d in range(2, n):
        if n % d == 0:
            return False
    return True

Le True final est hors de la boucle. Le placer dans un else à l’intérieur de la boucle provoquerait un retour après la vérification du premier diviseur possible seulement : 9 serait accepté à tort parce qu’il n’est pas divisible par 2. Avec la fonction corrigée, 9 et 1 donnent False ; 2, 7 et 97 donnent True. Pour 2, la boucle n’a aucun diviseur à essayer et l’exécution atteint le True final.

Renvoyer deux valeurs

def share(total, people):
    return total // people, total % people

each, left = share(17, 5)
print(each, left)

L’appel renvoie un tuple, un résultat regroupé contenant 3 et 2. L’affectation le dépaquette en deux noms : la sortie est donc « 3 2 ». Afficher directement l’appel montrerait « (3, 2) ». Le nombre de noms doit correspondre au nombre de valeurs dépaquetées.

Combiner les appels de l’intérieur vers l’extérieur

def add(a, b):
    return a + b

def to_fahrenheit(celsius):
    return celsius * 9 / 5 + 32

print(to_fahrenheit(add(10, 15)))

add renvoie d’abord 25. Cette valeur devient l’argument de to_fahrenheit, qui renvoie 77,0. Enfin, print affiche « 77.0 ». Chaque appel interne doit renvoyer la valeur dont la fonction suivante a besoin.

La portée indique où un nom peut être utilisé. Les paramètres et les noms auxquels une valeur est affectée dans une fonction sont locaux à l’appel de cette fonction. Un appelant et une fonction peuvent utiliser des noms similaires sans partager les mêmes variables locales.

Garder les noms locaux dans leur appel

def make_greeting():
    message = "Hi"
    print(message)

make_greeting()

Cela affiche « Hi ». Ajouter print(message) après l’appel déclenche NameError: name 'message' is not defined : le nom local n’est pas disponible à cet endroit. Pour rendre la valeur disponible à l’appelant, renvoie-la et stocke-la :

def make_greeting():
    return "Hi"

message = make_greeting()
print(message)

Le message au premier niveau du fichier est une nouvelle variable de l’appelant qui reçoit la valeur renvoyée. La fonction ne rend pas ses propres noms locaux visibles à l’extérieur.

Chaque appel reçoit de nouvelles variables locales. Si un corps affecte count = 0, ajoute 1 et l’affiche, deux appels affichent « 1 » et « 1 ». Le second appel ne continue pas avec le compteur du premier. Différentes fonctions peuvent aussi utiliser indépendamment des noms locaux comme total.

Suivre le masquage et la recherche des noms

x = 10

def show():
    x = 5
    print(x)

show()
print(x)

La sortie est « 5 » puis « 10 ». La variable locale x masque la variable globale x dans show ; l’affectation ne modifie pas la valeur au premier niveau du fichier. Une variable globale appartient à la portée du premier niveau du fichier. Les affectations ordinaires hors des fonctions créent des variables globales.

Pour une fonction définie au premier niveau du fichier, Python cherche un nom parmi ses noms locaux, puis parmi les noms globaux du fichier, puis parmi les noms natifs comme print. La première correspondance l’emporte. Les noms locaux et globaux sont donc deux endroits différents à vérifier lorsqu’une valeur semble incorrecte.

Réaffecter un paramètre ne modifie pas la variable de l’appelant

def add_bonus(points):
    points = points + 10
    print(points)

score = 50
add_bonus(score)
print(score)

points commence avec la valeur 50. Sa réaffectation locale lui donne la valeur 60 : la première sortie est donc « 60 ». La variable score de l’appelant vaut toujours 50. Pour mettre explicitement ce nom à jour, utilise une fonction qui renvoie points + 10, puis écris score = add_bonus(score).

Modifier une liste est une opération différente

Une liste peut être partagée par deux noms :

def add_guest(guests, name):
    guests.append(name)

party = ["Ana"]
add_guest(party, "Ben")
print(party)

Le paramètre guests et la variable party de l’appelant désignent la même liste. append modifie le contenu de cette liste : la sortie est donc « ['Ana', 'Ben'] ». Affecter guests = [] dans la fonction ferait en revanche désigner une nouvelle liste au seul nom local ; party désignerait toujours la liste d’origine. Lorsque tu suis un argument de type liste, demande-toi si la ligne modifie l’objet partagé ou réaffecte seulement un nom local.

Une fonction peut lire un nom global sans déclaration. Affecter une valeur à un nom dans son corps suit une règle différente, et confondre ces opérations est une cause courante d’UnboundLocalError.

Lire un paramètre fixe

TAX_RATE = 0.25

def tax(amount):
    return amount * TAX_RATE

print(tax(80))

La sortie est « 20.0 ». amount est local ; TAX_RATE est lu parmi les noms globaux du fichier. Par convention, les majuscules marquent une constante et indiquent que le programme doit laisser ce paramètre fixe. Python n’impose pas cette convention.

Une affectation rend un nom local dans tout le corps

total = 0

def add_to_total(amount):
    total = total + amount

add_to_total(5)

L’affectation rend total local dans toute la fonction add_to_total. Pour calculer le membre de droite, Python essaie de lire ce nom local avant qu’il ait une valeur. Il ne se rabat pas sur le total global. L’appel déclenche UnboundLocalError: cannot access local variable 'total' where it is not associated with a value.

La décision repose sur tout le corps, pas seulement sur les lignes déjà exécutées. Un corps avec print(count) suivi de count = 10 considère aussi count comme local à la ligne d’affichage. Un count global ne peut pas fournir la valeur locale manquante.

Déclarer une affectation globale délibérée

total = 0

def add_to_total(amount):
    global total
    total = total + amount

add_to_total(5)
add_to_total(7)
print(total)

La lecture et l’affectation désignent maintenant toutes deux le nom global : la sortie est donc « 12 ». Place global total avant toute utilisation de total dans la fonction. Utiliser le nom avant sa déclaration est une erreur de syntaxe.

Une déclaration seule ne crée pas de valeur. Une affectation ultérieure peut créer une variable globale qui n’existait pas : le corps d’une fonction contenant global level puis level = 1 crée le level global lors de son appel.

Montrer le changement par les entrées et un résultat

Le même total cumulé peut être écrit avec une interface explicite :

def add_to_total(total, amount):
    return total + amount

total = 0
total = add_to_total(total, 5)
total = add_to_total(total, 7)
print(total)

Cela affiche aussi « 12 ». Chaque appel montre l’ancienne valeur transmise, et l’affectation montre où va la nouvelle valeur. Tu peux vérifier add_to_total(10, 3) indépendamment, sans initialiser d’abord un état global caché. Lorsque plusieurs fonctions modifient la même variable globale, leur comportement dépend de leur ordre d’exécution.

Lire une liste partagée et modifier son contenu utilise la référence existante. Faire désigner une autre liste à ce nom global est une affectation : la règle d’affectation s’applique donc.

L’appelant doit connaître la tâche d’une fonction sans lire toute son implémentation. Une docstring fournit cette description. Python reconnaît une chaîne comme la docstring de la fonction lorsqu’elle est la première instruction du corps.

Écrire d’abord une courte description

def to_fahrenheit(celsius):
    """Convert a temperature from degrees Celsius to degrees Fahrenheit."""
    return celsius * 9 / 5 + 32

print(to_fahrenheit.__doc__)

La sortie est la phrase entre les guillemets. Python stocke la docstring dans __doc__ ; les triples guillemets ne font pas partie de la phrase stockée. help(to_fahrenheit) affiche la description avec la signature to_fahrenheit(celsius). Transmets le nom de la fonction à help, sans appeler la fonction.

La convention courante consiste à utiliser trois guillemets doubles, même pour une docstring d’une ligne. Commence par une instruction comme « Renvoyer l’aire d’un rectangle. » et termine par un point. Garde une courte description et ses guillemets de fermeture sur une seule ligne. Tu n’as pas besoin de répéter le nom de la fonction et la liste des paramètres, car l’aide les affiche déjà.

Ajouter des détails lorsque les appelants en ont besoin

def split_bill(total, people, tip_rate=0.2):
    """Return each person's share of a bill, including the tip.

    total: the bill before the tip
    people: the number of people sharing the bill
    tip_rate: the tip as a fraction of the bill (default 0.2)
    """
    return total * (1 + tip_rate) / people

La première ligne indique le résultat. Une ligne vide la sépare des détails sur les entrées. La valeur par défaut est documentée comme 0,2, une fraction de l’addition ; cela évite qu’un appelant prenne 20 pour la valeur voulue pour un pourboire de 20 %. Les guillemets de fermeture d’une docstring multiligne sont placés sur leur propre ligne.

Pour split_bill(84, 4), la fonction applique le pourboire par défaut et renvoie 25,2. L’appelant peut comprendre ce que signifient les trois entrées avant de choisir les arguments. Indique les unités lorsqu’elles comptent et décris les effets comme l’affichage, afin que l’appelant puisse prévoir le résultat et le comportement visible.

Distinguer la documentation des commentaires

Une chaîne placée après une affectation ou une autre instruction du corps n’est pas la docstring de la fonction. C’est une expression de chaîne inutilisée, et __doc__ vaut None si aucune docstring ne figure en première instruction. Un commentaire # ne devient pas non plus la description de l’aide.

Écris le résumé au moment de définir la tâche de la fonction. Si la phrase nécessite plusieurs actions sans rapport, demande-toi si la fonction devrait être décomposée. Lorsque tu modifies les paramètres, les valeurs par défaut, les valeurs renvoyées ou les effets d’affichage, mets la docstring à jour en même temps ; les appelants s’y fient comme partie de l’interface.

La décomposition consiste à diviser une tâche en travaux plus petits. Chaque fonction est responsable d’une tâche, avec des entrées explicites et un résultat ou un effet explicite. Le programme principal peut alors se lire comme une courte suite d’étapes nommées.

Prévoir les données avant d’écrire les corps

Pour un programme qui indique la moyenne de notes de contrôle et une note sous forme de lettre, distingue trois tâches : lire les notes, calculer une moyenne et choisir une lettre. Décide de ce que chaque fonction auxiliaire reçoit et renvoie. Garde l’affichage dans main, où les résultats se rejoignent.

def get_score(prompt):
    return float(input(prompt))

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

def letter_grade(score):
    if score >= 90:
        return "A"
    if score >= 80:
        return "B"
    if score >= 70:
        return "C"
    return "F"

def main():
    first = get_score("Test 1: ")
    second = get_score("Test 2: ")
    third = get_score("Test 3: ")
    avg = average(first, second, third)
    print("Average:", round(avg, 1), "Grade:", letter_grade(avg))

main()

Avec les notes 78, 92 et 85, average renvoie 85,0. Ce résultat devient l’argument de letter_grade, qui renvoie « B ». L’affichage est « Average: 85.0 Grade: B ».

main coordonne la séquence ; elle n’a pas besoin de savoir comment letter_grade choisit sa réponse. Utiliser une fonction en connaissant sa tâche et son interface, sans suivre chaque instruction de son corps, relève de l’abstraction procédurale. Tu utilises déjà print de cette façon.

Fournir à l’appelant une interface claire

L’interface d’une fonction comprend son nom, ses paramètres, le résultat renvoyé et son comportement documenté. average(a, b, c) exige trois nombres et renvoie leur moyenne. Son appelant n’a pas besoin de répondre à une invite ni de récupérer du texte affiché pour obtenir ce nombre. Tu peux réécrire le calcul tout en conservant les entrées et la sortie convenues, et les appels existants continuent de fonctionner.

Utilise des noms comme calculate_total et print_receipt pour les actions, et is_even ou has_discount pour les questions booléennes. Des noms de paramètres comme price et quantity indiquent les valeurs attendues à chaque emplacement. Les noms d’une seule lettre peuvent convenir lorsque leur sens est clair, comme pour les trois entrées de average.

Transformer les éléments répétés en paramètres

Si plusieurs parties d’un programme affichent différents titres entre les mêmes lignes de signes égal, fais du titre un paramètre de print_heading(title). La structure répétée appartient à un seul corps, tandis que le texte variable appartient aux appels. Une modification ultérieure de la longueur des lignes ne demande alors qu’une seule correction.

Définis les fonctions de façon à rendre les tâches plus faciles à comprendre ou à réutiliser. Placer toutes les instructions dans une longue fonction main masque les tâches plus petites. Transformer chaque expression triviale en fonction auxiliaire utilisée une seule fois peut ajouter des noms sans améliorer la lisibilité. Un test utile consiste à vérifier si une courte phrase peut décrire chaque tâche ainsi que ses entrées et ses sorties.

Termine le fichier par l’appel effectif main() après toutes les définitions. Un programme qui ne contient que des définitions crée ses fonctions et se termine sans exécuter leurs corps.

Construire plusieurs fonctions avant d’en exécuter une seule rend un échec plus difficile à localiser. Le développement incrémental consiste à écrire une petite partie, à la vérifier, puis à ajouter la suivante. Tu conserves ainsi un programme qui fonctionne tout en réduisant la quantité de nouveau code à examiner.

Utiliser un bouchon pendant la conception

Un bouchon possède l’en-tête prévu et un corps provisoire. Une docstring et pass gardent la définition valide, mais la fonction renvoie None jusqu’à son implémentation. Une valeur de retour fixe peut aider à tester l’affichage d’un appelant sans prétendre que le calcul réel fonctionne déjà.

Commence par une fonction auxiliaire de calcul dont tu peux déterminer le résultat indépendamment. Une fois qu’elle se comporte correctement, relie-la à la fonction auxiliaire suivante. Garde la saisie interactive pour le moment où les calculs pourront être vérifiés par des appels directs.

Déterminer les résultats attendus avant l’exécution

Avec les fonctions average et letter_grade, les notes 70, 75 et 72 ont une moyenne d’environ 72,33 : la note sous forme de lettre attendue est donc « C ». Vérifie les deux étapes :

print(average(70, 75, 72))
print(letter_grade(average(70, 75, 72)) == "C")

Les sorties sont « 72.33333333333333 » et « True ». La comparaison teste directement la note attendue ; regarder uniquement la sortie d’un programme sans attente indépendante peut laisser passer une réponse erronée mais plausible.

Tester les limites ainsi que les entrées ordinaires

Pour un seuil de 90, teste 90 et 89,9. La fonction de notation correcte renvoie « A » et « B ». Si sa première condition était score > 90, seule la vérification exactement au seuil révélerait que 90 passe à tort au test suivant.

Inclus une valeur courante, les seuils exacts, des valeurs proches et des entrées extrêmes que la fonction est censée traiter. Pour la fonction de notation, vérifier 70 et 0 permet de tester le seuil de réussite le plus bas et le chemin final « F ». Une vérification comme print(letter_grade(85) == "B") est facile parce que la fonction prend une valeur et renvoie son résultat.

Lire la trace d’appels et examiner la valeur reçue

Supposons que main appelle letter_grade(input("Score: ")). Saisir « 85 » envoie une chaîne dans une comparaison avec un nombre. L’erreur finale est TypeError: '>=' not supported between instances of 'str' and 'int'. La trace d’appels désigne la comparaison dans la fonction auxiliaire, tandis qu’une ligne d’appel précédente désigne main.

L’échec se produit lors de la comparaison, mais la correction doit être faite là où la saisie est préparée : convertis-la avec float() avant de la transmettre. Un print("letter_grade got", score) temporaire en première ligne aide à révéler une entrée inattendue. Si son type n’est pas clair, examine l’appelant et la conversion qu’il utilise. Supprime les affichages de débogage une fois le bug corrigé.

Associer les symptômes aux causes probables

Après avoir corrigé une fonction auxiliaire, relance les vérifications qui exercent les chemins concernés et l’appelant qui la relie au programme.