Hoe rond je af op 2 decimalen met Python?

Ik krijg veel decimalen in de uitvoer van deze code (omzetter van Fahrenheit naar Celsius).

Mijn code ziet er momenteel zo uit:

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

Dus mijn vraag is, hoe kan ik ervoor zorgen dat het programma elk antwoord op de 2e decimaal afrondt?


Antwoord 1, autoriteit 100%

U kunt de functie round gebruiken, die als eerste argument het getal neemt en als tweede argument de precisie achter de komma.

In jouw geval zou dat zijn:

answer = str(round(answer, 2))

Antwoord 2, autoriteit 20%

str.format()‘s syntaxis om weer te geven answer met twee decimalen (zonder de onderliggende waarde van answer te wijzigen):

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

Waar:

  • : introduceert de formaatspecificatie
  • 0 maakt sign-aware zero-padding voor numerieke typen mogelijk
  • .2 stelt de precisie tot 2
  • f geeft het nummer weer als een getal met een vaste komma

Antwoord 3, autoriteit 9%

De meeste antwoorden suggereerden round of format. round rondt soms naar boven af, en in mijn geval moest ik de waarde van mijn variabele naar beneden afronden en niet alleen als zodanig weergeven.

round(2.357, 2)  # -> 2.36

Ik heb het antwoord hier gevonden: Hoe rond ik een getal met drijvende komma af tot een bepaalde decimale plaats?

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

of:

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

Antwoord 4, autoriteit 3%

Als u alleen het afgeronde resultaat wilt afdrukken, kunt u de f- strings ge├»ntroduceerd sinds Python 3.6. De syntaxis is hetzelfde als str.format()‘s syntaxis voor tekenreeksen, behalve dat je een f voor de letterlijke tekenreeks plaatst, en je de variabelen direct in de tekenreeks plaatst, tussen de accolades.

.2f geeft afronding op twee decimalen aan:

number = 3.1415926
print(f"The number rounded to two decimal places is {number:.2f}")

Uitvoer:

The number rounded to two decimal places is 3.14

Antwoord 5, autoriteit 2%

U wilt uw antwoord afronden.

round(value,significantDigit) is de gebruikelijke oplossing om dit te doen, maar dit soms werkt niet zoals men zou verwachten van een wiskundig perspectief wanneer het cijfer dat direct lager is dan (links van) het cijfer waarnaar u afrondt een 5 heeft.

Hier zijn enkele voorbeelden van dit onvoorspelbare gedrag:

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

Ervan uitgaande dat het uw bedoeling is om de traditionele afronding voor statistieken in de wetenschappen te doen, is dit een handige wrapper om de functie round te laten werken zoals verwacht, waarbij u extra dingen moet import zoals Decimal.

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

Aha! Dus op basis hiervan kunnen we een functie maken…

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

Dit voegt in feite een heel kleine waarde toe aan de tekenreeks om deze te dwingen correct af te ronden in de onvoorspelbare gevallen waar het normaal gesproken niet gebeurt met de functie round wanneer u dit verwacht. Een handige waarde om toe te voegen is 1e-X waarbij X de lengte is van de cijferreeks die u probeert te gebruiken round op plus 1.

De benadering van het gebruik van 10**(-len(val)-1) was opzettelijk, aangezien dit het grootste kleine getal is dat u kunt toevoegen om de verschuiving te forceren, terwijl u er tegelijkertijd voor zorgt dat de waarde die u add verandert nooit de afronding, zelfs niet als de decimale . ontbreekt. Ik zou gewoon 10**(-len(val)) kunnen gebruiken met een voorwaarde if (val>1) om 1 meer af te trekken.. maar het is eenvoudiger om altijd de 1 af te trekken, omdat dat niet veel zal veranderen aan het bereik van decimale getallen dat deze tijdelijke oplossing goed aankan. Deze benadering zal mislukken als uw waarden de limieten van het type bereiken, dit zal mislukken, maar voor bijna het hele bereik van geldige decimale waarden zou het moeten werken.

Dus de voltooide code ziet er ongeveer zo uit:

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

…moet u de resultaten geven die u verwacht.

Je kunt hiervoor ook de bibliotheek decimaal gebruiken, maar de wrapper Ik stel voor is eenvoudiger en kan in sommige gevallen de voorkeur hebben.


Bewerken: bedankt Blckknght voor het aangeven dat de 5 randgeval komt alleen voor bij bepaalde waarden hier.


Antwoord 6, autoriteit 2%

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

Antwoord 7, autoriteit 2%

Als u een probleem met drijvende komma moet vermijden bij het afronden van getallen voor de boekhouding, kunt u numpy round gebruiken.

Je moet numpy installeren:

pip install numpy

en de code :

import numpy as np
print(round(2.675, 2))
print(float(np.round(2.675, 2)))

afdrukken

2.67
2.68

U moet dat gebruiken als u geld beheert met juridische afronding.


Antwoord 8

U kunt de operator round gebruiken voor maximaal 2 decimalen

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

Antwoord 9

U kunt de ronde-functie gebruiken.

round(80.23456, 3)

geeft u een antwoord van 80.234

Gebruik in jouw geval

answer = str(round(answer, 2))

Antwoord 10

Gebruik gewoon de opmaak met %.2f, zodat u naar beneden kunt afronden op 2 decimalen.

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

Antwoord 11

U kunt de tekenreeksopmaakoperator van python “%” gebruiken.
“%.2f” betekent 2 cijfers achter de komma.

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


Antwoord 12

Als je niet alleen het resultaat wilt afronden, maar ook wiskundige bewerkingen met het ronde resultaat wilt doen, dan kun je decimal.Decimal https://docs.python.org/2/library/decimal.html

from decimal import Decimal, ROUND_DOWN
Decimal('7.325').quantize(Decimal('.01'), rounding=ROUND_DOWN)
Decimal('7.32') 

Antwoord 13

Hier is een voorbeeld dat ik heb gebruikt:

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)

Antwoord 14

Ik weet niet zeker waarom, maar ‘{:0.2f}’.format(0.5357706) geeft me ‘0.54’.
De enige oplossing die voor mij werkt (python 3.6) is de volgende:

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

Antwoord 15

Omdat u uw antwoord in decimale getallen wilt hebben, hoeft u uw variabele antwoord niet naar str in de functie printC() te typen.

en gebruik dan printf-style String Formatting


Antwoord 16

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

Het antwoord komt van: https://stackoverflow.com/a/29651462/8025086


Antwoord 17

Om verrassende waarde van round() te voorkomen, is dit mijn aanpak:

Round = lambda x, n: eval('"%.'+str(int(n))+'f" % '+repr(int(x)+round(float('.'+str(float(x)).split('.')[1]),n)))
print(Round(2, 2))       # 2.00
print(Round(2.675, 2))   # 2.68

LEAVE A REPLY

Please enter your comment!
Please enter your name here

twenty + 10 =

Other episodes