Composition de programmes

En Python, toute valeur appartient à une classe qui détermine son type de valeur. Les valeurs qui partagent une classe partagent également le comportement. Par exemple, les nombres entiers 1 et 2 sont les deux instances de la classe int. Ces deux valeurs peuvent être traitées de façon similaire. Par exemple, on peut prendre leur valeur opposée (négative) ou bien les ajouter à un autre nombre entier. La fonction intégrée type nous permet d'inspecter la classe de n'importe quelle valeur.

>>> type ( 2 )
<class 'int'>

Les valeurs que nous avons utilisées jusqu'ici sont des exemples d'un petit nombre de types de données natifs intégrés dans le langage Python. Les types de données natifs présentent les propriétés suivantes :

1. Il existe des expressions qui s'évaluent à des valeurs appartenant à des types natifs, appelés littéraux.
2. Il existe des fonctions et des opérateurs intégrés permettant de manipuler des valeurs de types natifs.

La classe int est le type de données natif utilisé pour représenter des nombres entiers. Les littéraux entiers (séquences de chiffres adjacents) s'évaluent aux valeurs int, et les opérateurs mathématiques manipulent ces valeurs.

>>> 12 + 3000000000000000000000000
3000000000000000000000012

Python possède trois types numériques natifs : les nombres entiers (int), les nombres réels (float) et les nombres complexes (complex).

>>> type(1.5)
<class 'float'>
>>> type(1+1j)
<class 'complex'>

Les floats. Le nom float provient de la façon dont les nombres réels sont représentés en Python et dans de nombreux autres langages de programmation : une représentation dite « à virgule flottante ». Les détails de la façon dont ces nombres sont représentés ne sont pas le sujet de ce cours, mais il est important de connaître certaines différences de haut niveau entre les objets int et float. En particulier, les objets de type int représentent des entiers exactement, sans aucune approximation ni limite à leur taille. En revanche, les objets de type float peuvent représenter une large gamme de nombres fractionnaires, mais tous les nombres ne peuvent pas être représentés exactement, et il existe des valeurs minimales et maximales. Par conséquent, il faut considérer les valeurs de type float comme des approximations des valeurs réelles. Ces approximations n'ont qu'une précision limitée. La combinaison des valeurs de type float peut entraîner des erreurs d'approximation ; les deux expressions suivantes s'évalueraient à 7 s'il n'y avait pas d'approximation.

>>> 7 / 3 * 3
7.0

>>> 1 / 3 * 7 * 3
6.999999999999999

Bien que les expressions ci-dessus combinent des valeurs de type int, la division d'un int par un nombre d’un autre type produit une valeur de type float : une approximation finie et tronquée du quotient réel des deux nombres entiers divisés.

>>> type(1/3)
<class 'float'>
>>> 1/3
0.3333333333333333

Cette approximation conduit à des problèmes lorsque nous effectuons des tests d'égalité.

>>> 1/3 == 0.333333333333333312345 # Gare à l'approximation du float
True

Ces différences subtiles entre la classe int et float ont des conséquences importantes pour l'écriture de programmes, et ce sont des détails que les programmeurs doivent mémoriser. Heureusement, il n'y a qu'une poignée de types de données natifs, ce qui limite la quantité de choses à mémoriser pour devenir compétent dans un langage de programmation. En outre, ces détails sont à peu près les mêmes dans de nombreux langages de programmation, qui appliquent généralement des normes telles qu’appliquées par des directives communautaires telles que la norme IEEE 754 de représentation des nombres à virgule flottante.

Types non numériques. Les valeurs peuvent représenter de nombreux autres types de données, tels que des sons, des images, des lieux, des adresses Web, des connexions réseau et ainsi de suite. Certaines sont représentées par des types de données natifs, comme la classe Bool pour les valeurs True et False. Mais pour la plupart des valeurs, il incombe au développeur de définir ses propres types en utilisant les moyens de combinaison et d'abstraction que nous développerons dans ce chapitre.

La suite de ce tutoriel présente d'autres types de données natifs de Python, en se concentrant surtout sur le rôle qu'ils jouent dans la création d'abstractions de données utiles. Vous pouvez trouver plus de détails sur les différents types natifs dans la documentation officielle de Python 3.