Fonction Python round() avec EXEMPLES

Rond()

Round() est une fonction intégrée disponible avec python. Il vous renverra un nombre flottant qui sera arrondi aux décimales qui sont données en entrée.

Si les décimales à arrondir ne sont pas spécifiées, elles sont considérées comme 0 et arrondies à l'entier le plus proche.

Dans ce tutoriel Python, vous apprendrez :

Rond()
Syntaxe :
Quel impact l'arrondi peut-il avoir ? (Arrondi vs Troncature)
Exemple :Arrondir les nombres flottants
Exemple :arrondir des valeurs entières
Exemple :Arrondir des nombres négatifs
Exemple :Arrondir les tableaux numpy
Exemple :module décimal

Syntaxe :

round(float_num, num_of_decimals)

Paramètres

float_num :le nombre flottant à arrondir.
num_of_decimals :(optionnel) 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 prend par défaut la valeur 0 lorsqu'il n'est pas spécifié. Dans ce cas, il arrondira à 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, elles arrondiront au nombre de décimales donné. Le type de retour sera un flottant.

Si le nombre après la décimale indiqué

>=5 que + 1 seront ajoutés à la valeur finale
<5 que la valeur finale sera renvoyée, car elle ne dépasse pas les 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 vs Troncature)

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

Cela a été fait près de 3000 fois par jour. Les troncatures accumulées entraînent 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 de stock. En ce moment, je le génère pour une gamme de

1 000 000 secondes entre 0,01 et 0,05.

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, au début, vous devez utiliser les nombres jusqu'à seulement 3 décimales, c'est-à-dire tronquer 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'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 l'original et après la troncation est de 499,9016193868665, et de rond, elle 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 :Arrondir les nombres flottants

Dans ce programme, nous verrons comment arrondir des 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

S'il vous arrive d'utiliser 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 des nombres négatifs

Voyons quelques exemples de la façon dont l'arrondi fonctionne sur les 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 :Array Numpy Arrays

Comment arrondir les tableaux numpy 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 indiqué 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]

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 a un module décimal qui aide à 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 s'arrondira vers l'infini,
ROUND_DOWN :cela arrondira la valeur vers zéro,
ROUND_FLOOR :il s'arrondira vers -Infinity,
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 indiqué dans l'exemple ci-dessous.

Exemple :

Utilisation des méthodes round() et decimal

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 qui sont 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é.

Fonction Python abs() :Exemples de valeurs absolues Python range() Fonction :Float, List, For loop Exemples

Python