Vous travaillez avec des types de données numériques en Python ? Améliorez votre niveau en apprenant les différentes façons d’arrondir les nombres en Python.

La plupart des ensembles de données du monde réel contiennent des caractéristiques numériques et catégorielles. Il existe un large éventail de caractéristiques numériques, allant des relevés de capteurs aux taux de change, en passant par les signaux biomédicaux, etc.

Lorsque vous travaillez avec des valeurs numériques, vous pouvez avoir besoin d’arrondir ces valeurs à une précision fixe pour des raisons telles que :

  • Assurer un format cohérent
  • Faciliter le stockage et le traitement

Dans ce didacticiel, nous allons apprendre les différentes façons d’arrondir un nombre à une précision spécifique, d’arrondir les nombres à l’entier le plus proche, et bien plus encore.

Commençons par le commencement.

Comment arrondir des nombres à l’aide de la fonction intégrée round()

La méthode la plus courante pour arrondir des nombres en Python est d’utiliser la fonction intégrée round(). Commençons par apprendre sa syntaxe :

round(num, ndigits)

Ici,

  • num est le nombre que vous voulez arrondir
  • ndigits est un paramètre facultatif dont la valeur par défaut est None. Il s’agit du nombre de chiffres à arrondir. Si ndigits = 2, num est arrondi à deux chiffres après la virgule.
  • La fonction round() renvoie num arrondi à ndigits après la virgule.

Exemples d’utilisation de la fonction Python round()

Codons quelques exemples pour comprendre le fonctionnement de la fonction round().

Comme nous l’avons mentionné, ndigits est optionnel. Ainsi, lorsque nous appelons round() avec seulement le nombre, le nombre est arrondi à l’entier le plus proche.

nombre = 7.123456
arrondi = round(number)  
print(arrondi)
# Sortie : 7

Prenons maintenant quelques exemples où nous spécifions la précision.

Avec ndigits à 2, le nombre est arrondi à deux décimales (dixième position) :

nombre = 7.123456
arrondi = round(number, 2)  
print(arrondi)
# Sortie : 7.12

Avec ndigits à 3, le nombre est arrondi à trois décimales (centième) :

nombre = 7.123456
arrondi = round(number, 3)  
print(arrondi)
# Sortie : 7.123

Vous pouvez également utiliser round() pour arrondir des nombres négatifs :

nombre = -3.4
arrondi = round(number)
print(arrondi) 
# Sortie : -3

Ici, la fonction arrondit -3.4 à -3, l’entier le plus proche.

Arrondir à la dizaine et à la centaine la plus proche

Saviez-vous que les ndigits peuvent également prendre des valeurs négatives ?

Oui, vous pouvez appeler la fonction round() avec des valeurs négatives pour ndigits. Dans ce cas, l’arrondi se fait à gauche de la virgule au lieu de la droite.

Qu’est-ce que cela signifie ? Voyons quelques exemples.

Lorsque nous fixons ndigits à -1, le nombre est arrondi à la dizaine la plus proche.

nombre = 7.123456
arrondi = round(number, -1)  
print(arrondi)
# Sortie : 10.0

En appelant la fonction round() avec ndigits à -2, on arrondit le nombre 77.123456 à la centaine la plus proche, soit 100.0 dans ce cas.

number = 77.123456
arrondi = round(number, -2)  
print(arrondi)
# Sortie : 100.0

Jusqu’à présent, la fonction round() semble suivre les principes généraux de l’arrondi que nous avons appris à l’école en mathématiques. Mais ce n’est pas toujours le cas.

Les nombres à virgule flottante présentent certaines limites . Vous pouvez donc obtenir des résultats inattendus lors de l’arrondi. Une autre mise en garde intéressante est l’arrondi du banquier.

Qu’est-ce que l’arrondi bancaire ?

Démarrez une REPL Python et essayez l’exemple suivant :

>>> round(1.5)
2

Nous voyons que round(1.5) renvoie 2 (comme prévu). Alors, que devrait retourner round(2.5)?

>>> round(2.5)
2

Intéressant, non ? Round( 1.5) et Round(2.5) renvoient tous deux 2. Mais comment et pourquoi ?

En interne, la fonction round fonctionne de la manière suivante : toute valeur située à mi-chemin entre deux entiers est arrondie à l’entier pair le plus proche. C’est ce qu’on appelle l’arrondi du banquier ou la stratégie de l’arrondi de la moitié au pair.

Nous savons que la fonction round() suffit pour les tâches d’arrondi simples. Mais il peut arriver que vous deviez arrondir un nombre à l’entier supérieur ou inférieur le plus proche.

Comment faire ? C’est ce que nous allons voir dans la section suivante.

Comment arrondir des nombres en Python

Pour arrondir un nombre à l’entier le plus proche, vous pouvez utiliser :

Utilisation de math.ceil

La fonction ceil () (ou fonction plafond) fonctionne comme suit : Elle arrondit un nombre à l’entier supérieur le plus petit.

python-round-1

L’extrait suivant montre comment utiliser la fonction ceil() pour arrondir le nombre 3,2 :

import math

nombre = 3,2
rounded_up = math.ceil(number)
print(rounded_up)  
# Sortie : 4

Utilisation du module décimal

Jusqu’à présent, nous avons utilisé le type de données intégré float. Mais pour certaines applications en informatique scientifique et en finance, nous avons besoin d’une plus grande précision. Pour cela, Python est livré avec le module décimal qui fournit :

  • Une arithmétique en virgule flottante plus précise
  • Des tests d’égalité fiables
  • Un contrôle plus fin du niveau de précision (la précision par défaut est de 28 places)

Pour voir le contexte actuel, utilisez getcontext() comme indiqué :

from decimal import getcontext
contexte_actuel = contexte_actuel()
print(contexte_courant)

Vous devriez être en mesure de voir la précision et le mode d’arrondi actuels, entre autres :

# Sortie
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, 
majuscules=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

number = Decimal('3.2')
rounded_up = number.quantize(Decimal('0'), rounding=ROUND_CEILING)
print(rounded_up)  
# Sortie : 4

Ici, le nombre 3,2 a été arrondi à l’entier 4 le plus proche.

Comment arrondir les nombres à la valeur inférieure en Python

Voyons maintenant comment arrondir les nombres en Python. Comme pour l’arrondi à l’entier supérieur, nous pouvons utiliser les modules math ou decimal.

Utilisation de math.floor

La fonction floor() du module math fonctionne comme suit : Elle arrondit un nombre à l’entier inférieur le plus grand.

python-round-2

Prenons l’exemple suivant :

import math

nombre = 3,8
arrondi = math.floor(nombre)
print(arrondi_bas)  
# Sortie : 3

Ici, la fonction floor() arrondit le nombre à virgule flottante 3,8 à 3.

Utilisation du module décimal

Pour arrondir un nombre à l’unité inférieure, vous pouvez utiliser quantize() en réglant le mode d’arrondi sur ROUND_FLOOR.

from decimal import Decimal, ROUND_FLOOR

nombre = Décimal('3.8')
rounded_down = number.quantize(Decimal('0'), rounding=ROUND_FLOOR)
print(rounded_down)  
# Sortie : 3

Comme vous le voyez, 3,8 a été arrondi à 3.

Pièges courants à éviter lors de l’arrondi des nombres

Nous avons déjà vu que la fonction round() arrondit la moitié au pair, ce qui n’est pas toujours souhaitable. Il existe d’autres pièges courants à éviter lorsque l’on arrondit 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, le contrôle d’égalité échouera (presque toujours) en raison de la variation de la précision. Essayez donc d’éviter les contrôles d’égalité entre des nombres à virgule flottante et des nombres à virgule flottante arrondis. Si la comparaison est nécessaire, introduisez un seuil de tolérance.
  • Perte d’informations: Il se peut que vous souhaitiez que certaines données, telles que les relevés de capteurs à différents moments, soient capturées avec une grande précision. L’arrondissement 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: Le calcul se fait souvent en plusieurs étapes. Utilisez une précision cohérente pour toutes les étapes. Évitez également d’arrondir les résultats aux étapes intermédiaires afin d’éviter que les erreurs d’arrondi ne s’additionnent.

Meilleures pratiques pour arrondir les nombres en Python

Voici une liste des meilleures pratiques à suivre pour arrondir des nombres en Python :

  • Choisissez le bon type de données: Choisissez entre les types de données float et décimal en fonction de l’application. Si vous devez effectuer des opérations arithmétiques de haute précision en virgule flottante, choisissez le type de données décimal.
  • Utilisez des niveaux de précision cohérents: Définissez des niveaux de précision cohérents pour les nombres décimaux dans l’ensemble du programme afin d’éviter les erreurs d’arrondi inattendues.
  • Documentez les techniques d’arrondi: Dans les applications réelles impliquant des données telles que des devises ou des relevés de capteurs, il est important de disposer d’une technique d’arrondi cohérente et documentée.

Récapitulation

Concluons ce tutoriel par un examen rapide de ce que nous avons appris :

  • Vous pouvez utiliser la fonction intégrée round() avec la syntaxe suivante round(num, ndigits). Lorsque vous utilisez la fonction round(), vous devez être conscient de la stratégie d’arrondi du banquier. Ainsi, elle arrondit les nombres exactement entre deux entiers à l’entier pair le plus proche.
  • Vous pouvez utiliser les fonctions ceil() et floor() du module mathématique pour arrondir respectivement un nombre donné à l’entier supérieur et à l’entier inférieur le plus proche.
  • Lorsque vous devez effectuer des opérations arithmétiques de haute précision en virgule flottante, utilisez le module décimal. Vous pouvez 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. Il s’agit notamment de la perte d’informations due à l’arrondi, de l’arrondi des résultats à des étapes intermédiaires et de l’utilisation d’une précision différente dans différentes parties du code.
  • Les meilleures pratiques consistent à choisir le bon type de données en fonction de l’application et à documenter des niveaux de précision cohérents.

Ensuite, apprenez à effectuer une division par le sol en Python.