Python funzione round() con ESEMPI

Il giro ()

Round() è una funzione integrata disponibile con Python. Ti restituirà un numero float che verrà arrotondato alle cifre decimali fornite come input.

Se non vengono specificate le cifre decimali da arrotondare, il valore viene considerato pari a 0 e l'arrotondamento avviene all'intero più vicino.

Sintassi

round(float_num, num_of_decimals)

Scheda Sintetica

• float_num: il numero float da arrotondare.
• num_of_decimals: (facoltativo) Il numero di decimali da considerare durante l'arrotondamento. È facoltativo e, se non specificato, il valore predefinito è 0 e l'arrotondamento viene eseguito all'intero più vicino.

Descrizione

Il metodo round() accetta due argomenti

• il numero da arrotondare e
• le cifre decimali da considerare durante l'arrotondamento.

Il secondo argomento è facoltativo e, se non specificato, il suo valore predefinito è 0. In tal caso, verrà arrotondato all'intero più vicino e anche il tipo restituito sarà un intero.

Quando sono presenti le cifre decimali, ovvero il secondo argomento, verrà arrotondato al numero di cifre indicato. Il tipo restituito sarà float.

Se viene fornito il numero dopo la cifra decimale

• >=5 di + 1 verrà aggiunto al valore finale
• <5 rispetto al valore finale verrà restituito fino alle cifre decimali menzionate.

Valore di ritorno

Restituirà un valore intero se non viene fornito num_of_decimals e un valore float se viene fornito num_of_decimals. Tieni presente che il valore verrà arrotondato a +1 se il valore dopo il punto decimale è >=5 altrimenti restituirà il valore così com'è fino alle cifre decimali menzionate.

Quanto impatto può avere l'arrotondamento? (Arrotondamento vs troncamento)

L’esempio migliore per mostrare l’impatto dell’arrotondamento è quello del mercato azionario. In passato cioè nell'anno 1982, il Borsa di Vancouver (VSE): utilizzato per troncare i valori delle azioni a tre cifre decimali su ogni operazione.

È stato fatto quasi 3000 volte al giorno. I troncamenti accumulati comportano una perdita di circa 25 punti al mese.

Di seguito è riportato un esempio di troncamento dei valori rispetto all'arrotondamento.

Considera i numeri in virgola mobile generati di seguito come valori azionari. In questo momento lo sto generando per una serie di

1,000,000 di secondi tra 0.01 e 0.05.

Esempi:

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

Per mostrare l'impatto dell'arrotondamento, ho scritto un piccolo pezzo di codice in cui inizialmente è necessario utilizzare i numeri fino a sole 3 cifre decimali, ovvero troncare il numero dopo 3 cifre decimali.

Ho il valore totale originale, il totale proveniente dai valori troncati e la differenza tra valore originale e troncato.

Sullo stesso insieme di numeri, ho utilizzato il metodo round() fino a 3 cifre decimali e ho calcolato la somma e la differenza tra il valore originale e il valore arrotondato.

Ecco l'esempio e l'output
esempio 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)

Produzione:

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 differenza tra originale e dopo il troncamento è 499.9016193868665 e da rotondo è 0.04661938686695066

La differenza sembra essere molto grande e l'esempio mostra come il metodo round() aiuta a eseguire calcoli con una precisione prossima.

Esempio: arrotondamento mobile Numbers

In questo programma vedremo come arrotondare le parole sui numeri mobili

# 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))

Produzione:

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

Esempio: arrotondamento di valori interi

Se ti capita di usare round() su un valore intero, ti restituirà semplicemente il numero senza alcuna modifica.

# testing round() on a integer

num = 15

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

Produzione:

The output is 15

Esempio: arrotondamento al negativo Numbers

Vediamo alcuni esempi di come funziona l'arrotondamento sui numeri negativi

# testing round()

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

Produzione:

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

Esempio: array Numpy rotondi

Come arrotondare Numpy array in Python?

Per risolvere questo problema, possiamo utilizzare il modulo numpy e utilizzare il metodo numpy.round() o numpy.around(), come mostrato nell'esempio seguente.

Usando 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)

Produzione:

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

Possiamo anche utilizzare numpy.around(), che fornisce lo stesso risultato mostrato nell'esempio seguente.

Esempio: modulo decimale

Oltre alla funzione round(), Python ha un modulo decimal che aiuta a gestire i numeri decimali in modo più accurato.

Il modulo Decimal viene fornito con tipi di arrotondamento, come mostrato di seguito:

• ROUND_CEILING: girerà verso l'infinito,
• ROUND_DOWN: arrotonderà il valore verso lo zero,
• ROUND_FLOOR: ruoterà verso -Infinito,
• ROUND_HALF_DOWN: arrotonda al valore più vicino che si avvicina allo zero,
• ROUND_HALF_EVEN: arrotonda al valore più vicino con il valore che va all'intero pari più vicino,
• ROUND_HALF_UP: arrotonda al valore più vicino con un valore che si allontana da zero
• ROUND_UP: arrotonderà il punto in cui il valore si allontanerà da zero.

In decimale, il metodo quantize() aiuta ad arrotondare a un numero fisso di cifre decimali ed è possibile specificare l'arrotondamento da utilizzare, come mostrato nell'esempio seguente.
Esempio:
Utilizzando round() e metodi decimali

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)

Produzione:

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

Sintesi

• Round(float_num, Num_of_decimals) è una funzione integrata disponibile con Python. Ti restituirà il numero float che verrà arrotondato alle cifre decimali fornite come input.
• float_num: il numero float da arrotondare.
• Num_of_decimals: È il numero di decimali da considerare durante l'arrotondamento.
• Restituirà un valore intero se non viene fornito num_of_decimals e un valore float se viene fornito num_of_decimals.