Vous manipulez des données numériques en Python ? Approfondissez vos connaissances en explorant les diverses méthodes d’arrondissement des nombres offertes par ce langage.
La plupart des jeux de données réels contiennent des informations à la fois numériques et catégorielles. Les données numériques peuvent prendre de multiples formes, qu’il s’agisse de relevés de capteurs, de taux de change ou de signaux biomédicaux, parmi tant d’autres.
Lorsque vous travaillez avec des valeurs numériques, il peut être nécessaire de les arrondir à une précision spécifique pour les raisons suivantes :
- Garantir une mise en forme uniforme
- Faciliter le stockage et le traitement
Dans ce tutoriel, nous allons découvrir différentes manières d’arrondir un nombre avec une précision définie, d’arrondir un nombre à l’entier le plus proche et bien plus encore.
C’est parti !
Comment arrondir des nombres en utilisant la fonction intégrée round()
L’approche la plus courante pour arrondir des nombres en Python consiste à employer la fonction round(). Commençons par étudier sa syntaxe :
round(nombre, ndigits)
Ici,
- `nombre` représente le nombre que vous souhaitez arrondir.
- `ndigits` est un paramètre optionnel, dont la valeur par défaut est `None`. Il indique le nombre de chiffres après la virgule auquel arrondir le nombre. Par exemple, si `ndigits = 2`, le nombre sera arrondi à deux décimales.
- La fonction `round()` retourne un nombre arrondi à la précision de `ndigits` après la virgule décimale.
Exemples d’utilisation de la fonction round() en Python
Illustrons son fonctionnement à l’aide de quelques exemples de code.
Comme mentionné précédemment, `ndigits` est facultatif. Ainsi, lorsque nous appelons `round()` en ne fournissant que le nombre, celui-ci est arrondi à l’entier le plus proche.
nombre = 7.123456 arrondi = round(nombre) print(arrondi) # Résultat : 7
Voyons maintenant des exemples où nous spécifions la précision.
Avec `ndigits` défini sur 2, le nombre est arrondi à deux décimales (à la position des dixièmes) :
nombre = 7.123456 arrondi = round(nombre, 2) print(arrondi) # Résultat : 7.12
Avec `ndigits` défini sur 3, le nombre est arrondi à trois décimales (à la position des centièmes) :
nombre = 7.123456 arrondi = round(nombre, 3) print(arrondi) # Résultat : 7.123
Vous pouvez également utiliser `round()` pour arrondir les nombres négatifs :
nombre = -3.4 arrondi = round(nombre) print(arrondi) # Résultat : -3
Ici, la fonction arrondit -3.4 à -3, l’entier le plus proche.
Arrondir aux dizaines et aux centaines les plus proches
Saviez-vous que `ndigits` peut également accepter des valeurs négatives ?
Oui, vous pouvez appeler la fonction `round()` avec des valeurs négatives pour `ndigits`. Dans ce cas, l’arrondi s’effectue à gauche de la virgule décimale, et non à droite.
Qu’est-ce que cela signifie ? Regardons quelques exemples.
Lorsque nous définissons `ndigits` sur -1, le nombre est arrondi à la dizaine la plus proche.
nombre = 7.123456 arrondi = round(nombre, -1) print(arrondi) # Résultat : 10.0
Et appeler la fonction `round()` avec `ndigits` défini sur -2 arrondit le nombre 77.123456 à la centaine la plus proche, qui dans ce cas est 100.0.
nombre = 77.123456 arrondi = round(nombre, -2) print(arrondi) # Résultat : 100.0
Jusqu’à présent, la fonction `round()` semble suivre les principes d’arrondi courants que nous avons appris en mathématiques à l’école. Mais ce n’est pas toujours le cas.
Il existe certaines limitations liées à la représentation des nombres à virgule flottante. Par conséquent, vous pourriez obtenir des résultats inattendus lors de l’arrondi. Une autre particularité intéressante concerne l’arrondi du banquier.
Qu’est-ce que l’arrondi du banquier ?
Démarrez un interpréteur interactif Python et essayez l’exemple suivant :
>>> round(1.5) 2
Nous voyons que `round(1.5)` retourne 2 (comme prévu). Alors, que devrait retourner `round(2.5)` ?
>>> round(2.5) 2
Intéressant, n’est-ce pas ? `round(1.5)` et `round(2.5)` retournent tous les deux 2. Mais comment et pourquoi ?
En interne, la fonction `round` fonctionne comme ceci : toute valeur située exactement à mi-chemin entre deux entiers est arrondie à l’entier pair le plus proche. C’est ce que l’on appelle l’arrondi du banquier ou la stratégie d’arrondi « moitié vers le pair ».
Nous savons que la fonction `round()` suffit pour les tâches d’arrondi simples. Cependant, il arrive que l’on doive arrondir un nombre à l’entier supérieur ou inférieur.
Alors, comment faire ? Découvrons cela dans la section suivante.
Comment arrondir les nombres à l’entier supérieur en Python
Pour arrondir un nombre à l’entier le plus proche par excès, vous pouvez utiliser :
Utiliser math.ceil()
La fonction `ceil()` (ou fonction plafond) fonctionne de la manière suivante : elle arrondit un nombre au plus petit entier qui lui est supérieur.
L’extrait de code ci-dessous montre comment utiliser la fonction `ceil()` pour arrondir le nombre 3.2 :
import math nombre = 3.2 arrondi_sup = math.ceil(nombre) print(arrondi_sup) # Résultat : 4
Utilisation du module decimal
Jusqu’à présent, nous avons utilisé le type de données `float` intégré. Cependant, certaines applications, notamment en calcul scientifique et en finance, nécessitent une précision bien plus élevée. C’est pourquoi Python inclut le module `decimal` qui offre :
- Une arithmétique en virgule flottante plus précise
- Des tests d’égalité fiables
- Un contrôle plus précis du niveau de précision (la précision par défaut est de 28 décimales)
Pour afficher le contexte actuel, utilisez `getcontext()` comme indiqué :
from decimal import getcontext contexte_actuel = getcontext() print(contexte_actuel)
Vous devriez pouvoir voir la précision actuelle et le mode d’arrondi, entre autres :
# Résultat Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[InvalidOperation, DivisionByZero, Overflow])
Pour arrondir un nombre, vous pouvez utiliser `quantize()`, en spécifiant :
- La précision (0.0, puisque nous voulons arrondir à l’entier le plus proche) et
- Le mode d’arrondi : `ROUND_CEILING`
from decimal import Decimal, ROUND_CEILING
nombre = Decimal('3.2')
arrondi_sup = nombre.quantize(Decimal('0'), rounding=ROUND_CEILING)
print(arrondi_sup)
# Résultat : 4
Ici, le nombre 3.2 a été arrondi à l’entier supérieur 4.
Comment arrondir les nombres à l’entier inférieur en Python
Voyons maintenant comment arrondir les nombres en Python à l’entier inférieur. De manière similaire à l’arrondi supérieur, nous pouvons utiliser les modules `math` ou `decimal`.
Utiliser math.floor()
La fonction `floor()` du module `math` fonctionne de la manière suivante : elle arrondit un nombre au plus grand entier qui lui est inférieur.
Prenons l’exemple suivant :
import math nombre = 3.8 arrondi_inf = math.floor(nombre) print(arrondi_inf) # Résultat : 3
Ici, la fonction `floor()` arrondit le nombre à virgule flottante 3.8 à 3.
Utilisation du module decimal
Pour arrondir un nombre, vous pouvez utiliser `quantize()` en définissant le mode d’arrondi sur `ROUND_FLOOR`.
from decimal import Decimal, ROUND_FLOOR
nombre = Decimal('3.8')
arrondi_inf = nombre.quantize(Decimal('0'), rounding=ROUND_FLOOR)
print(arrondi_inf)
# Résultat : 3
Comme vous pouvez le constater, 3.8 a été arrondi à 3.
Pièges courants à éviter lors de l’arrondissement des nombres
Nous avons déjà vu que la fonction `round()` arrondit à la valeur paire la plus proche, ce qui n’est pas toujours souhaité. Voici d’autres pièges courants à éviter lors de l’arrondissement des nombres en Python :
- Comparaison d’égalité incorrecte : l’arrondi des nombres introduit souvent des erreurs d’arrondi. Si vous essayez d’effectuer une comparaison d’égalité entre un résultat arrondi et une autre valeur, la vérification de l’égalité échouera (presque toujours) en raison d’une précision variable. Par conséquent, essayez d’éviter les contrôles d’égalité entre les nombres à virgule flottante et les nombres à virgule flottante arrondis. Si la comparaison est nécessaire, introduisez alors une marge de tolérance.
- Perte d’informations : vous pouvez souhaiter que certaines données, telles que des relevés de capteurs à différents horodatages, soient capturées avec une haute précision. L’arrondi de ces données à un nombre inférieur de décimales entraîne une perte d’informations et une analyse incorrecte.
- Arrondir les résultats intermédiaires : les calculs comportent souvent plusieurs étapes. Utilisez une précision constante à chaque étape. Évitez également d’arrondir les résultats intermédiaires pour éviter que les erreurs d’arrondi ne s’aggravent.
Meilleures pratiques pour l’arrondissement des nombres en Python
Énumérons quelques bonnes pratiques à suivre lors de l’arrondissement des nombres en Python :
- Choisir le bon type de données : sélectionnez entre les types de données `float` et `decimal` en fonction de l’application. Si vous devez effectuer des calculs à virgule flottante de haute précision, choisissez le type de données `decimal`.
- Utiliser des niveaux de précision cohérents : définissez des niveaux de précision cohérents pour les nombres décimaux dans tout le programme afin d’éviter des erreurs d’arrondi inattendues.
- Documenter les techniques d’arrondi : dans les applications réelles impliquant des données telles que les conversions de devises et les relevés de capteurs, il est important de mettre en place une technique d’arrondi cohérente et documentée.
Conclusion
Terminons ce tutoriel par un bref récapitulatif de ce que nous avons appris :
- Vous pouvez utiliser la fonction intégrée `round()` avec la syntaxe `round(nombre, ndigits)`. Lorsque vous utilisez cette fonction, vous devez connaître la stratégie d’arrondi du banquier. Elle arrondit donc les nombres situés exactement entre deux entiers à l’entier pair le plus proche.
- Vous pouvez utiliser les fonctions `ceil()` et `floor()` du module `math` pour arrondir un nombre donné à l’entier le plus proche, par excès et par défaut, respectivement.
- Lorsque vous devez effectuer des calculs à virgule flottante de haute précision, utilisez le module `decimal`. Vous pouvez ainsi arrondir les nombres avec la précision et la stratégie d’arrondi requises.
- Vous devez être conscient des pièges courants liés à l’arrondi des nombres en Python. Cela comprend la perte d’informations due à l’arrondi, l’arrondi des résultats intermédiaires et l’utilisation de précisions différentes dans différentes parties du code.
- Les meilleures pratiques comprennent le choix du type de données approprié en fonction de l’application et la documentation de niveaux de précision cohérents.
Découvrez ensuite comment effectuer une division entière en Python.
Cet article vous a-t-il été utile ?
Merci pour votre avis !