Runde bis zur Zweiten Dezimalstelle in Python

Wie kann ich das Runden einer Zahl auf die zweite Nachkommastelle in python? Zum Beispiel:

0.022499999999999999

Sollte die Runde bis zu 0.03

0.1111111111111000

Sollte die Runde bis zu 0.12

Wenn es irgendeinen Wert in der Dritten Dezimalstelle, ich will es immer in der Runde und ließen mich 2 Werte hinter dem Komma.

InformationsquelleAutor user1202589 | 2012-02-10
  1. 48

    Python umfasst die round() Funktion, die können Sie angeben die Anzahl der Ziffern, die Sie wollen. Aus der Dokumentation:

    round(x[, n])

    Rückkehr der floating-point-Wert x, gerundet auf n Nachkommastellen. Wenn n weggelassen wird, wird standardmäßig null. Das Ergebnis ist eine Fließkommazahl. Werte gerundet auf das nächste Vielfache von 10 hoch minus n; wenn zwei Vielfache sind ebenso in der Nähe die Rundung erfolgt Weg von 0 (so. zum Beispiel, round(0.5) ist 1.0 und round(-0.5) ist -1.0).

    So würden Sie wollen, um round(x, 2) zum normalen Rundung. Um sicherzustellen, dass die Zahl immer gerundet bis müssten Sie die ceil(x) Funktion. Ebenso in Runde unten Verwendung floor(x).

    • Guter Vorschlag, aber es spielt keine Runde up wie der OP zu verlangen scheint.
    • "Round up" ist nicht das gleiche wie normale Rundung. An den Beispielen in der Frage.
    • Sie sind beide Recht-ich Editier jetzt.
    • Da das hinzufügen der genauen code zu tun ceil würde bedeuten, kopieren, deine Antwort lasse ich mir als (fast) ist und upvoting verkaufen.
    InformationsquelleAutor simchona
  2. 26
    from math import ceil

num = 0.1111111111000
num = ceil(num * 100) / 100.0

    Finden Sie unter:

    math.ceil - Dokumentation

    round - Dokumentation - Sie werden wahrscheinlich wollen, check this out, jedenfalls für zukünftige Referenz

    • Sie brauchen nicht round() hier-es ändert nicht das Ergebnis in keiner Weise.
    • Gibt falsche Ergebnisse in folgenden Fällen: math.ceil((1.11 * 100.0)) / 100.0 kommt heraus 1.12 Weil: 1.11 * 100.0 Wert 111.00000000000001
    • siehe floating point math kaputt? die decimal - Modul wenn Sie brauchen genaue dezimale Ergebnisse.
    InformationsquelleAutor Edwin
  3. 13

    Extrapolation von Edwin Antwort:

    from math import ceil, floor
def float_round(num, places = 0, direction = floor):
    return direction(num * (10**places)) / float(10**places)

    Verwenden:

    >>> float_round(0.21111, 3, ceil)  #round up
>>> 0.212
>>> float_round(0.21111, 3)        #round down
>>> 0.211
>>> float_round(0.21111, 3, round) #round naturally
>>> 0.211
    • Gibt falsche Ergebnisse in folgenden Fällen: math.ceil((1.11 * 100.0)) / 100.0 kommt heraus 1.12 Weil: 1.11 * 100.0 Wert 111.00000000000001
    InformationsquelleAutor Patrick Perini
  4. 11
    x = math.ceil(x * 100.0) / 100.0
    • Ich hatte einen Blick auf diese für eine Weile, bevor ich erkannte, das ist sogar mehr pythonic als meine Lösung.
    InformationsquelleAutor Mark Ransom
  5. 10

    Dies hängt von dem Verhalten, das Sie wollen, wenn man positive und negative zahlen, aber wenn Sie wollen etwas, das immer Runden auf einen größeren Wert (z.B. 2.0449 -> 2.05, -2.0449 -> -2.04) dann kannst du das tun:

    round(x + 0.005, 2)

    oder ein wenig schicker:

    def round_up(x, place):
    return round(x + 5 * 10**(-1 * (place + 1)), place)

    Dieser scheint auch zu funktionieren wie folgt:

    round(144, -1)
# 140
round_up(144, -1)
# 150
round_up(1e308, -307)
# 1.1e308
    InformationsquelleAutor ajp619
  6. 4

    Beachten Sie, dass die ceil(num * 100) /100 trick-crash auf einige degenerierte Eingaben, wie 1e308. Dieser kann nicht kommen oft, aber ich kann Ihnen sagen, es nur kostet mich ein paar Tage. Um dies zu vermeiden, "wäre es schön, wenn" ceil() und floor() nahm einen Dezimalstellen argument, wie round() tut... Inzwischen weiss jemand eine saubere alternative, die nicht Abstürzen, auf Eingaben wie das? Ich hatte einige Hoffnungen für die decimal - Paket, aber es scheint zu sterben, zu:

    >>> from math import ceil
>>> from decimal import Decimal, ROUND_DOWN, ROUND_UP
>>> num = 0.1111111111000
>>> ceil(num * 100) / 100
0.12
>>> float(Decimal(num).quantize(Decimal('.01'), rounding=ROUND_UP))
0.12
>>> num = 1e308
>>> ceil(num * 100) / 100
Traceback (most recent call last):
  File "<string>", line 301, in runcode
  File "<interactive input>", line 1, in <module>
OverflowError: cannot convert float infinity to integer
>>> float(Decimal(num).quantize(Decimal('.01'), rounding=ROUND_UP))
Traceback (most recent call last):
  File "<string>", line 301, in runcode
  File "<interactive input>", line 1, in <module>
decimal.InvalidOperation: [<class 'decimal.InvalidOperation'>]

    Natürlich könnte man sagen, der Absturz ist die einzige vernünftige Verhalten auf solche Einträge, aber ich würde behaupten, dass es nicht die Rundung, sondern die Multiplikation, die das problem verursacht (das ist, warum, z.B., 1e306 nicht abstürzt), und eine sauberere Umsetzung der rund-um-bis-N-TEN-Platz fn-würde vermeiden, dass die Multiplikation hack.

    • Das problem, das Sie in läufst mit dieser Nutzung Decimal ist, dass das Ergebnis der Quantisierung Ausdruck braucht 311 Ziffern zum Ausdruck zu bringen, und die aktuelle Genauigkeit ist zu klein. Wenn Sie eine from decimal import getcontext; getcontext().prec = 400 im Vorfeld, diese "arbeiten", für einen Wert von "Arbeit". Oder Sie können beachten Sie, dass alle Schwimmer, die größer als 2**52 im absoluten Wert muss bereits eine ganze Zahl, so dass die Rundung wird keine Wirkung haben. Und ja, ich Stimme zu, es wäre schön, wenn "ceil" und "Boden" hat eine Nachkommastellen argument.
    InformationsquelleAutor Jacob Eliosoff
  7. 2
    def round_up(number, ndigits=None):
    # start by just rounding the number, as sometimes this rounds it up
    result = round(number, ndigits if ndigits else 0)
    if result < number:
        # whoops, the number was rounded down instead, so correct for that
        if ndigits:
            # use the type of number provided, e.g. float, decimal, fraction
            Numerical = type(number)
            # add the digit 1 in the correct decimal place
            result += Numerical(10) ** -ndigits
            # may need to be tweaked slightly if the addition was inexact
            result = round(result, ndigits)
        else:
            result += 1 # same as 10 ** -0 for precision of zero digits
    return result

assert round_up(0.022499999999999999, 2) == 0.03
assert round_up(0.1111111111111000, 2) == 0.12

assert round_up(1.11, 2) == 1.11
assert round_up(1e308, 2) == 1e308
    • Sollten Sie Kommentare in Ihren code, um zu beschreiben, was du gemacht hast
    • Ist das besser?
    • Das ist Super, danke!
    InformationsquelleAutor David Augusto Villa
  8. 0

    Die Runde funtion angegeben funktioniert nicht, definitiv für Ganzzahlen wie :

    a=8

    round(a,3)

    8.0

    a=8.00

    round(a,3)

    8.0

    a=8.000000000000000000000000

    round(a,3)

    8.0

    aber funktioniert für :

    r=400/3.0

    r

    133.33333333333334

    Runde(r,3)

    133.333

    Ausserdem die Nachkommastellen wie 2.675 abgerundet sind, als nicht 2.67 2.68.

    Besser verwenden Sie die andere Methode, die oben bereitgestellt.

    InformationsquelleAutor Shikhar
  9. 0

    Python round Funktion Rundung, die Art und Weise nicht erwartet.

    Können Sie mehr über die spezifischen Rundung-Methode, indem Sie Decimal.quantize

    zB.

    from decimal import Decimal, ROUND_HALF_UP
res = Decimal('0.25').quantize(Decimal('0.0'), rounding=ROUND_HALF_UP)
print(res) 
# prints 0.3

    Referenz:

    https://gist.github.com/jackiekazil/6201722

    InformationsquelleAutor James Lin
Schreibe einen Kommentar