- À propos de sys.float_info et sys.int_info
- Afficher les informations sur les nombres flottants avec sys.float_info
- Connaître les valeurs maximale et minimale des nombres flottants
- Connaître la précision des nombres flottants
- Comprendre epsilon avec sys.float_info.epsilon
- Afficher les informations sur les entiers avec sys.int_info
- Comprendre la représentation des grands entiers
- Comprendre la différence entre float_info et int_info
- Utiliser float_info et int_info dans un programme
- À retenir !
1. À propos de sys.float_info et sys.int_info
Le module sys fournit plusieurs informations sur le fonctionnement de l'interpréteur Python. Parmi elles, sys.float_info décrit les caractéristiques des nombres à virgule flottante de type float, tandis que sys.int_info fournit des informations sur la représentation interne des nombres entiers de type int.
Il est important de ne pas confondre les deux. sys.float_info renseigne notamment sur les limites et la précision des nombres flottants, alors que sys.int_info décrit surtout certains paramètres de la représentation interne des entiers Python.
Le programme suivant affiche les deux objets afin d'avoir une première vue des informations qu'ils contiennent.
1 2 3 4 | import sys print(sys.float_info) print(sys.int_info) |
Sortie possible :
1 2 | sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1) sys.int_info(bits_per_digit=30, sizeof_digit=4, default_max_str_digits=4300, str_digits_check_threshold=640) |
Le contenu exact de sys.int_info peut varier selon la version et l'implémentation de Python. Les informations affichées dans ce tutoriel correspondent principalement à CPython.
2. Afficher les informations sur les nombres flottants avec sys.float_info
sys.float_info fournit un ensemble d'attributs décrivant les caractéristiques des nombres float utilisés par Python. Sur les implémentations courantes, ces nombres correspondent généralement aux nombres à double précision du système sous-jacent.
Le programme suivant affiche plusieurs attributs importants de sys.float_info.
1 2 3 4 5 6 7 8 | import sys print("Maximum :", sys.float_info.max) print("Minimum normalisé :", sys.float_info.min) print("Précision décimale :", sys.float_info.dig) print("Précision de la mantisse :", sys.float_info.mant_dig) print("Epsilon :", sys.float_info.epsilon) print("Base :", sys.float_info.radix) |
Sortie possible :
1 2 3 4 5 6 | Maximum : 1.7976931348623157e+308 Minimum normalisé : 2.2250738585072014e-308 Précision décimale : 15 Précision de la mantisse : 53 Epsilon : 2.220446049250313e-16 Base : 2 |
Ces attributs permettent d'étudier les limites, la précision et certaines propriétés de la représentation des nombres flottants.
3. Connaître les valeurs maximale et minimale des nombres flottants
L'attribut sys.float_info.max fournit la plus grande valeur flottante finie positive représentable. L'attribut sys.float_info.min fournit, quant à lui, la plus petite valeur flottante positive normalisée.
Le programme suivant affiche ces deux valeurs.
1 2 3 4 | import sys print("Float maximal :", sys.float_info.max) print("Float positif normalisé minimal :", sys.float_info.min) |
Sortie possible :
1 2 | Float maximal : 1.7976931348623157e+308 Float positif normalisé minimal : 2.2250738585072014e-308 |
Une remarque importante s'impose : sys.float_info.min ne représente pas le nombre flottant négatif minimal et ne représente pas non plus nécessairement le plus petit nombre positif non nul pouvant exister.
Le nombre flottant fini négatif de plus grande amplitude peut être obtenu en prenant l'opposé de sys.float_info.max.
1 2 3 4 5 | import sys minimum_negatif = -sys.float_info.max print(minimum_negatif) |
Sortie possible :
1 | -1.7976931348623157e+308 |
Des valeurs positives plus petites que sys.float_info.min peuvent exister sous forme de nombres subnormaux. Ainsi, l'attribut min doit bien être compris comme la plus petite valeur positive normalisée.
4. Connaître la précision des nombres flottants
sys.float_info.dig fournit une information importante sur la précision décimale des nombres flottants. Il indique le nombre maximal de chiffres décimaux significatifs pouvant être convertis en nombre flottant puis reconvertis en décimal en conservant la même valeur décimale.
Le programme suivant affiche cette valeur.
1 2 3 | import sys print("Nombre de chiffres significatifs :", sys.float_info.dig) |
Sortie possible :
1 | Nombre de chiffres significatifs : 15 |
L'attribut mant_dig indique quant à lui le nombre de chiffres en base radix utilisés pour représenter la significande d'un nombre flottant.
Le programme suivant affiche mant_dig et radix.
1 2 3 4 | import sys print("mant_dig :", sys.float_info.mant_dig) print("radix :", sys.float_info.radix) |
Sortie possible :
1 2 | mant_dig : 53 radix : 2 |
Dans cet environnement, la significande possède donc une précision de 53 chiffres binaires. Cela explique en partie pourquoi les nombres flottants ne peuvent pas représenter exactement tous les nombres décimaux.
5. Comprendre epsilon avec sys.float_info.epsilon
L'attribut sys.float_info.epsilon représente la différence entre 1.0 et la plus petite valeur flottante représentable strictement supérieure à 1.0.
Le programme suivant affiche la valeur d'epsilon.
1 2 3 4 5 | import sys epsilon = sys.float_info.epsilon print(epsilon) |
Sortie possible :
1 | 2.220446049250313e-16 |
Nous pouvons vérifier le rôle de cette valeur en l'ajoutant à 1.0.
1 2 3 4 5 6 7 | import sys epsilon = sys.float_info.epsilon print(1.0) print(1.0 + epsilon) print(1.0 + epsilon > 1.0) |
Sortie :
1 2 3 | 1.0 1.0000000000000002 True |
Si nous ajoutons une quantité plus petite, comme epsilon / 2, l'arrondi peut conduire à retrouver exactement 1.0.
1 2 3 4 5 6 | import sys epsilon = sys.float_info.epsilon print(1.0 + epsilon / 2) print(1.0 + epsilon / 2 == 1.0) |
Sortie :
1 2 | 1.0 True |
Il faut toutefois éviter d'utiliser systématiquement epsilon comme tolérance universelle pour comparer deux nombres flottants. La précision dépend de l'ordre de grandeur des nombres comparés. Pour les comparaisons numériques, des outils comme math.isclose() sont souvent plus appropriés.
6. Afficher les informations sur les entiers avec sys.int_info
Contrairement à sys.float_info, sys.int_info ne fournit pas une valeur entière maximale ou minimale. Les entiers Python peuvent avoir une précision arbitraire, limitée en pratique principalement par la mémoire disponible et les contraintes de l'environnement.
sys.int_info fournit plutôt des informations sur la manière dont les entiers sont représentés en interne par l'implémentation Python.
Le programme suivant affiche les informations disponibles.
1 2 3 | import sys print(sys.int_info) |
Sortie possible :
1 | sys.int_info(bits_per_digit=30, sizeof_digit=4, default_max_str_digits=4300, str_digits_check_threshold=640) |
Nous pouvons accéder individuellement aux principaux attributs.
1 2 3 4 5 6 | import sys print("bits_per_digit :", sys.int_info.bits_per_digit) print("sizeof_digit :", sys.int_info.sizeof_digit) print("default_max_str_digits :", sys.int_info.default_max_str_digits) print("str_digits_check_threshold :", sys.int_info.str_digits_check_threshold) |
Sortie possible :
1 2 3 4 | bits_per_digit : 30 sizeof_digit : 4 default_max_str_digits : 4300 str_digits_check_threshold : 640 |
Les attributs disponibles peuvent dépendre de la version de Python. Les deux premiers décrivent directement la représentation interne des grands entiers dans CPython, tandis que les suivants concernent notamment certaines limites de conversion entre entiers et chaînes décimales.
7. Comprendre la représentation des grands entiers
En Python, le type int n'est pas limité à une valeur maximale fixe comparable à sys.float_info.max. Lorsqu'un entier devient plus grand, Python utilise davantage de mémoire pour le représenter.
Le programme suivant crée plusieurs entiers de tailles très différentes.
1 2 3 4 5 6 7 | petit = 10 grand = 10 ** 100 tres_grand = 10 ** 1000 print(petit) print(grand) print(len(str(tres_grand))) |
Sortie :
1 2 3 | 10 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 1001 |
Le dernier entier contient 1001 chiffres décimaux. Python peut le représenter sans débordement du type int.
Nous pouvons utiliser sys.getsizeof() pour constater que les grands entiers nécessitent davantage de mémoire.
1 2 3 4 5 6 7 8 9 | import sys a = 10 b = 10 ** 100 c = 10 ** 1000 print("10 :", sys.getsizeof(a), "octets") print("10**100 :", sys.getsizeof(b), "octets") print("10**1000 :", sys.getsizeof(c), "octets") |
Sortie possible :
1 2 3 | 10 : 28 octets 10**100 : 72 octets 10**1000 : 468 octets |
Les valeurs exactes peuvent varier selon l'implémentation et l'environnement Python, mais le principe reste le même : plus un entier nécessite de chiffres internes pour être représenté, plus sa représentation peut demander de mémoire.
8. Comprendre la différence entre float_info et int_info
sys.float_info et sys.int_info concernent deux types numériques dont le fonctionnement est très différent.
Les nombres float possèdent une précision et une plage finies. Les nombres int, en revanche, peuvent augmenter en taille en utilisant davantage de mémoire.
| Caractéristique | sys.float_info | sys.int_info |
|---|---|---|
| Type concerné | float | int |
| Valeur maximale | Disponible avec max | Pas de maximum fixe fourni |
| Précision | Limitée | Précision arbitraire pour les entiers |
| Epsilon | Disponible | Non applicable |
| Informations internes | Caractéristiques de la représentation flottante | Caractéristiques de la représentation des entiers |
Le programme suivant illustre directement cette différence en essayant de dépasser la plage d'un nombre flottant tout en créant un entier extrêmement grand.
1 2 3 4 5 6 7 8 | import sys grand_entier = 10 ** 1000 grand_float = sys.float_info.max print("Chiffres du grand entier :", len(str(grand_entier))) print("Float maximal :", grand_float) print("Float multiplié par 2 :", grand_float * 2) |
Sortie possible :
1 2 3 | Chiffres du grand entier : 1001 Float maximal : 1.7976931348623157e+308 Float multiplié par 2 : inf |
Le grand entier reste un objet int exact, tandis que le dépassement de la plage finie du float conduit ici à la valeur spéciale inf, qui représente l'infini positif.
9. Utiliser float_info et int_info dans un programme
Les informations fournies par sys.float_info peuvent être utiles pour examiner les caractéristiques numériques de l'environnement Python utilisé.
Le programme suivant affiche un petit rapport sur la représentation des nombres flottants.
1 2 3 4 5 6 7 8 9 | import sys info = sys.float_info print("Maximum :", info.max) print("Minimum normalisé :", info.min) print("Chiffres significatifs :", info.dig) print("Epsilon :", info.epsilon) print("Base :", info.radix) |
Sortie possible :
1 2 3 4 5 | Maximum : 1.7976931348623157e+308 Minimum normalisé : 2.2250738585072014e-308 Chiffres significatifs : 15 Epsilon : 2.220446049250313e-16 Base : 2 |
De la même manière, sys.int_info permet d'inspecter certains paramètres utilisés pour les entiers.
1 2 3 4 5 6 | import sys info = sys.int_info print("Bits par chiffre interne :", info.bits_per_digit) print("Taille d'un chiffre interne :", info.sizeof_digit, "octets") |
Sortie possible :
1 2 | Bits par chiffre interne : 30 Taille d'un chiffre interne : 4 octets |
Ces informations sont surtout utiles pour comprendre le fonctionnement interne de Python, étudier la représentation des nombres ou écrire du code nécessitant des informations précises sur l'environnement d'exécution.
10. À retenir !
Le module sys fournit sys.float_info et sys.int_info pour obtenir des informations sur la représentation des nombres dans Python.
- sys.float_info décrit les caractéristiques des nombres de type float.
- sys.float_info.max donne la plus grande valeur flottante finie positive représentable.
- sys.float_info.min donne la plus petite valeur flottante positive normalisée.
- sys.float_info.dig fournit une information sur la précision décimale des nombres flottants.
- sys.float_info.mant_dig indique la précision de la significande dans la base indiquée par radix.
- sys.float_info.epsilon représente l'écart entre 1.0 et le plus petit flottant représentable strictement supérieur à 1.0.
- sys.int_info fournit des informations sur la représentation interne des entiers Python.
- Les objets int Python n'ont pas de valeur maximale fixe analogue à sys.float_info.max.
- Les grands entiers utilisent davantage de mémoire lorsque leur valeur augmente.
- Les valeurs et attributs disponibles peuvent dépendre de la version et de l'implémentation de Python.
Le programme suivant résume les informations numériques essentielles fournies par sys.float_info et sys.int_info.
1 2 3 4 5 6 7 8 9 10 11 | import sys print("=== Nombres flottants ===") print("Maximum :", sys.float_info.max) print("Minimum normalisé :", sys.float_info.min) print("Précision décimale :", sys.float_info.dig) print("Epsilon :", sys.float_info.epsilon) print("=== Nombres entiers ===") print("Bits par chiffre interne :", sys.int_info.bits_per_digit) print("Taille d'un chiffre interne :", sys.int_info.sizeof_digit, "octets") |
Sortie possible :
1 2 3 4 5 6 7 8 | === Nombres flottants === Maximum : 1.7976931348623157e+308 Minimum normalisé : 2.2250738585072014e-308 Précision décimale : 15 Epsilon : 2.220446049250313e-16 === Nombres entiers === Bits par chiffre interne : 30 Taille d'un chiffre interne : 4 octets |
Auteur : Younes Derfoufi
Lieu de travail : CRMEF OUJDA
Site Web : www.tresfacile.net
Chaine YouTube : https://www.youtube.com/user/InformatiquesFacile
Me contacter : https://www.tresfacile.net/me-contacter/
