Como arredondar para 2 casas decimais com Python?

Estou recebendo muitas casas decimais na saída desse código (conversor de Fahrenheit para Celsius).

Meu código atualmente é assim:

def main():
    printC(formeln(typeHere()))

def typeHere():
    global Fahrenheit
    try:
        Fahrenheit = int(raw_input("Hi! Enter Fahrenheit value, and get it in Celsius!\n"))
    except ValueError:
        print "\nYour insertion was not a digit!"
        print "We've put your Fahrenheit value to 50!"
        Fahrenheit = 50
    return Fahrenheit

def formeln(c):
    Celsius = (Fahrenheit - 32.00) * 5.00/9.00
    return Celsius

def printC(answer):
    answer = str(answer)
    print "\nYour Celsius value is " + answer + " C.\n"



main()

Portanto, minha pergunta é: como faço para o programa arredondar todas as respostas para a segunda casa decimal?

Você pode usar a roundfunção, que usa como primeiro argumento o número e o segundo argumento é a precisão após o ponto decimal.

No seu caso, seria:

answer = str(round(answer, 2))

Usando str.format()a sintaxe para exibir answer com duas casas decimais (sem alterar o valor subjacente de answer):

def printC(answer):
    print("\nYour Celsius value is {:0.2f}ºC.\n".format(answer))

Onde:

• :apresenta a especificação de formato
• 0 permite preenchimento zero com reconhecimento de sinal para tipos numéricos
• .2define a precisão para2
• f exibe o número como um número de ponto fixo

A maioria das respostas sugeridas roundou format. roundàs vezes é arredondado para cima e, no meu caso, eu precisava que o valor da minha variável fosse arredondado para baixo e não apenas exibido como tal.

round(2.357, 2)  # -> 2.36

Encontrei a resposta aqui: Como arredondar um número de ponto flutuante até uma determinada casa decimal?

import math
v = 2.357
print(math.ceil(v*100)/100)  # -> 2.36
print(math.floor(v*100)/100)  # -> 2.35

ou:

from math import floor, ceil

def roundDown(n, d=8):
    d = int('1' + ('0' * d))
    return floor(n * d) / d

def roundUp(n, d=8):
    d = int('1' + ('0' * d))
    return ceil(n * d) / d

float(str(round(answer, 2)))
float(str(round(0.0556781255, 2)))

Você quer arredondar sua resposta.

round(value,significantDigit)é a solução comum para fazer isso, no entanto, às vezes, isso não funciona como seria de esperar de uma perspectiva matemática quando o dígito imediatamente inferior (à esquerda) ao dígito para o qual você está arredondando possui a 5.

Aqui estão alguns exemplos desse comportamento imprevisível:

>>> round(1.0005,3)
1.0
>>> round(2.0005,3)
2.001
>>> round(3.0005,3)
3.001
>>> round(4.0005,3)
4.0
>>> round(1.005,2)
1.0
>>> round(5.005,2)
5.0
>>> round(6.005,2)
6.0
>>> round(7.005,2)
7.0
>>> round(3.005,2)
3.0
>>> round(8.005,2)
8.01

Supondo que sua intenção seja fazer o arredondamento tradicional para estatísticas nas ciências, este é um invólucro útil para que a roundfunção funcione conforme o esperado, necessitando de importcoisas extras Decimal.

>>> round(0.075,2)

0.07

>>> round(0.075+10**(-2*6),2)

0.08

Aha! Então, com base nisso, podemos fazer uma função ...

def roundTraditional(val,digits):
   return round(val+10**(-len(str(val))-1), digits)

Basicamente, isso adiciona um valor muito pequeno à string para forçá-la a arredondar corretamente nas instâncias imprevisíveis em que ela normalmente não roundfunciona com a função quando você espera. Um valor conveniente a acrescentar é 1e-Xonde Xestá o comprimento da sequência numérica que você está tentando usar roundno plus 1.

A abordagem do uso 10**(-len(val)-1)foi deliberada, pois é o maior número pequeno que você pode adicionar para forçar a mudança, além de garantir que o valor adicionado nunca mude o arredondamento, mesmo que o decimal .esteja ausente. Eu poderia usar apenas 10**(-len(val))um condicional if (val>1)para subtrair 1mais ... mas é mais simples sempre subtrair o valor, 1pois isso não mudará muito o intervalo aplicável de números decimais que esta solução alternativa pode manipular adequadamente. Essa abordagem falhará se seus valores atingirem os limites do tipo, isso falhará, mas, para quase todo o intervalo de valores decimais válidos, deve funcionar.

Portanto, o código final será algo como:

def main():
    printC(formeln(typeHere()))

def roundTraditional(val,digits):
    return round(val+10**(-len(str(val))-1))

def typeHere():
    global Fahrenheit
    try:
        Fahrenheit = int(raw_input("Hi! Enter Fahrenheit value, and get it in Celsius!\n"))
    except ValueError:
        print "\nYour insertion was not a digit!"
        print "We've put your Fahrenheit value to 50!"
        Fahrenheit = 50
    return Fahrenheit

def formeln(c):
    Celsius = (Fahrenheit - 32.00) * 5.00/9.00
    return Celsius

def printC(answer):
    answer = str(roundTraditional(answer,2))
    print "\nYour Celsius value is " + answer + " C.\n"

main()

... deve fornecer os resultados esperados.

Você também pode usar a biblioteca decimal para fazer isso, mas o invólucro que proponho é mais simples e pode ser preferido em alguns casos.

Edit: Obrigado Blckknght por apontar que a 5caixa de franja ocorre apenas para determinados valores aqui .

Basta usar a formatação com% .2f, que permite arredondar para 2 casas decimais.

def printC(answer):
    print "\nYour Celsius value is %.2f C.\n" % answer

Você pode usar o operador de formatação de string do python "%". "% .2f" significa 2 dígitos após o ponto decimal.

def typeHere():
    try:
        Fahrenheit = int(raw_input("Hi! Enter Fahrenheit value, and get it in Celsius!\n"))
    except ValueError:
        print "\nYour insertion was not a digit!"
        print "We've put your Fahrenheit value to 50!"
        Fahrenheit = 50
    return Fahrenheit

def formeln(Fahrenheit):
    Celsius = (Fahrenheit - 32.0) * 5.0/9.0
    return Celsius

def printC(answer):
    print "\nYour Celsius value is %.2f C.\n" % answer

def main():
    printC(formeln(typeHere()))

main()

http://docs.python.org/2/library/stdtypes.html#string-formatting

Você pode usar o operador redondo para até 2 casas decimais

num = round(343.5544, 2)
print(num) // output is 343.55

Você pode usar a função round.

round(80.23456, 3)

lhe dará uma resposta de 80.234

No seu caso, use

answer = str(round(answer, 2))

Espero que isto ajude :)

Se você precisar evitar problemas de ponto flutuante nos números de arredondamento para contabilidade, poderá usar a arredondamento numpy.

Você precisa instalar o numpy:

pip install numpy

e o código:

import numpy as np

print(round(2.675, 2))
print(float(np.round(2.675, 2)))

impressões

2.67
2.68

Você deve usar isso se gerenciar dinheiro com arredondamento legal.

Aqui está um exemplo que eu usei:

def volume(self):
    return round(pi * self.radius ** 2 * self.height, 2)

def surface_area(self):
    return round((2 * pi * self.radius * self.height) + (2 * pi * self.radius ** 2), 2)

Não sei por que, mas o formato '{: 0.2f}'. (0,5357706) me fornece '0,54'. A única solução que funciona para mim (python 3.6) é a seguinte:

def ceil_floor(x):
    import math
    return math.ceil(x) if x < 0 else math.floor(x)

def round_n_digits(x, n):
    import math
    return ceil_floor(x * math.pow(10, n)) / math.pow(10, n)

round_n_digits(-0.5357706, 2) -> -0.53 
round_n_digits(0.5357706, 2) -> 0.53

Como você deseja sua resposta em número decimal, não precisa converter a variável de resposta em str na função printC ().

e use a formatação de seqüência de caracteres no estilo printf

round(12.3956 - 0.005, 2)  # minus 0.005, then round.

A resposta é de: https://stackoverflow.com/a/29651462/8025086