Python Función round() con EJEMPLOS

¿Qué es la función round() en Python?

Python round() es una función integrada disponible con Python. Devolverá un número decimal que se redondeará a la cantidad de cifras decimales que se proporcionen como entrada.

Si no se especifican los decimales a redondear, se considera como 0 y se redondeará al entero más cercano.

Sintaxis

round(float_num, num_of_decimals)

Parámetros

• número flotante: El número flotante que se va a redondear.
• número_de_decimales: (opcional) El número de decimales que se tendrán en cuenta al redondear. Es opcional y, si no se especifica, se toma el valor predeterminado de 0 y el redondeo se realiza al entero más cercano.

Mareas Ideales para Lecciones

El método round() toma dos argumentos:

• el número que se va a redondear y
• los decimales que debe considerar al redondear.

El segundo argumento es opcional y, si no se especifica, toma el valor 0 por defecto. En ese caso, se redondeará al entero más cercano y el tipo de retorno también será un entero.

Cuando los lugares decimales, es decir, el segundo argumento, estén presentes, se redondeará al número de lugares indicados. El tipo de retorno será flotante.

Si el número después del punto decimal dado es:

• Si es mayor o igual a 5, se añadirá +1 al valor final.
• < 5, entonces el valor final se devolverá tal cual, hasta el número de decimales mencionado.

Valor de retorno

Devolverá un valor entero si no se especifica el número de decimales y un valor decimal si se especifica. Tenga en cuenta que el valor se redondeará a +1 si el valor después del punto decimal es mayor o igual a 5; de lo contrario, devolverá el valor tal cual, hasta el número de decimales indicado.

¿Qué impacto puede tener el redondeo? (Redondeo versus truncamiento)

El mejor ejemplo para mostrar el impacto del redondeo es el mercado de valores. En el pasado, es decir, en el año 1982, el Bolsa de Valores de Vancouver (VSE) se utilizaba para truncar los valores de las acciones a tres decimales en cada transacción.

Se realizaba casi 3000 veces al día. Los recortes acumulados provocaron una pérdida de alrededor de 25 puntos al mes.

A continuación se muestra un ejemplo de truncamiento de valores versus redondeo.

Consideremos los números de coma flotante que se generan a continuación como valores de acciones. En este momento, los estoy generando para un intervalo de 1,000,000 de segundos entre 0.01 y 0.05.

Ejemplos:

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

Para mostrar el impacto del redondeo, he escrito un pequeño fragmento de código en el que, en primer lugar, se utilizan los números con hasta 3 decimales, es decir, se trunca el número después de 3 decimales.

Tengo el valor total original, el total resultante de los valores truncados y la diferencia entre el valor original y el valor truncado.

En el mismo conjunto de números, he utilizado el método round() hasta 3 decimales y he calculado la suma y la diferencia entre el valor original y el valor redondeado.

Aquí están el ejemplo y el resultado.

Ejemplo

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)

Salida:

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 diferencia entre el valor original y el truncado es 499.9016193868665, y de round(), es 0.04661938686695066.

La diferencia parece ser muy grande, y el ejemplo muestra cómo el método round() ayuda a calcular con una precisión casi perfecta.

Ejemplo: flotación de redondeo Numbers

En este programa, veremos cómo funciona el redondeo en números decimales.

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

Salida:

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

Ejemplo: redondear valores enteros

Si utiliza round() en un valor entero, simplemente le devolverá el número sin ningún cambio.

# testing round() on a integer

num = 15

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

Salida:

The output is 15

Ejemplo: redondeo a negativo Numbers

Veamos algunos ejemplos de cómo funciona el redondeo con números negativos.

# testing round()

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

Salida:

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

Ejemplo: Redondear matrices NumPy

¿Cómo se redondea NumPy? matrices en Python?

Para resolver esto, podemos utilizar el módulo NumPy y el método numpy.round() o numpy.around(), como se muestra en el ejemplo a continuación.

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)

Salida:

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

También podemos usar numpy.around(), que da el mismo resultado que numpy.round() mostrado anteriormente.

Ejemplo: módulo decimal

Además de la función round(), Python Tiene un módulo decimal que ayuda a manejar números decimales con mayor precisión.

El módulo Decimal incluye tipos de redondeo, como se muestra a continuación:

• TECHO REDONDO: girará hacia el infinito.
• REDONDEO HACIA ABAJO: redondeará el valor hacia cero.
• PISO REDONDO: Se redondeará hacia el -infinito.
• REDONDEO HACIA ABAJO: Se redondeará al valor más cercano a cero.
• RONDA_MITAD_PAR: Se redondeará al valor más cercano, llegando al entero par más próximo.
• REDONDEO_HACIA_MÁS: Se redondeará al valor más cercano alejándose de cero.
• REDONDEO: redondeará donde el valor se alejará de cero.

En decimal, el método quantize() ayuda a redondear a un número fijo de decimales y puede especificar el redondeo que se utilizará, como se muestra en el siguiente ejemplo.

Ejemplo: Usando métodos round() y 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)

Salida:

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

Preguntas Frecuentes