Python Fonction round() avec des exemples

Qu'est-ce que la fonction round() dans Python?

Python round() est une fonction intégrée disponible avec PythonElle vous renverra un nombre flottant arrondi au nombre de décimales indiqué en entrée.

Si les décimales à arrondir ne sont pas précisées, il est considéré comme 0 et il sera arrondi à l'entier le plus proche.

Syntaxe

round(float_num, num_of_decimals)

Paramètres

• nombre_flottant : Le nombre flottant à arrondir.
• nombre_de_décimales : (Facultatif) Nombre de décimales à prendre en compte pour l'arrondi. Ce paramètre est facultatif ; s'il n'est pas spécifié, la valeur par défaut est 0 et l'arrondi est effectué à l'entier le plus proche.

Description

La méthode round() prend deux arguments :

• le nombre à arrondir, et
• les décimales à prendre en compte lors de l'arrondi.

Le deuxième argument est facultatif et vaut par défaut 0 s'il n'est pas spécifié ; dans ce cas, il sera arrondi à l'entier le plus proche et le type de retour sera également un entier.

Lorsque les décimales, c'est-à-dire le deuxième argument, sont présentes, l'arrondi sera effectué au nombre de décimales indiqué. Le type de retour sera un float.

Si le chiffre après la virgule est :

• >= 5, alors + 1 sera ajouté à la valeur finale.
• < 5, alors la valeur finale sera renvoyée telle quelle, jusqu'aux décimales mentionnées.

Valeur de retour

Elle renverra un entier si le nombre de décimales n'est pas spécifié, et un nombre à virgule flottante s'il est spécifié. Veuillez noter que la valeur sera arrondie à 1 si le nombre de décimales est supérieur ou égal à 5 ; sinon, elle sera conservée telle quelle, avec le nombre de décimales indiqué.

Quel impact l’arrondi peut-il avoir ? (Arrondi ou troncature)

Le meilleur exemple pour illustrer l'impact de l'arrondi est le marché boursier. Auparavant, c'est-à-dire en 1982, Bourse de Vancouver (VSE) utilisé pour tronquer les valeurs boursières à trois décimales sur chaque transaction.

Cette opération était effectuée près de 3 000 fois par jour. Les troncatures accumulées entraînaient une perte d'environ 25 points par mois.

Un exemple de troncature des valeurs par rapport à l’arrondi est présenté ci-dessous.

Considérez les nombres à virgule flottante générés ci-dessous comme des valeurs boursières. Actuellement, je les génère pour une plage de 1 000 000 de secondes, entre 0.01 et 0.05.

Exemples :

arr = [random.uniform(0.01, 0.05) for _ in range(1000000)]

Pour illustrer l'impact de l'arrondi, j'ai écrit un petit morceau de code dans lequel, dans un premier temps, on utilise les nombres jusqu'à seulement 3 décimales, c'est-à-dire en tronquant le nombre après 3 décimales.

J'ai la valeur totale initiale, le total obtenu à partir des valeurs tronquées, et la différence entre la valeur initiale et la valeur tronquée.

Sur le même ensemble de nombres, j'ai utilisé la méthode round() jusqu'à 3 décimales et calculé la somme et la différence entre la valeur d'origine et la valeur arrondie.

Voici l'exemple et le résultat.

Exemple 1

import random

def truncate(num):
    return int(num * 1000) / 1000

arr = [random.uniform(0.01, 0.05) for _ in range(1000000)]
sum_num = 0
sum_truncate = 0
for i in arr:
    sum_num = sum_num + i  
    sum_truncate = truncate(sum_truncate + i)
  
print("Testing by using truncating upto 3 decimal places")
print("The original sum is = ", sum_num)
print("The total using truncate = ", sum_truncate)
print("The difference from original - truncate = ", sum_num - sum_truncate)

print("\n\n")
print("Testing by using round() upto 3 decimal places")
sum_num1 = 0
sum_truncate1 = 0
for i in arr:
    sum_num1 = sum_num1 + i  
    sum_truncate1 = round(sum_truncate1 + i, 3)

print("The original sum is =", sum_num1)
print("The total using round = ", sum_truncate1)
print("The difference from original - round =", sum_num1 - sum_truncate1)

Sortie :

Testing by using truncating upto 3 decimal places
The original sum is =  29985.958619386867
The total using truncate =  29486.057
The difference from original - truncate =  499.9016193868665

Testing by using round() up to 3 decimal places
The original sum is = 29985.958619386867
The total using round =  29985.912
The difference from original - round = 0.04661938686695066

La différence entre la valeur originale et la valeur tronquée est de 499.9016193868665, et d'après round(), elle est de 0.04661938686695066.

La différence semble très importante, et l'exemple montre comment la méthode round() permet d'obtenir des calculs d'une précision quasi parfaite.

Exemple : arrondi flottant Numbers

Dans ce programme, nous verrons comment fonctionne l'arrondi des nombres à virgule flottante.

# testing round()

float_num1 = 10.60 # here the value will be rounded to 11 as after the decimal point the number is 6 that is >5

float_num2 = 10.40 # here the value will be rounded to 10 as after the decimal point the number is 4 that is <=5

float_num3 = 10.3456 # here the value will be 10.35 as after the 2 decimal points the value >=5

float_num4 = 10.3445 #here the value will be 10.34 as after the 2 decimal points the value is <5

print("The rounded value without num_of_decimals is :", round(float_num1))
print("The rounded value without num_of_decimals is :", round(float_num2))
print("The rounded value with num_of_decimals as 2 is :", round(float_num3, 2))
print("The rounded value with num_of_decimals as 2 is :", round(float_num4, 2))

Sortie :

The rounded value without num_of_decimals is : 11
The rounded value without num_of_decimals is : 10
The rounded value with num_of_decimals as 2 is : 10.35
The rounded value with num_of_decimals as 2 is : 10.34

Exemple : arrondir des valeurs entières

Si vous utilisez round() sur une valeur entière, il vous renverra simplement le nombre sans aucune modification.

# testing round() on a integer

num = 15

print("The output is", round(num))

Sortie :

The output is 15

Exemple : Arrondir sur le négatif Numbers

Voyons quelques exemples illustrant le fonctionnement de l'arrondi des nombres négatifs.

# testing round()

num = -2.8
num1 = -1.5
print("The value after rounding is", round(num))
print("The value after rounding is", round(num1))

Sortie :

C:\pythontest>python testround.py
The value after rounding is -3
The value after rounding is -2

Exemple : Arrondir les tableaux NumPy

Comment arrondir NumPy ? tableaux dans Python?

Pour résoudre ce problème, nous pouvons utiliser le module NumPy et la méthode numpy.round() ou numpy.around(), comme illustré dans l'exemple ci-dessous.

Utiliser numpy.round()

# testing round()
import numpy as np

arr = [-0.341111, 1.455098989, 4.232323, -0.3432326, 7.626632, 5.122323]

arr1 = np.round(arr, 2)

print(arr1)

Sortie :

C:\pythontest>python testround.py
[-0.34  1.46  4.23 -0.34  7.63  5.12]

On peut également utiliser numpy.around(), qui donne le même résultat que numpy.round() présenté ci-dessus.

Exemple : module décimal

En plus de la fonction round(), Python possède un module décimal qui permet de gérer les nombres décimaux avec plus de précision.

Le module Décimal propose différents types d'arrondi, comme indiqué ci-dessous :

• PLAFOND_ROND : Elle tendra vers l'infini.
• ARRONDI_INF : Elle arrondira la valeur vers zéro.
• SOL_ROND : Elle s'arrondira vers -infini.
• ARRONDI_MIDI_INFÉRIEUR : Elle sera arrondie à la valeur la plus proche de zéro.
• ARRONDI_MIDI_PAIR : Elle sera arrondie à la valeur la plus proche, en arrondissant à l'entier pair le plus proche.
• ARRONDI_MIDI_SUP : Elle sera arrondie à la valeur la plus proche, en s'éloignant de zéro.
• ARRONDI_UP : L'arrondi se fera lorsque la valeur s'éloignera de zéro.

En décimal, la méthode quantize() permet d'arrondir à un nombre fixe de décimales, et vous pouvez spécifier l'arrondi à utiliser, comme le montre l'exemple ci-dessous.

Exemple : Utilisation des méthodes round() et décimales

import  decimal
round_num = 15.456

final_val = round(round_num, 2)

#Using decimal module
final_val1 = decimal.Decimal(round_num).quantize(decimal.Decimal('0.00'), rounding=decimal.ROUND_CEILING)
final_val2 = decimal.Decimal(round_num).quantize(decimal.Decimal('0.00'), rounding=decimal.ROUND_DOWN)
final_val3 = decimal.Decimal(round_num).quantize(decimal.Decimal('0.00'), rounding=decimal.ROUND_FLOOR)
final_val4 = decimal.Decimal(round_num).quantize(decimal.Decimal('0.00'), rounding=decimal.ROUND_HALF_DOWN)
final_val5 = decimal.Decimal(round_num).quantize(decimal.Decimal('0.00'), rounding=decimal.ROUND_HALF_EVEN)
final_val6 = decimal.Decimal(round_num).quantize(decimal.Decimal('0.00'), rounding=decimal.ROUND_HALF_UP)
final_val7 = decimal.Decimal(round_num).quantize(decimal.Decimal('0.00'), rounding=decimal.ROUND_UP)

print("Using round()", final_val)
print("Using Decimal - ROUND_CEILING ",final_val1)
print("Using Decimal - ROUND_DOWN ",final_val2)
print("Using Decimal - ROUND_FLOOR ",final_val3)
print("Using Decimal - ROUND_HALF_DOWN ",final_val4)
print("Using Decimal - ROUND_HALF_EVEN ",final_val5)
print("Using Decimal - ROUND_HALF_UP ",final_val6)
print("Using Decimal - ROUND_UP ",final_val7)

Sortie :

Using round() 15.46
Using Decimal - ROUND_CEILING  15.46
Using Decimal - ROUND_DOWN  15.45
Using Decimal - ROUND_FLOOR  15.45
Using Decimal - ROUND_HALF_DOWN  15.46
Using Decimal - ROUND_HALF_EVEN  15.46
Using Decimal - ROUND_HALF_UP  15.46
Using Decimal - ROUND_UP  15.46

FAQ