Variables et types

En MicroPython, une variable se crée par simple affectation, sans déclarer son type : x = 5 suffit. C’est le typage dynamique : l’interpréteur déduit le type, et une même variable peut même en changer en cours de route. C’est la grande différence avec le C++ (int x = 5;), source de concision… et d’un piège à connaître. Cette fiche couvre les types de base et les conteneurs essentiels.

Pas de déclaration, un type déduit

temperature = 21.5      # float
nom = "Pico"            # str (chaîne de caractères)
actif = True            # bool
nombre = 42             # int

type() révèle le type courant :

>>> type(temperature)
<class 'float'>
>>> type(nombre)
<class 'int'>

Les int sont de précision arbitraire (pas de débordement à 65535 comme sur un int 16 bits AVR), et la division distingue deux opérateurs :

>>> 5 / 2      # division réelle -> float
2.5
>>> 5 // 2     # division entière -> int
2

Convertir entre types

Les conversions sont explicites : int(), float(), str().

>>> int("42") + 1        # une chaîne "42" devient le nombre 42
43
>>> "valeur : " + str(nombre)   # pour concaténer, convertir le nombre en str
'valeur : 42'

C’est fréquent en embarqué : un ADC renvoie un int, qu’on convertit en tension (float) ou en texte pour l’affichage.

Les conteneurs : list et dict

Une list range des valeurs ordonnées, modifiables :

mesures = [512, 530, 528]
mesures.append(541)      # ajoute en fin
print(mesures[0])        # premier élément -> 512
print(len(mesures))      # nombre d'éléments -> 4

Un dict associe des clés à des valeurs (pratique pour nommer) :

capteur = {"nom": "LDR", "broche": 26, "valeur": 512}
print(capteur["broche"])   # -> 26

Pièges

Le type peut changer en silence. Comme rien n’est déclaré, réaffecter x = "texte" après x = 5 est permis, et peut introduire un bug difficile à voir. Garder une variable sur un seul type, sauf raison claire.

/ n’est pas //. 5 / 2 vaut 2.5 (réel), pas 2. Pour une division entière, utiliser //. C’est l’inverse du réflexe C où / entre entiers tronque.

Le Pico calcule en simple précision. Ses float tiennent sur 32 bits, pas 64 comme sur un PC : un calcul pourtant simple peut afficher des décimales parasites. float("3.3") * 2 peut donner 6.5999999 au lieu de 6.6. C’est normal. Conséquence : ne pas comparer deux réels par égalité stricte (==), mais tester un petit écart (abs(a - b) < 0.001).

str + int lève une erreur. "valeur : " + 42 provoque un TypeError : il faut convertir (+ str(42)). Python ne mélange pas les types implicitement.

Coût mémoire. Un objet Python est plus lourd qu’un entier C. Sans gravité pour apprendre, mais à garder en tête sur de gros tableaux (voir gestion mémoire).

Exercices

Exercice 1 — Inspecter et convertir

Au REPL, créez une variable contenant la chaîne "3.3", vérifiez son type, puis convertissez-la en nombre réel et multipliez-la par 2.

Corrigé

>>> v = "3.3"
>>> type(v)
<class 'str'>
>>> float(v) * 2
6.6

La chaîne "3.3" n’est pas un nombre tant qu’on ne la convertit pas : float(v) la transforme en réel, qu’on peut alors calculer. Multiplier la chaîne (v * 2) donnerait '3.33.3', d’où l’importance de la conversion. Sur le Pico (simple précision), l’affichage réel peut être 6.5999999 plutôt que 6.6 : le calcul est juste, c’est l’affichage qui révèle la limite (voir le piège).

Exercice 2 — Moyenne de mesures

À partir d’une liste de trois mesures [512, 530, 528], calculez leur moyenne. Indice : sum() et len().

Corrigé

mesures = [512, 530, 528]
moyenne = sum(mesures) / len(mesures)
print(moyenne)        # 523.33...

sum() additionne les éléments, len() les compte. La division réelle / donne une moyenne en float. On retrouvera ce motif pour lisser des mesures bruitées.

Voir aussi

• Le langage MicroPython — hub du parcours langage
• Conditions et boucles — agir selon la valeur d’une variable
• Le typage en C++ — l’approche statique, à comparer
• Gestion mémoire — ce que coûtent les objets (transverse)