Fonction Python round () avec EXEMPLES

Table des matières:

Anonim

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, il est considéré comme 0 et arrondi à l'entier le plus proche.

Dans ce didacticiel Python, vous apprendrez:

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

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é, il vaut 0 par défaut 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 lorsqu'il n'est pas spécifié, et dans ce cas, il arrondira à l'entier le plus proche et le type de retour sera également un entier.

Lorsque la décimale, c'est-à-dire le deuxième argument, est présente, elle arrondira au nombre de places donné. Le type de retour sera un float.

Si le nombre après la décimale donnée

  • > = 5 que + 1 sera ajouté à la valeur finale
  • <5 que la valeur finale retournera car elle est jusqu'à la décimale mentionnée.

Valeur de retour

Il renverra une valeur entière si le num_of_decimals n'est pas donné et une valeur float si le num_of_decimals est donné. Veuillez noter que la valeur sera arrondie à +1 si la valeur après la virgule décimale 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'arrondissement 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 pour chaque transaction.

Cela était 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'arrondissement 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 de 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 bout 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 j'ai calculé la somme et la différence entre la valeur d'origine et la valeur arrondie.

Voici l'exemple et la sortie

Exemple 1

import randomdef truncate(num):return int(num * 1000) / 1000arr = [random.uniform(0.01, 0.05) for _ in range(1000000)]sum_num = 0sum_truncate = 0for i in arr:sum_num = sum_num + isum_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 = 0sum_truncate1 = 0for i in arr:sum_num1 = sum_num1 + isum_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)

Production:

Testing by using truncating upto 3 decimal placesThe original sum is = 29985.958619386867The total using truncate = 29486.057The difference from original - truncate = 499.9016193868665Testing by using round() up to 3 decimal placesThe original sum is = 29985.958619386867The total using round = 29985.912The difference from original - round = 0.04661938686695066

La différence entre l'original et après la troncature est de 499,9016193868665, et de ronde, elle est de 0,04661938686695066

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

Exemple: arrondir les nombres flottants

Dans ce programme, nous verrons comment arrondir les mots sur les 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 >5float_num2 = 10.40 # here the value will be rounded to 10 as after the decimal point the number is 4 that is <=5float_num3 = 10.3456 # here the value will be 10.35 as after the 2 decimal points the value >=5float_num4 = 10.3445 #here the value will be 10.34 as after the 2 decimal points the value is <5print("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))

Production:

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

Exemple: arrondir les 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 integernum = 15print("The output is", round(num))

Production:

The output is 15

Exemple: arrondi sur des nombres négatifs

Voyons quelques exemples du fonctionnement de l'arrondi sur les nombres négatifs

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

Production:

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

Exemple: tableaux Numpy arrondis

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.

Utilisation de numpy.round ()

# testing round()import numpy as nparr = [-0.341111, 1.455098989, 4.232323, -0.3432326, 7.626632, 5.122323]arr1 = np.round(arr, 2)print(arr1)

Production:

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 Décimal est livré avec des types d'arrondi, comme indiqué ci-dessous:

  • ROUND_CEILING: il tournera vers l'Infini,
  • ROUND_DOWN: il arrondira la valeur vers zéro,
  • ROUND_FLOOR: il arrondira vers -Infinity,
  • ROUND_HALF_DOWN: il arrondira à la valeur la plus proche 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 illustré dans l'exemple ci-dessous.

Exemple:

Utilisation des méthodes round () et decimal

import decimalround_num = 15.456final_val = round(round_num, 2)#Using decimal modulefinal_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)

Production:

Using round() 15.46Using Decimal - ROUND_CEILING 15.46Using Decimal - ROUND_DOWN 15.45Using Decimal - ROUND_FLOOR 15.45Using Decimal - ROUND_HALF_DOWN 15.46Using Decimal - ROUND_HALF_EVEN 15.46Using Decimal - ROUND_HALF_UP 15.46Using 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 float si le num_of_decimals est donné.