Comment arrondir des nombres en Python

C’est l’ère des mégadonnées, et chaque jour de plus en plus d’entreprises tentent de tirer parti de leurs données pour prendre des décisions éclairées. De nombreuses entreprises se tournent vers le puissant écosystème de la science des données de Python pour analyser leurs données, comme en témoigne La popularité croissante de Python dans le domaine de la science des données.

Chaque praticien de la science des données doit garder à l’esprit la manière dont un ensemble de données peut être biaisé. Tirer des conclusions à partir de données biaisées peut conduire à des erreurs coûteuses.

Il existe de nombreuses façons dont le biais peut se glisser dans un ensemble de données. Si vous avez étudié certaines statistiques, vous connaissez probablement des termes comme le biais de signalement, le biais de sélection et le biais d’échantillonnage. Il existe un autre type de biais qui joue un rôle important lorsque vous traitez des données numériques: le biais d’arrondi.

Dans cet article, vous apprendrez:

Pourquoi la façon dont vous arrondissez les chiffres est importante
Comment arrondir un nombre selon différentes stratégies d’arrondi et comment implémenter chaque méthode en Python pur
Comment l’arrondi affecte les données et quelle stratégie d’arrondi minimise cet effet
Comment arrondir les nombres dans les tableaux NumPy et les DataFrames Pandas

Quand appliquer différentes stratégies d’arrondi

*__ Répondez au questionnaire:* Testez vos connaissances avec notre quiz interactif "Arrondir les nombres en Python". À la fin, vous recevrez un score afin que vous puissiez suivre vos progrès d'apprentissage au fil du temps:

lien:/quiz/python-rounding/[Participez au quiz »]

Cet article n’est pas un traité sur la précision numérique en informatique, bien que nous aborderons brièvement le sujet. Seule une familiarité avec les principes fondamentaux de Python est nécessaire, et les mathématiques impliquées ici devraient être à l’aise pour quiconque connaît l’équivalent de l’algèbre du lycée.

Commençons par examiner le mécanisme d’arrondi intégré de Python.

Fonction intégrée `+ round () +` de Python

Python a une fonction intégrée + round () + qui prend deux arguments numériques, + n + et + ndigits +, et retourne le nombre + n + arrondi à + ndigits +. L’argument + ndigits + est réglé par défaut sur zéro, donc le laisser de côté entraîne un nombre arrondi à un entier. Comme vous le verrez, + round () + peut ne pas fonctionner comme prévu.

La façon dont la plupart des gens apprennent à arrondir un nombre ressemble à ceci:

_ _ Arrondissez le nombre + n + à + p + décimales en décalant d’abord la virgule décimale dans + n + par + p + placez en multipliant + n + par 10ᵖ (10 élevé à la puissance + p + e ) pour obtenir un nouveau nombre + m +.

Regardez ensuite le chiffre + d + à la première décimale de + m +. Si + d + est inférieur à 5, arrondissez + m + à l’entier le plus proche. Sinon, arrondissez + m +.

Enfin, décaler la virgule décimale + p + en divisant + m + par 10ᵖ. _ _

C’est un algorithme simple! Par exemple, le nombre + 2,5 + arrondi au nombre entier le plus proche est + 3 +. Le nombre + 1.64 + arrondi à une décimale est + 1.6 +.

Ouvrez maintenant une session d’interpréteur et arrondissez + 2.5 + au nombre entier le plus proche en utilisant https://docs.python.org/3/library/functions.html#round [+ round () + intégré à Python. ] une fonction:

>>>

>>> round(2.5)
2

Haleter!

Comment + round () + gère-t-il le nombre + 1.5 +?

>>>

>>> round(1.5)
2

Donc, + round () + rounds + 1.5 + jusqu’à + 2 +, et + 2.5 + vers + 2 +!

Avant de soulever un problème sur le traqueur de bogues Python, permettez-moi de vous assurer que + round (2.5) + est censé renvoyer + 2 +. Il y a une bonne raison pour laquelle + round () + se comporte comme il le fait.

Dans cet article, vous apprendrez qu’il existe plus de façons d’arrondir un nombre que vous ne le pensez, chacune avec des avantages et des inconvénients uniques. + round () + se comporte selon une stratégie d’arrondi particulière, qui peut ou non être celle dont vous avez besoin pour une situation donnée.

Vous vous demandez peut-être: «La façon dont j’arrondis les chiffres peut-elle vraiment avoir autant d’impact?» Voyons à quel point les effets de l’arrondi peuvent être extrêmes.

Quel impact peut avoir l’arrondi?

Supposons que vous ayez un jour incroyablement chanceux et que vous trouviez 100 $ sur le terrain. Plutôt que de dépenser tout votre argent en même temps, vous décidez de jouer intelligemment et d’investir votre argent en achetant des actions de différentes actions.

La valeur d’un stock dépend de l’offre et de la demande. Plus il y a de gens qui veulent acheter un stock, plus le stock a de valeur, et vice versa. Sur les marchés boursiers à volume élevé, la valeur d’une action particulière peut fluctuer de seconde en seconde.

Lançons une petite expérience. Nous prétendons que la valeur globale des actions que vous avez achetées fluctue d’un petit nombre aléatoire chaque seconde, par exemple entre 0,05 $ et - 0,05 $. Cette fluctuation n’est pas nécessairement une bonne valeur avec seulement deux décimales. Par exemple, la valeur globale peut augmenter de 0,031286 $ une seconde et diminuer la seconde suivante de 0,028476 $.

Vous ne voulez pas garder une trace de votre valeur à la cinquième ou sixième décimale, vous décidez donc de tout couper après la troisième décimale. Dans le jargon d’arrondi, cela s’appelle tronquer le nombre à la troisième décimale. Il y a une erreur à prévoir ici, mais en gardant trois décimales, cette erreur ne pourrait pas être substantielle. Droite?

Pour exécuter notre expérience en utilisant Python, commençons par écrire une fonction + truncate () + qui tronque un nombre à trois décimales:

>>>

>>> def truncate(n):
...     return int(n * 1000)/1000

La fonction + troncate () + fonctionne en décalant d’abord la virgule décimale du nombre + n + de trois places vers la droite en multipliant + n + par + 1000 +. La partie entière de ce nouveau nombre est prise avec + int () +. Enfin, la virgule décimale est décalée de trois places vers la gauche en divisant + n + par + 1000 +.

Définissons ensuite les paramètres initiaux de la simulation. Vous aurez besoin de deux variables: une pour garder une trace de la valeur réelle de vos stocks une fois la simulation terminée et une pour la valeur de vos stocks après avoir été tronquée à trois décimales à chaque étape.

Commencez par initialiser ces variables à + 100 +:

>>>

>>> actual_value, truncated_value = 100, 100

Exécutons maintenant la simulation pendant 1 000 000 de secondes (environ 11,5 jours). Pour chaque seconde, générez une valeur aléatoire entre + -0,05 + et + 0,05 + avec la fonction + uniforme () + dans le module + aléatoire +, puis mettez à jour + réel + et `+ tronqué + ":

>>>

>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239

La viande de la simulation se déroule dans la boucle + for +, qui boucle sur la plage + (1000000) + de nombres entre + 0 + et + 999,999 +. La valeur tirée de + range () + à chaque étape est stockée dans la variable + _ +, que nous utilisons ici car nous n’avons pas réellement besoin de cette valeur à l’intérieur de la boucle.

À chaque étape de la boucle, un nouveau nombre aléatoire entre + -0.05 + et + 0.05 + est généré en utilisant + random.randn () + et affecté à la variable + randn +. La nouvelle valeur de votre investissement est calculée en ajoutant + randn + à + actual_value +, et le total tronqué est calculé en ajoutant + randn + à + truncated_value + puis en tronquant cette valeur avec `+ truncate () + ' .

Comme vous pouvez le voir en inspectant la variable + actual_value + après avoir exécuté la boucle, vous n’avez perdu que 3,55 $ environ. Cependant, si vous regardiez + truncated_value +, vous auriez pensé que vous aviez perdu presque tout votre argent!

*Remarque:* Dans l'exemple ci-dessus, la fonction `+ random.seed () +` est utilisée pour amorcer le générateur de nombres pseudo-aléatoires afin que vous puissiez reproduire la sortie montrée ici.

Pour en savoir plus sur le caractère aléatoire dans Python, consultez https://realpython.com/python-random/[Generating Random Data in Python (Guide) de Real Python.

Ignorant pour le moment que + round () + ne se comporte pas exactement comme prévu, essayons de relancer la simulation. Nous allons utiliser + round () + cette fois pour arrondir à trois décimales à chaque étape, et + seed () + à nouveau la simulation pour obtenir les mêmes résultats qu’auparavant:

>>>

>>> random.seed(100)
>>> actual_value, rounded_value = 100, 100

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     rounded_value = round(rounded_value + randn, 3)
...

>>> actual_value
96.45273913513529

>>> rounded_value
96.258

Quelle différence!

Aussi choquant que cela puisse paraître, cette erreur exacte a fait beaucoup de bruit au début des années 1980 lorsque le système conçu pour enregistrer la valeur de la Vancouver Stock Exchange a tronqué la valeur globale de l’indice à trois décimales au lieu d’arrondir. Des erreurs d’arrondi ont swayed élections et ont même entraîné les http://www-users.math.umn.edu/~arnold/disasters/patriot .html [perte de vie].

La façon dont vous arrondissez les chiffres est importante et, en tant que développeur et concepteur de logiciels responsable, vous devez connaître les problèmes courants et savoir comment les résoudre. Plongeons-nous et examinons les différentes méthodes d’arrondi et comment les implémenter chacune en Python pur.

Une ménagerie de méthodes

Il existe une https://en.wikipedia.org/wiki/Rounding}plethora of rounding strategies], chacune avec ses avantages et ses inconvénients. Dans cette section, vous découvrirez certaines des techniques les plus courantes et leur influence sur vos données.

Troncature

La méthode la plus simple, quoique la plus grossière, pour arrondir un nombre consiste à tronquer le nombre en un nombre donné de chiffres. Lorsque vous tronquez un nombre, vous remplacez chaque chiffre après une position donnée par 0. Voici quelques exemples:

Value	Truncated To	Result
12.345	Tens place	10
12.345	Ones place	12
12.345	Tenths place	12.3
12.345	Hundredths place	12.34

Vous avez déjà vu une façon de l’implémenter dans la fonction + truncate () + à partir du lien: # how-much-impact-can-rounding-have [Combien d’impact peut avoir l’arrondi?]. Dans cette fonction, le numéro d’entrée a été tronqué à trois décimales par:

Multiplier le nombre par + 1000 + pour déplacer la virgule décimale de trois places vers la droite
Prendre la partie entière de ce nouveau nombre avec + int () + *Décaler la décimale de trois places vers la gauche en divisant par + 1000 +

Vous pouvez généraliser ce processus en remplaçant + 1000 + par le nombre 10ᵖ (+ 10 + élevé à la puissance pth), où p est le nombre de décimales à tronquer:

def truncate(n, decimals=0):
    multiplier = 10*  *decimals
    return int(n* multiplier)/multiplier

Dans cette version de + truncate () +, le deuxième argument par défaut est + 0 + de sorte que si aucun deuxième argument n’est passé à la fonction, alors + truncate () + renvoie la partie entière du nombre qui est passé à elle.

La fonction + truncate () + fonctionne bien pour les nombres positifs et négatifs:

>>>

>>> truncate(12.5)
12.0

>>> truncate(-5.963, 1)
-5.9

>>> truncate(1.625, 2)
1.62

Vous pouvez même passer un nombre négatif à + décimales + pour tronquer aux chiffres à gauche du séparateur décimal:

>>>

>>> truncate(125.6, -1)
120.0

>>> truncate(-1374.25, -3)
-1000.0

Lorsque vous tronquez un nombre positif, vous l’arrondissez. De même, tronquer un nombre négatif arrondit ce nombre. Dans un sens, la troncature est une combinaison de méthodes d’arrondi en fonction du signe du nombre que vous arrondissez.

Examinons chacune de ces méthodes d’arrondi individuellement, en commençant par l’arrondi.

Arrondir

La deuxième stratégie d’arrondi que nous examinerons s’appelle «arrondir». Cette stratégie arrondit toujours un nombre à un nombre spécifié de chiffres. Le tableau suivant résume cette stratégie:

Value	Round Up To	Result
12.345	Tens place	20
12.345	Ones place	13
12.345	Tenths place	12.4
12.345	Hundredths place	12.35

Pour implémenter la stratégie «d’arrondi» en Python, nous utiliserons la fonction https://docs.python.org/3/library/math.html#math.ceil [+ ceil () +] à partir de https ://docs.python.org/3/library/math.html [+ math +] module.

La fonction + ceil () + tire son nom du terme «plafond», qui est utilisé en mathématiques pour décrire l’entier le plus proche supérieur ou égal à un nombre donné.

Chaque nombre qui n’est pas un entier se situe entre deux entiers consécutifs. Par exemple, le nombre + 1.2 + se situe dans l’intervalle entre + 1 + et + 2 +. Le «plafond» est le plus grand des deux points limites de l’intervalle. Le moindre des deux points de terminaison appelé le «plancher». Ainsi, le plafond de + 1.2 + est + 2 +, et le plancher de + 1.2 + est + 1 +.

En mathématiques, une fonction spéciale appelée fonction plafond mappe chaque nombre à son plafond. Pour permettre à la fonction de plafond d’accepter des entiers, le plafond d’un entier est défini comme étant l’entier lui-même. Ainsi, le plafond du nombre + 2 + est + 2 +.

En Python, + math.ceil () + implémente la fonction de plafond et renvoie toujours l’entier le plus proche qui est supérieur ou égal à son entrée:

>>>

>>> import math

>>> math.ceil(1.2)
2

>>> math.ceil(2)
2

>>> math.ceil(-0.5)
0

Notez que le plafond de + -0,5 + est + 0 +, pas + -1 +. Cela a du sens parce que «+ 0 » est l'entier le plus proche de « -0,5 » qui est supérieur ou égal à « -0,5 +».

Écrivons une fonction appelée + round_up () + qui implémente la stratégie "arrondir":

def round_up(n, decimals=0):
    multiplier = 10 * *decimals
    return math.ceil(n* multiplier)/multiplier

Vous pouvez remarquer que + round_up () + ressemble beaucoup à + truncate () +. Tout d’abord, la virgule décimale dans + n + est décalée du nombre correct de places vers la droite en multipliant + n + par +10 * décimales +. Cette nouvelle valeur est arrondie à l’entier le plus proche en utilisant + math.ceil () +, puis le point décimal est décalé vers la gauche en divisant par +10

TOC

Comment arrondir des nombres en Python