Wie rundet man eine Zahl in Python auf?

Dieses Problem bringt mich um. Wie rundet man eine Zahl UP in Python auf?

Ich habe versucht, die Zahl abzurunden, aber es hat die Zahl abgerundet. Beispiel:

round(2.3) = 2.0 and not 3, what I would like

Das habe ich versucht int (Nummer + .5) aber es rundet die Nummer wieder ab! Beispiel:

int(2.3 + .5) = 2

Dann habe ich es mit Runde (Nummer + .5) versucht, aber in Randfällen funktioniert es nicht. Beispiel:

WAIT! THIS WORKED!

Bitte beraten.

Die Deckenfunktion :

import math
print(math.ceil(4.2))

Ich weiß, dass diese Antwort für eine Frage von vor einiger Zeit ist, aber wenn Sie keine Mathematik importieren und nur aufrunden möchten, funktioniert dies für mich.

>>> int(21 / 5)
4
>>> int(21 / 5) + (21 % 5 > 0)
5

Der erste Teil wird zu 4 und der zweite Teil wird mit "True" bewertet, wenn ein Rest vorhanden ist, der zusätzlich True = 1 ist. False = 0. Wenn also kein Rest vorhanden ist, bleibt die gleiche Ganzzahl erhalten, aber wenn ein Rest vorhanden ist, wird 1 hinzugefügt.

Interessantes Python 2.x-Problem:

>>> import math
>>> math.ceil(4500/1000)
4.0
>>> math.ceil(4500/1000.0)
5.0

Das Problem ist, dass das Teilen von zwei Ints in Python ein weiteres Int erzeugt und dieses vor dem Deckenaufruf abgeschnitten wird. Sie müssen einen Wert als Float (oder Cast) festlegen, um ein korrektes Ergebnis zu erhalten.

In Javascript führt genau derselbe Code zu einem anderen Ergebnis:

console.log(Math.ceil(4500/1000));
5

Wenn Sie mit ganzen Zahlen arbeiten, besteht eine Möglichkeit zum Aufrunden darin, die Tatsache auszunutzen, dass abgerundet wird //: Teilen Sie einfach die negative Zahl und negieren Sie dann die Antwort. Kein Import, Gleitkomma oder Bedingung erforderlich.

rounded_up = -(-numerator // denominator)

Zum Beispiel:

>>> print(-(-101 // 5))
21

Das könnte dir auch gefallen:

>>> import numpy as np
>>> np.ceil(2.3)
3.0

Ich sage nicht, dass es besser ist als Mathe, aber wenn Sie numpy bereits für andere Zwecke verwendet haben, können Sie Ihren Code konsistent halten.

Jedenfalls nur ein Detail, auf das ich gestoßen bin. Ich benutze viel Numpy und war überrascht, dass es nicht erwähnt wurde, aber natürlich funktioniert die akzeptierte Antwort einwandfrei.

Verwenden Siemath.ceil zum Aufrunden:

>>> import math
>>> math.ceil(5.4)
6.0

HINWEIS : Der Eingang sollte float sein.

Wenn Sie eine Ganzzahl benötigen, rufen Sie diese intauf, um sie zu konvertieren:

>>> int(math.ceil(5.4))
6

Übrigens, verwenden Sie math.floor, um abzurunden und roundauf die nächste ganze Zahl zu runden.

>>> math.floor(4.4), math.floor(4.5), math.floor(5.4), math.floor(5.5)
(4.0, 4.0, 5.0, 5.0)
>>> round(4.4), round(4.5), round(5.4), round(5.5)
(4.0, 5.0, 5.0, 6.0)
>>> math.ceil(4.4), math.ceil(4.5), math.ceil(5.4), math.ceil(5.5)
(5.0, 5.0, 6.0, 6.0)

Die Syntax ist möglicherweise nicht so pythonisch, wie man es gerne hätte, aber es ist eine leistungsstarke Bibliothek.

https://docs.python.org/2/library/decimal.html

from decimal import *
print(int(Decimal(2.3).quantize(Decimal('1.'), rounding=ROUND_UP)))

Ich bin überrascht, dass niemand vorgeschlagen hat

(numerator + denominator - 1) // denominator

für ganzzahlige Division mit Aufrundung. War früher der übliche Weg für C / C ++ / CUDA (vgl. divup)

Stellen Sie sicher, dass der gerundete Wert schwebend sein sollte

a = 8 
b = 21
print math.ceil(a / b)
>>> 0

aber

print math.ceil(float(a) / b)
>>> 1.0

Versuche dies:

a = 211.0
print(int(a) + ((int(a) - a) != 0))

>>> def roundup(number):
...     return round(number+.5)
>>> roundup(2.3)
3
>>> roundup(19.00000000001)
20

Diese Funktion erfordert keine Module.

Die obigen Antworten sind richtig, aber das Importieren des mathModuls nur für diese eine Funktion fühlt sich für mich normalerweise wie ein Overkill an. Zum Glück gibt es noch einen anderen Weg:

g = 7/5
g = int(g) + (not g.is_integer())

Trueund Falsewerden als 1und 0in einer Anweisung mit Zahlen in Python interpretiert . g.is_interger()im Grunde übersetzt zu g.has_no_decimal()oder g == int(g). So lautet die letzte Aussage auf Englisch round g down and add one if g has decimal.

Ohne Mathematik zu importieren // mit grundlegender Umgebung:

a) Methode / Klassenmethode

def ceil(fl): 
  return int(fl) + (1 if fl-int(fl) else 0)

def ceil(self, fl): 
  return int(fl) + (1 if fl-int(fl) else 0)

b) Lambda:

ceil = lambda fl:int(fl)+(1 if fl-int(fl) else 0)

Für diejenigen, die aufrunden a / bund eine ganze Zahl erhalten möchten :

Eine andere Variante mit ganzzahliger Division ist

def int_ceil(a, b):
    return (a - 1) // b + 1

>>> int_ceil(19, 5)
4
>>> int_ceil(20, 5)
4
>>> int_ceil(21, 5)
5

Falls jemand auf eine bestimmte Dezimalstelle aufrunden möchte:

import math
def round_up(n, decimals=0):
    multiplier = 10 ** decimals
    return math.ceil(n * multiplier) / multiplier

Ich bin überrascht round(x + 0.4999), dass ich diese Antwort noch nicht gesehen habe , also werde ich sie ablegen. Beachten Sie, dass dies mit jeder Python-Version funktioniert. Änderungen am Python-Rundungsschema haben die Sache schwierig gemacht. Siehe diesen Beitrag .

Ohne zu importieren, benutze ich:

def roundUp(num):
    return round(num + 0.49)

testCases = list(x*0.1 for x in range(0, 50))

print(testCases)
for test in testCases:
    print("{:5.2f}  -> {:5.2f}".format(test, roundUp(test)))

Warum das so ist

Aus den Dokumenten

Für die eingebauten Typen, die round () unterstützen, werden die Werte auf das nächste Vielfache von 10 zur Potenz minus n gerundet. Wenn zwei Vielfache gleich nahe beieinander liegen, wird auf die gerade Wahl gerundet

Daher wird 2,5 auf 2 und 3,5 auf 4 gerundet. Wenn dies nicht der Fall wäre, könnte das Aufrunden durch Hinzufügen von 0,5 erfolgen, aber wir möchten vermeiden, auf den halben Punkt zu gelangen. Wenn Sie also 0,4999 hinzufügen, werden Sie nah dran sein, aber mit genügend Spielraum, um auf das gerundet zu werden, was Sie normalerweise erwarten würden. Dies wird natürlich fehlschlagen, wenn das x + 0.4999gleich ist [n].5000, aber das ist unwahrscheinlich.

So machen Sie es ohne Import:

>>> round_up = lambda num: int(num + 1) if int(num) != num else int(num)
>>> round_up(2.0)
2
>>> round_up(2.1)
3

Ich weiß, dass dies schon eine ganze Weile her ist, aber ich habe eine ziemlich interessante Antwort gefunden.

-round(-x-0.5)

Dies behebt die Kantenfälle und funktioniert sowohl für positive als auch für negative Zahlen. Es ist kein Funktionsimport erforderlich

Prost

Wenn Sie 4500/1000 in Python betreiben, ist das Ergebnis 4, da für das Standard-Python-Asume als Ganzzahl das Ergebnis logisch lautet: 4500/1000 = 4,5 -> int (4,5) = 4 und die Obergrenze von 4 ist offensichtlich 4

Bei Verwendung von 4500 / 1000.0 beträgt das Ergebnis 4,5 und die Obergrenze 4,5 -> 5

Wenn Sie Javascript verwenden, erhalten Sie 4.5 als Ergebnis von 4500/1000, da Javascript nur das Ergebnis als "numerischen Typ" annimmt und ein Ergebnis direkt als float zurückgibt

Viel Glück!!

Wenn Sie nichts importieren möchten, können Sie jederzeit Ihre eigene einfache Funktion schreiben als:

def RoundUP(num): if num== int(num): return num return int(num + 1)

Sie können Floor Devision verwenden und 1 hinzufügen. 2,3 // 2 + 1

Ich denke, Sie verwechseln die Arbeitsmechanismen zwischen int()und round().

int()schneidet die Dezimalzahlen immer ab, wenn eine schwebende Zahl angegeben wird; wohingegen round()im Fall , 2.5wo2 und 3sind beide in gleichem Abstand von 2.5, Python kehrt je nachdem , was das ist mehr entfernt von dem 0 - Punkt.

round(2.5) = 3
int(2.5) = 2

Mein Anteil

Ich habe getestet print(-(-101 // 5)) = 21 das obige Beispiel oben .

Nun zur Zusammenfassung:

101 * 19% = 19.19

Ich kann nicht verwenden, **also verteile ich die Multiplikation auf Division:

(-(-101 //(1/0.19))) = 20

Ich bin im Grunde ein Anfänger bei Python, aber wenn Sie nur versuchen, aufzurunden statt abzurunden, warum nicht:

round(integer) + 1