Função Python round() com EXEMPLOS

Rodada()

Round() é uma função integrada disponível com python. Ele retornará um número float que será arredondado para as casas decimais que são fornecidas como entrada.

Se as casas decimais a serem arredondadas não forem especificadas, será considerado 0 e será arredondado para o inteiro mais próximo.

Neste Tutorial Python, você aprenderá:

Rodada()
Sintaxe:
Qual o impacto que o arredondamento pode ter? (Arredondamento x Truncamento)
Exemplo:arredondamento de números flutuantes
Exemplo:arredondamento de valores inteiros
Exemplo:arredondamento de números negativos
Exemplo:Arrays Numpy redondos
Exemplo:módulo decimal

Sintaxe:

round(float_num, num_of_decimals)

Parâmetros

float_num:o número float a ser arredondado.
num_of_decimals:(opcional) O número de decimais a ser considerado durante o arredondamento. É opcional e, se não especificado, o padrão é 0, e o arredondamento é feito para o inteiro mais próximo.

Descrição

O método round() recebe dois argumentos

o número a ser arredondado e
as casas decimais que devem ser consideradas durante o arredondamento.

O segundo argumento é opcional e o padrão é 0 quando não especificado e, nesse caso, ele será arredondado para o inteiro mais próximo e o tipo de retorno também será um inteiro.

Quando as casas decimais, ou seja, o segundo argumento, estiverem presentes, ele será arredondado para o número de casas fornecido. O tipo de retorno será um float.

Se o número após a casa decimal fornecida

>=5 que + 1 será adicionado ao valor final
<5 do que o valor final retornará, pois é até as casas decimais mencionadas.

Valor de retorno

Ele retornará um valor inteiro se o num_of_decimals não for fornecido e um valor float se o num_of_decimals for fornecido. Observe que o valor será arredondado para +1 se o valor após o ponto decimal for>=5, caso contrário, retornará o valor conforme é até as casas decimais mencionadas.

Qual o impacto que o arredondamento pode ter? (Arredondamento x Truncamento)

O melhor exemplo para mostrar o impacto do arredondamento é para o mercado de bolsa de valores. No passado, ou seja, no ano de 1982, a Bolsa de Valores de Vancouver (VSE):usada para truncar os valores das ações em três casas decimais em cada negociação.

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 truncar os valores versus arredondamento é mostrado abaixo.

Considere os números de ponto flutuante gerados abaixo como valores de ações. Agora estou gerando para uma variedade 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 pedaço de código em que, primeiro, você precisa usar os números até apenas 3 casas decimais, ou seja, truncar o número após 3 casas decimais.

Tenho o valor total original, o total vindo 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() até 3 casas decimais e calculando 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 original e após truncar é 499,9016193868665, e da rodada, é 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 de números flutuantes

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

Resultado:

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 de volta sem nenhuma alteração.

# testing round() on a integer

num = 15

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

Resultado:

The output is 15

Exemplo:arredondamento em números negativos

Vamos ver alguns exemplos de como o arredondamento funciona 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))

Resultado:

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

Exemplo:Arrays Numpy redondos

Como arredondar matrizes numpy 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)

Resultado:

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 ajuda a lidar com números decimais com mais precisão.

O módulo Decimal vem com tipos de arredondamento, conforme mostrado abaixo:

ROUND_CEILING:será arredondado em direção ao infinito,
ROUND_DOWN:arredondará o valor para zero,
ROUND_FLOOR:será arredondado para -Infinito,
ROUND_HALF_DOWN:arredondará para o valor mais próximo indo para zero,
ROUND_HALF_EVEN:será arredondado para o mais próximo com o valor indo para o inteiro par mais próximo,
ROUND_HALF_UP:será arredondado para o mais próximo com o valor saindo de zero
ROUND_UP: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 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)

Resultado:

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 float que será arredondado para as casas decimais fornecidas como entrada.
float_num:o número float a ser arredondado.
Num_of_decimals:é o número de decimais a ser considerado durante o arredondamento.
Ele retornará um valor inteiro se o num_of_decimals não for fornecido e um valor float se o num_of_decimals for fornecido.

Função Python abs():exemplos de valor absoluto Função range() do Python:Float, List, For loop Exemplos

python