¿Cómo redondear a 2 decimales con Python?

Estoy obteniendo muchos decimales en la salida de este código (convertidor de Fahrenheit a Celsius).

Mi código actualmente se ve así:

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

Entonces mi pregunta es, ¿cómo hago para que el programa redondee cada respuesta al segundo decimal?

Puede usar la roundfunción, que toma como primer argumento el número y el segundo argumento es la precisión después del punto decimal.

En su caso, sería:

answer = str(round(answer, 2))

Usando str.format()la sintaxis para mostrar answer con dos decimales (sin alterar el valor subyacente de answer):

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

Dónde:

• :introduce la especificación de formato
• 0 habilita el relleno de cero con signo para los tipos numéricos
• .2establece la precisión en2
• f muestra el número como un número de punto fijo

La mayoría de las respuestas sugeridas roundo format. rounda veces se redondea y, en mi caso, necesitaba que el valor de mi variable se redondeara hacia abajo y no solo se mostrara como tal.

round(2.357, 2)  # -> 2.36

Encontré la respuesta aquí: ¿Cómo redondeo un número de coma flotante hasta cierto lugar decimal?

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

o:

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

Quieres redondear tu respuesta.

round(value,significantDigit)es la solución ordinaria para hacer esto, sin embargo, esto a veces no funciona como cabría esperar desde una perspectiva matemática cuando el dígito inmediatamente inferior (a la izquierda de) el dígito que está redondeando tiene un 5.

Aquí hay algunos ejemplos de este comportamiento impredecible:

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

Suponiendo que su intención es hacer el redondeo tradicional para las estadísticas en las ciencias, este es un útil contenedor para que la roundfunción funcione como se espera y necesita importcosas adicionales como Decimal.

>>> round(0.075,2)

0.07

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

0.08

¡Ajá! Entonces, en base a esto, podemos hacer una función ...

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

Básicamente, esto agrega un valor realmente pequeño a la cadena para obligarla a redondearse correctamente en las instancias impredecibles donde normalmente no roundfunciona con la función cuando lo espera. Un valor conveniente para agregar es 1e-Xdónde Xestá la longitud de la cadena de números que está tratando de usar rounden más 1.

El enfoque de uso 10**(-len(val)-1)fue deliberado, ya que es el número pequeño más grande que puede agregar para forzar el cambio, al tiempo que garantiza que el valor que agregue nunca cambie el redondeo, incluso si .falta el decimal . Podría usar solo 10**(-len(val))con una condición if (val>1)para restar 1más ... pero es más simple restar siempre, 1ya que eso no cambiará mucho el rango aplicable de números decimales que esta solución puede manejar adecuadamente. Este enfoque fallará si sus valores alcanzan los límites del tipo, fallará, pero para casi todo el rango de valores decimales válidos debería funcionar.

Entonces el código terminado será algo así 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()

... debería darte los resultados que esperas.

También puede usar la biblioteca decimal para lograr esto, pero el contenedor que propongo es más simple y puede preferirse en algunos casos.

Editar: Gracias Blckknght por señalar que el 5caso marginal ocurre solo para ciertos valores aquí .

Simplemente use el formato con% .2f que le da redondeo a 2 decimales.

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

Puede usar el operador de formato de cadena de python "%". "% .2f" significa 2 dígitos después del punto 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

Puede usar el operador redondo para hasta 2 decimales

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

Puedes usar la función redonda.

round(80.23456, 3)

le dará una respuesta de 80.234

En su caso, use

answer = str(round(answer, 2))

Espero que esto ayude :)

Si necesita evitar el problema de punto flotante en los números de redondeo para la contabilidad, puede usar numpy round.

Necesitas instalar numpy:

pip install numpy

y el código:

import numpy as np

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

huellas dactilares

2.67
2.68

Debería usar eso si administra dinero con redondeo legal.

Aquí hay un ejemplo que usé:

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)

No estoy seguro de por qué, pero el formato '{: 0.2f}'. (0.5357706) me da '0.54'. La única solución que funciona para mí (python 3.6) es la siguiente:

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 desea su respuesta en número decimal, no necesita escribir su variable de respuesta para str en la función printC ().

y luego use el formato de cadena de estilo printf

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

La respuesta es de: https://stackoverflow.com/a/29651462/8025086