Redondo ()
Round () es una función incorporada disponible con python. Devolverá un número flotante para redondear a los lugares decimales dados como entrada.
Si no se especifican los lugares decimales a redondear, se consideran 0 y se redondean al número entero más cercano.
En este tutorial de Python, aprenderá:
Sintaxis:
round(float_num, num_of_decimals)
Parámetros
- float_num: el número flotante para redondear.
- num_of_decimals: (opcional) Número de decimales a considerar al redondear. Es opcional y, si no se especifica, falla a 0 y se redondea al número entero más cercano.
Suelte
El método round () asume dos argumentos
- el número a redondear y
- los lugares decimales que debe considerar al redondear.
El segundo argumento es opcional y falla 0 cuando no se especifica, en cuyo caso se redondeará al número entero más cercano, y el tipo de retorno también será un entero.
Cuando están presentes los lugares decimales, es decir, el segundo argumento, se redondea el número de lugares dados. El tipo de retorno será flotante.
Si se da el número después del lugar decimal
- = = 5 o +1 se agregará al valor final
- <5 no devuelve el valor final ya que está hasta los lugares decimales indicados.
Valor devuelto
Devolverá un valor entero si no se da el núm_de_decimales y un valor flotante si se da el núm_de_decimales. Tenga en cuenta que el valor se redondeará a +1 si el valor después del otro punto decimal> = 5 devolverá el valor, ya que está hasta los lugares decimales indicados.
¿Cuánto impacto puede tener la salvación? (Salvación versus truncamiento)
El mejor ejemplo para mostrar el impacto del equilibrio es para el mercado de valores. En el pasado, es decir, en 1982, la Bolsa de valores de Vancouver (VSE): se utiliza para truncar los valores de las acciones a tres decimales en cada operación.
Se hizo casi 3000 veces al día. Aproximadamente se pierden 25 puntos por mes debido a los baúles acumulados.
A continuación se muestra un ejemplo de los valores contra el redondeo de acortamiento.
Piense en los números flotantes generados a continuación como valores de acciones. Ahora lo estoy generando para un rango de
1,000,000 segundos entre 0.01 y 0.05.
Ejemplos:
arr = [random.uniform(0.01, 0.05) for _ in range(1000000)]
Para mostrar el efecto del redondeo, escribí un pequeño fragmento de código y primero tienes que usar los números hasta 3 lugares decimales, es decir, truncar el número después de 3 lugares decimales.
Tengo el valor total original, el total procedente de valores truncados y la diferencia entre el valor original y el valor truncado.
En el mismo conjunto de números, estaba usando el método exacto () hasta 3 lugares decimales al calcular la suma y la diferencia entre el valor original y el valor exacto.
Aquí está el ejemplo y la salida
Ejemplo 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("nn")
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)
Producción:
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 truncado original y después del truncado es 499.9016193868665, y desde la ronda, es 0.04661938686695066
La diferencia parece ser muy grande y el ejemplo muestra cómo redondear () lo que ayuda a calcular con precisión.
Ejemplo: redondeo de números flotantes
En este programa, veremos cómo redondear palabras a números flotantes.
# 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))
Producción:
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: redondeo de valores enteros
Si usa round () en un valor entero, solo le devolverá el número sin ningún cambio.
# testing round() on a integer
num = 15
print("The output is", round(num))
Producción:
The output is 15
Ejemplo: redondeo de números negativos
No veamos muchos ejemplos de cómo funciona el redondeo en 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))
Producción:
C:pythontest>python testround.py The value after rounding is -3 The value after rounding is -2
Ejemplo: matrices redondas
¿Cómo asegurar matrices numpy en Python?
Para resolver esto, podemos usar el módulo numpy y usar el método numpy.round () o numpy.around (), como se muestra en el siguiente ejemplo.
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)
Producción:
C:pythontest>python testround.py [-0.34 1.46 4.23 -0.34 7.63 5.12]
También podemos usar numpy.around (), que le da el mismo resultado que se muestra en el siguiente ejemplo.
Ejemplo: módulo decimal
Además de la función round (), Python tiene un módulo decimal que ayuda a manejar números decimales de una manera más precisa.
El módulo Decimal viene con tipos de redondeo, como se muestra a continuación:
- ROUND_CEILING: correrá hacia Infinity,
- ROUND_DOWN: redondea el valor a cero,
- ROUND_FLOOR: va a -Infinity,
- ROUND_HALF_DOWN: redondea al valor más cercano que va a cero,
- ROUND_HALF_EVEN: pasará al más cercano y el valor irá incluso al número entero más cercano,
- ROUND_HALF_UP: da la vuelta al más cercano con un valor que se desvía de cero
- ROUND_UP: asegura dónde va el valor desde cero.
En decimal, el método de cuantificación () 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)
Producción:
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
Resumen:
- Un round (float_num, Num_of_decimals) es una función incorporada disponible con python. Le devolverá el número flotante redondeado a los lugares decimales dados como entrada.
- float_num: el número flotante para redondear.
- Num_of_decimals: el número de decimales a considerar al redondear.
- Devolverá un valor entero si no se da el núm_de_decimales y un valor flotante si se da el núm_de_decimales.