Python função round() com EXEMPLOS
Rodada ()
Round() é uma função integrada disponível com python. Ele retornará um número flutuante que será arredondado para as casas decimais fornecidas como entrada.
Se não forem especificadas as casas decimais a serem arredondadas, será considerado 0 e será arredondado para o número inteiro mais próximo.
Sintaxe
round(float_num, num_of_decimals)
parâmetros
- float_num: o número flutuante a ser arredondado.
- num_of_decimals: (opcional) O número de casas decimais a serem consideradas no arredondamento. É opcional e, se não for especificado, o padrão é 0 e o arredondamento é feito para o número inteiro mais próximo.
Descrição
O método round() leva dois argumentos
- o número a ser arredondado e
- as casas decimais que deve considerar no arredondamento.
O segundo argumento é opcional e o padrão é 0 quando não especificado e, nesse caso, será arredondado para o número inteiro mais próximo e o tipo de retorno também será um número inteiro.
Quando as casas decimais, ou seja, o segundo argumento, estiverem presentes, ele será arredondado para o número de casas indicado. O tipo de retorno será float.
Se o número após a casa decimal fornecida
- >=5 do que + 1 será adicionado ao valor final
- <5 do que o valor final retornará, pois está até as casas decimais mencionadas.
Valor de retorno
Ele retornará um valor inteiro se num_of_decimals não for fornecido e um valor flutuante se num_of_decimals for fornecido. Observe que o valor será arredondado para +1 se o valor após a vírgula decimal for> = 5, caso contrário, ele retornará o valor até as casas decimais mencionadas.
Quanto impacto o arredondamento pode ter? (Arredondamento vs Truncamento)
O melhor exemplo para mostrar o impacto do arredondamento é o do mercado de ações. No passado, ou seja, no ano de 1982, o Bolsa de Valores de Vancouver (VSE): usado para truncar os valores das ações para três casas decimais em cada negociação.
Isso foi feito quase 3000 vezes todos os dias. Os truncamentos acumulados levam a uma perda de cerca de 25 pontos por mês.
Um exemplo de truncamento de valores versus arredondamento é mostrado abaixo.
Considere os números de ponto flutuante gerados abaixo como valores de ações. No momento estou gerando isso para uma série de
1,000,000 segundos entre 0.01 e 0.05.
Exemplos:
arr = [random.uniform(0.01, 0.05) for _ in range(1000000)]
Para mostrar o impacto do arredondamento, escrevi um pequeno trecho de código onde, inicialmente, você precisa usar os números com apenas 3 casas decimais, ou seja, truncando o número após 3 casas decimais.
Tenho o valor total original, o total proveniente dos valores truncados e a diferença entre o valor original e o valor truncado.
No mesmo conjunto de números, tenho usado o método round() com até 3 casas decimais e calculado a soma e a diferença entre o valor original e o valor arredondado.
Aqui estão o exemplo e a saída
Exemplo 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)
Saída:
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
A diferença entre o original e após o truncamento é 499.9016193868665, e do redondo é 0.04661938686695066
A diferença parece ser muito grande, e o exemplo mostra como o método round() ajuda no cálculo próximo da precisão.
Exemplo: Arredondamento Flutuante Numbers
Neste programa, veremos como arredondar palavras em números flutuantes
# 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))
Saída:
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
Exemplo: arredondamento de valores inteiros
Se acontecer de você usar round() em um valor inteiro, ele apenas retornará o número sem nenhuma alteração.
# testing round() on a integer num = 15 print("The output is", round(num))
Saída:
The output is 15
Exemplo: Arredondamento em Negativo Numbers
Vejamos alguns exemplos de como funciona o arredondamento em 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))
Saída:
C:\pythontest>python testround.py The value after rounding is -3 The value after rounding is -2
Exemplo: matrizes numpy redondas
Como arredondar numpy matrizes em python?
Para resolver isso, podemos usar o módulo numpy e usar o método numpy.round() ou numpy.around(), conforme mostrado no exemplo abaixo.
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)
Saída:
C:\pythontest>python testround.py [-0.34 1.46 4.23 -0.34 7.63 5.12]
Também podemos usar numpy.around(), que fornece o mesmo resultado mostrado no exemplo abaixo.
Exemplo: Módulo Decimal
Além da função round(), python possui um módulo decimal que auxilia no tratamento de números decimais com mais precisão.
O módulo Decimal vem com tipos de arredondamento, conforme mostrado abaixo:
- ROUND_CEILING: irá arredondar em direção ao infinito,
- ROUND_DOWN: arredondará o valor para zero,
- ROUND_FLOOR: irá arredondar em direção a -Infinity,
- ROUND_HALF_DOWN: irá arredondar para o valor mais próximo indo em direção a zero,
- ROUND_HALF_EVEN: irá arredondar para o mais próximo com o valor indo para o número inteiro par mais próximo,
- ROUND_HALF_UP: irá arredondar para o mais próximo com o valor saindo de zero
- ROUND_UP: irá arredondar onde o valor sairá de zero.
Em decimal, o método quantize() ajuda a arredondar para um número fixo de casas decimais, e você pode especificar o arredondamento a ser usado, conforme mostrado no exemplo abaixo.
Exemplo:
Usando métodos round() e decimais
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)
Saída:
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
Resumo
- Round(float_num, Num_of_decimals) é uma função integrada disponível com python. Ele retornará o número flutuante que será arredondado para as casas decimais fornecidas como entrada.
- float_num: o número flutuante a ser arredondado.
- Num_of_decimals: É o número de casas decimais a serem consideradas no arredondamento.
- Ele retornará um valor inteiro se num_of_decimals não for fornecido e um valor flutuante se num_of_decimals for fornecido.