Types de données

L’ensemble auquel appartient un nombre

Répondez à deux questions : vous tenez $7$ pommes et vous en coupez une en deux. Tenez-vous maintenant $7 + \frac{1}{2}$ pommes au même sens que vous teniez $7$ ? Une demi-pomme n’est pas un nombre entier de pommes, le $7$ vit dans $\mathbb{Z}$, et le $7\frac{1}{2}$ vit dans $\mathbb{Q}$.

Un mathématicien répond en demandant à quel ensemble une valeur appartient. La même distinction poursuit chaque programme : la machine stocke $42$ différemment de $42.5$, et $42$ différemment de "42". Le mot que Python emploie pour « dans quel ensemble vit cette valeur » est type.

Alors : combien d’ensembles vaut-il la peine de distinguer ? Quatre, pour commencer.

La ligne float contient une réserve délibérée, approché. Un entier est stocké exactement, à chaque fois. Un nombre réel, presque jamais : comment stockeriez-vous $1/3 = 0.333\ldots$ avec un nombre fini de chiffres ? Impossible, donc Python conserve une approximation finie, et les comptes divergent sur les derniers chiffres. Ce seul fait explique une surprise célèbre que vous allez bientôt rencontrer.

Demander l’ensemble d’appartenance

Devant une valeur, vous pouvez demander son type directement :

type(42)      # <class 'int'>
type(3.14)    # <class 'float'>
type("hi")    # <class 'str'>
type(True)    # <class 'bool'>

Deux remarques de notation. D’abord, type(...) est une fonction, vous lui confiez une valeur et elle vous rend l’objet de type auquel cette valeur appartient. Ensuite, la réponse s’affiche <class 'int'> ; le mot class est le terme de Python pour type, et le mot entre guillemets est le nom de l’ensemble. Lisez <class 'float'> comme « appartient à l’ensemble float ».

Un nom ne s’engage pas envers un ensemble

C’est ici que les dividendes commencent. Dans un langage à typage statique, vous déclareriez à l’avance : x est un entier. Python, lui, laisse un nom pointer où il veut :

x = 5
print(type(x))    # <class 'int'>
x = "hello"
print(type(x))    # <class 'str'>

Rediriger un nom vers un autre ensemble est légal, si bien que le type de x ne se lit dans aucune déclaration, seulement en demandant envers quoi il pointe actuellement. C’est le typage dynamique. C’est commode, et c’est aussi la raison pour laquelle votre programme peut silencieusement confier une chaîne à une fonction qui attend des nombres : rien ne l’en empêche jusqu’à ce que l’opération elle-même échoue.

Quelles valeurs se comportent comme True ?

Toute valeur est vraie ou fausse (truthy / falsy), ou bien elle se comporte comme True dans une condition, ou bien comme False. La règle est compacte, et il vaut la peine de la vérifier :

• Falsy : le $0$, le $0.0$, la chaîne vide "" et None
• Truthy : tout le reste

bool(0)         # False
bool(1)         # True
bool(-1)        # True   — tout nombre non nul est truthy
bool("")        # False
bool("hello")   # True   — toute chaîne non vide est truthy

Observez ce qui est dans la liste et ce qui en est exclu. -1 est True ; 0 ne l’est pas. La chaîne "0" est True, elle est non vide, et pour les chaînes le critère est la vacuité, pas la valeur de leur contenu. Cette règle se rembourse dès votre premier if : if score: signifie si score n’est pas nul.

Un exemple travaillé : auditer une expression

Les ensembles paient dès qu’une expression les mélange. Lisez le reçu ligne par ligne et demandez l’ensemble de chaque résultat :

unit_price = 4.75
quantity = 4
bill = unit_price * quantity     # float : le float absorbe l'int
type(bill)                       # <class 'float'>
bool(bill)                       # True — tout non-nul est truthy

type(10 / 2)                     # <class 'float'> — la division réelle ne rend jamais int

Lisez bill comme le produit de deux ensembles distincts. Les ensembles ne se « mélangent » pas, le float l’emporte, car la proportion n’est un nombre entier d’aucune échelle et l’ensemble le plus large doit la contenir. L’habitude d’audit consiste à demander directement à l’ensemble : type(...) confirme ce que vous soupçonniez au lieu de parier sur la chance.

Pièges courants

• 4 / 2 vaut 2.0, pas 2. La division réelle (/) renvoie toujours un float en Python 3, même quand la division est exacte. Pour un résultat entier, demandez la division entière : 4 // 2 → 2.
• True + True vaut 2. bool est une sous-classe de int en Python : True se comporte comme $1$ et False comme $0$ en arithmétique. Les deux ensembles se recouvrent, mais type(True) répond toujours bool.
• type() indique le type concret. type(True) est bool, pas int, si à l’aise que True soit dans les sommes.
• type() décrit le résultat, pas les opérandes. type(2 * 3.0) est float, un int multiplié par un float vit dans l’ensemble float. Ne le prédisez pas à partir des pièces ; demandez à la réponse.