Python Fonction round() avec des EXEMPLES

Rond ()

Round() est une fonction intégrée disponible avec python. Il vous renverra un nombre flottant qui sera arrondi aux décimales données 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

• float_num : le nombre flottant à arrondir.
• num_of_decimals : (facultatif) Le nombre de décimales à prendre en compte lors de l'arrondi. Il est facultatif et s'il n'est pas spécifié, sa 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 la valeur par défaut est 0 lorsqu'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 nombre après la décimale indiqué

• >=5 que + 1 sera ajouté à la valeur finale
• <5 que la valeur finale sera renvoyée telle qu'elle correspond aux décimales mentionnées.

Valeur de retour

Il renverra une valeur entière si le num_of_decimals n'est pas donné et une valeur flottante si le num_of_decimals est donné. Veuillez noter que la valeur sera arrondie à +1 si la valeur après la virgule est >=5, sinon elle renverra la valeur telle qu'elle est jusqu'aux décimales mentionnées.

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

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

Cela se faisait près de 3000 25 fois par jour. Les troncatures accumulées entraînent une perte d'environ 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. En ce moment, je le génère pour une gamme de

1,000,000 0.01 0.05 de secondes entre et .

Exemples :

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

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

J'ai la valeur totale d'origine, le total provenant des valeurs tronquées et la différence entre la valeur d'origine et la valeur tronquée.

Sur le même ensemble de nombres, j'utilise la méthode round() jusqu'à 3 décimales et calcule 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 l'original et après troncature est de 499.9016193868665, et celle du rond est de 0.04661938686695066.

La différence semble être très grande, et l'exemple montre comment la méthode round() aide à calculer avec une précision proche.

Exemple : arrondi flottant Numbers

Dans ce programme, nous verrons comment arrondir les mots sur des nombres flottants

# 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 de la façon dont fonctionne l'arrondi sur 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 : tableaux Numpy ronds

Comment arrondir numpy tableaux en python?

Pour résoudre ce problème, nous pouvons utiliser le module numpy et utiliser la méthode numpy.round() ou numpy.around(), comme le montre 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]

Nous pouvons également utiliser numpy.around(), qui vous donne le même résultat que celui indiqué dans l'exemple ci-dessous.

Exemple : module décimal

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

Le module Decimal est livré avec des types d'arrondi, comme indiqué ci-dessous :

• ROUND_CEILING : il arrondira vers l'Infini,
• ROUND_DOWN : il arrondira la valeur vers zéro,
• ROUND_FLOOR : il arrondira vers -Infini,
• ROUND_HALF_DOWN : il arrondira à la valeur la plus proche en allant vers zéro,
• ROUND_HALF_EVEN : il arrondira au plus proche avec la valeur allant à l'entier pair le plus proche,
• ROUND_HALF_UP : il arrondira au plus proche avec une valeur s'éloignant de zéro
• ROUND_UP : il arrondira là où 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

Résumé

• Round(float_num, Num_of_decimals) est une fonction intégrée disponible avec python. Il vous renverra le nombre flottant qui sera arrondi aux décimales données en entrée.
• float_num : le nombre flottant à arrondir.
• Num_of_decimals : C'est le nombre de décimales à prendre en compte lors de l'arrondi.
• Il renverra une valeur entière si le num_of_decimals n'est pas donné et une valeur flottante si le num_of_decimals est donné.