Jak zaokrąglić do 2 miejsc po przecinku za pomocą Pythona?

Otrzymuję wiele miejsc po przecinku w wyniku tego kodu (konwerter Fahrenheita na Celsjusza).

Mój kod obecnie wygląda następująco:

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

Więc moje pytanie brzmi: jak sprawić, by program zaokrąglał każdą odpowiedź do drugiego miejsca po przecinku?

Możesz użyć roundfunkcji, która jako pierwszy argument przyjmuje liczbę, a drugi argument to precyzja po przecinku.

W twoim przypadku byłoby to:

answer = str(round(answer, 2))

Korzystanie str.format()„s składni do wyświetlania answer z dwoma miejscami po przecinku (bez zmiany wartości podstawowej o answer):

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

Gdzie:

• :wprowadza specyfikację formatu
• 0 włącza znakowanie zerami dla typów numerycznych
• .2ustawia precyzję na2
• f wyświetla liczbę jako liczbę stałoprzecinkową

Większość odpowiedzi sugerowanych roundlub format. roundczasami zaokrągla w górę, aw moim przypadku potrzebowałem zaokrąglenia wartości mojej zmiennej, a nie tylko jej wyświetlania.

round(2.357, 2)  # -> 2.36

Znalazłem odpowiedź tutaj: jak zaokrąglić liczbę zmiennoprzecinkową do pewnego miejsca po przecinku?

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

lub:

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

Chcesz zaokrąglić swoją odpowiedź.

round(value,significantDigit)jest zwykłym rozwiązaniem tego problemu, jednak czasami nie działa to tak, jak można by się tego spodziewać z perspektywy matematycznej, gdy cyfra bezpośrednio gorsza (na lewo od) cyfry, którą zaokrąglasz, ma 5.

Oto kilka przykładów tego nieprzewidywalnego zachowania:

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

Zakładając, że Twoim celem jest wykonanie tradycyjnego zaokrąglania dla statystyk w nauce, jest to przydatne opakowanie, aby roundfunkcja działała zgodnie z oczekiwaniami i wymagała importdodatkowych rzeczy Decimal.

>>> round(0.075,2)

0.07

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

0.08

Aha! Na tej podstawie możemy wykonać funkcję ...

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

Zasadniczo dodaje to naprawdę niewielką wartość do łańcucha, aby zmusić go do poprawnego zaokrąglenia w górę w nieprzewidywalnych przypadkach, w których zwykle nie działa z roundfunkcją, gdy się tego spodziewasz. Wygodną wartością do dodania jest to, 1e-Xgdzie Xjest długość ciągu liczbowego, którego próbujesz użyć roundna plus 1.

Podejście polegające na użyciu 10**(-len(val)-1)było celowe, ponieważ jest to największa mała liczba, jaką można dodać, aby wymusić przesunięcie, jednocześnie zapewniając, że dodana wartość nigdy nie zmienia zaokrąglenia, nawet jeśli .brakuje dziesiętnego . Mógłbym użyć tylko 10**(-len(val))warunku, if (val>1)aby odjąć 1więcej ... ale łatwiej jest po prostu zawsze odjąć, 1ponieważ nie zmieni to zbytnio odpowiedniego zakresu liczb dziesiętnych, które to obejście może poprawnie obsłużyć. To podejście zakończy się niepowodzeniem, jeśli twoje wartości osiągną granice danego typu, to się nie powiedzie, ale dla prawie całego zakresu prawidłowych wartości dziesiętnych powinno działać.

Tak więc gotowy kod będzie podobny do:

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

... powinien dać oczekiwane rezultaty.

Aby to zrobić, możesz również użyć biblioteki dziesiętnej , ale proponuję opakowanie jest prostsze i może być preferowane w niektórych przypadkach.

Edit: Dzięki Blckknght dla wskazując, że 5sprawa frędzle występuje tylko dla pewnych wartości tutaj .

Wystarczy użyć formatowania z% .2f, co daje zaokrąglenie w dół do 2 miejsc po przecinku.

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

Możesz użyć operatora formatowania łańcucha w pythonie „%”. „% .2f” oznacza 2 cyfry po przecinku.

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

Można użyć operatora okrągłego z dokładnością do 2 miejsc po przecinku

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

Możesz użyć funkcji okrągłej.

round(80.23456, 3)

da ci odpowiedź 80.234

W twoim przypadku użyj

answer = str(round(answer, 2))

Jeśli chcesz uniknąć problemu z liczbą zmiennoprzecinkową przy zaokrąglaniu liczb do rozliczania, możesz użyć rundy numpy.

Musisz zainstalować numpy:

pip install numpy

i kod:

import numpy as np

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

odciski

2.67
2.68

Powinieneś tego użyć, jeśli zarządzasz pieniędzmi za pomocą legalnego zaokrąglania.

Oto przykład, którego użyłem:

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)

Nie jestem pewien dlaczego, ale format „{: 0.2f}” (0,5357706) daje mi „0,54”. Jedyne rozwiązanie, które działa dla mnie (python 3.6), jest następujące:

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

Jak chcesz swoją odpowiedź w liczbach dziesiętnych, więc nie musisz zapisywać zmiennej odpowiedzi do str w funkcji printC ().

a następnie użyj formatowania ciągów w stylu printf

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

Odpowiedź pochodzi z: https://stackoverflow.com/a/29651462/8025086