Les fonctions

Une fonction regroupe sous un nom un bloc d’instructions réutilisable. Plutôt que de recopier dix fois la même séquence de clignotement, on l’écrit une fois dans une fonction et on l’appelle. C’est l’outil de base pour factoriser (ne pas se répéter) et nommer (rendre le code lisible). En MicroPython, une fonction se déclare avec def, sans préciser le type des arguments. Voir aussi la notion générale de fonction.

Déclarer et appeler

def saluer():
    print("Bonjour depuis le Pico")
 
saluer()        # appel -> affiche le message

def ouvre la définition. Le corps est indenté, et l’appel se fait par nom(). La définition doit être exécutée avant l’appel (donc écrite plus haut dans le fichier).

Arguments et valeurs par défaut

Une fonction reçoit des arguments entre parenthèses. On peut donner une valeur par défaut, utilisée si l’argument est omis :

from time import sleep
 
def clignote(led, n=3, duree=0.2):
    for i in range(n):
        led.on()
        sleep(duree)
        led.off()
        sleep(duree)
 
clignote(led)            # 3 clignotements de 0,2 s (valeurs par défaut)
clignote(led, 5)         # 5 clignotements
clignote(led, 10, 0.05)  # 10 clignotements rapides

Renvoyer un résultat

return renvoie une valeur à l’appelant. Sans return, la fonction renvoie None.

def lire_tension(adc):
    brut = adc.read_u16()        # 0..65535
    return brut * 3.3 / 65535    # conversion en volts
 
v = lire_tension(capteur)
print("Tension :", v, "V")

Une fonction peut même renvoyer plusieurs valeurs d’un coup (sous forme de tuple) : return mini, maxi, récupérées par a, b = ....

Pièges

Oublier return. Une fonction censée fournir une valeur mais sans return renvoie None : v = lire_tension(capteur) donnerait None, et le calcul suivant échouerait. Vérifier qu’on renvoie bien le résultat.

Appeler avant de définir. La ligne def doit avoir été exécutée avant l’appel. Définir les fonctions en haut du fichier, les appeler ensuite.

Variables internes invisibles dehors. Une variable créée dans une fonction est locale : elle n’existe pas en dehors. Pour partager une valeur, la renvoyer (return) plutôt que de compter sur une variable globale (notion de portée, cf. globale).

Exercices

Exercice 1 — Une fonction de clignotement paramétrable

Écrivez une fonction clignote(led, n) qui fait clignoter une LED n fois (0,2 s on / 0,2 s off), puis appelez-la pour 4 clignotements.

Corrigé

from time import sleep
 
def clignote(led, n):
    for i in range(n):
        led.on()
        sleep(0.2)
        led.off()
        sleep(0.2)
 
clignote(led, 4)

La fonction encapsule la boucle. On la réutilise ensuite avec n’importe quel nombre. Ajouter duree=0.2 en argument par défaut la rendrait encore plus souple.

Exercice 2 — Convertir une lecture ADC

Écrivez une fonction en_volts(brut) qui convertit une lecture brute (0–65535) en tension (référence 3,3 V) et renvoie le résultat. Testez-la avec brut = 32768.

Corrigé

def en_volts(brut):
    return brut * 3.3 / 65535
 
print(en_volts(32768))    # ~1.65 V (moitié de l'échelle)

return rend le résultat utilisable par l’appelant (affichage, comparaison…). Une demi-échelle (32768) donne bien ~1,65 V, soit la moitié de 3,3 V : un bon test de cohérence.

Voir aussi

• Le langage MicroPython — hub du parcours langage
• Fonction — la notion générale (transverse)
• Modules et import — regrouper des fonctions dans un fichier réutilisable
• Portée locale et globale — ce qui survit hors d’une fonction (à comparer)