Jak zaokrąglić liczbę w Pythonie?

[[2]} Ciekawy Python 2.kwestia x do zapamiętania:

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

Problem polega na tym, że dzielenie dwóch Int w Pythonie powoduje powstanie kolejnego int, który jest obcięty przed wywołaniem sufitu. Aby uzyskać poprawny wynik, musisz uczynić jedną wartość float (lub cast).

W javascript, ten sam kod daje inny wynik:

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

Wiem, że ta odpowiedź jest na pytanie sprzed jakiegoś czasu, ale jeśli nie chcesz importować matematyki, a chcesz tylko zaokrąglać, to działa dla mnie.

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

Pierwsza część staje się 4, a druga część ocenia na "True", jeśli istnieje reszta, która dodatkowo True = 1; False = 0. Więc jeśli nie ma reszty, to pozostaje ta sama liczba całkowita, ale jeśli jest reszta dodaje 1.

W przypadku pracy z liczbami całkowitymi, jednym ze sposobów zaokrąglania w górę jest wykorzystanie faktu, że // zaokrągla się w dół: po prostu wykonaj podział na liczbę ujemną, a następnie zaneguj odpowiedź. Nie jest potrzebny import, zmiennoprzecinkowy ani warunkowy.

rounded_up = -(-numerator // denominator)

Na przykład:

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

Możesz również polubić numpy:

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

Nie mówię, że to lepsze niż matematyka, ale jeśli używałeś już numpy do innych celów, możesz zachować spójność kodu.

Użycie math.ceil zaokrąglić:

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

Notatka: wejście powinno być float.

Jeśli potrzebujesz liczby całkowitej, wywołaj int, aby ją przekonwertować:

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

BTW, użyj math.floordo zaokrąglenia w dół i round do zaokrąglenia do najbliższej liczby całkowitej.

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

Składnia może nie być tak pythoniczna, jak by się chciało, ale jest potężną biblioteką.

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

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

Be shure zaokrąglona wartość powinna być float

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

Ale

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

Dziwi mnie, że nikt nie zasugerował]}

(numerator + denominator - 1) // denominator

Dla dzielenia liczb całkowitych z zaokrągleniem w górę. Dawniej był to wspólny sposób dla C / C++ / CUDA (por. divup)

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

Ta funkcja nie wymaga modułów.

Powyższe odpowiedzi są poprawne, jednak importowanie modułu math tylko dla tej jednej funkcji zwykle wydaje mi się trochę przesadą. Na szczęście jest inny sposób, aby to zrobić:

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

True i {[3] } są interpretowane jako 1 i 0 w oświadczeniu zawierającym liczby w Pythonie. g.is_interger() W zasadzie tłumaczy się na g.has_no_decimal() lub g == int(g). Tak więc ostatnia wypowiedź w języku angielskim brzmi round g down and add one if g has decimal.

Bez importowania matematyki / / przy użyciu podstawowego środowiska:

A) Metoda / Metoda klasy

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)

Spróbuj tego:

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

Dziwi mnie, że jeszcze nie widziałem tej odpowiedzi, więc ją odłożę. Zauważ, że działa to z każdą wersją Pythona. Zmiany wprowadzone w systemie zaokrąglania Pythona utrudniły sprawę. Zobacz ten post .

Bez importowania używam:

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

Dlaczego to działa

Z docs

Dla typów wbudowanych obsługujących round (), wartości są zaokrąglane do najbliższej wielokrotności 10 do potęgi minus n; Jeśli dwie wielokrotności są jednakowe blisko, zaokrąglanie odbywa się w kierunku parzystego wyboru

Dlatego 2,5 zaokrągla się do 2, a 3,5 do 4. Gdyby tak nie było, zaokrąglenie można by zrobić dodając 0.5, ale chcemy uniknąć dojścia do półmetka. Tak więc, jeśli dodasz 0.4999, zbliżysz się, ale z wystarczającym marginesem, aby być zaokrąglonym do tego, czego normalnie byś się spodziewał. Oczywiście, to się nie powiedzie, jeśli x + 0.4999 jest równe [n].5000, ale jest to mało prawdopodobne.

Dla tych, którzy chcą zaokrąglić a / b i uzyskać liczbę całkowitą:

Innym wariantem stosującym dzielenie liczb całkowitych jest

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

Aby zrobić to bez żadnego importu:

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

Wiem, że to już jakiś czas temu, ale znalazłem dość ciekawą odpowiedź, więc proszę bardzo:

-round(-x-0.5)

To naprawia przypadki krawędzi i działa zarówno dla liczb dodatnich, jak i ujemnych, i nie wymaga żadnego importowania funkcji

Cheers

Gdy operujesz 4500/1000 w Pythonie, wynik będzie 4, ponieważ dla domyślnego Pythona jako liczba całkowita wynik, logicznie: 4500/1000 = 4,5 --> int(4,5) = 4 i 4

Używając 4500/1000. 0 wynik wyniesie 4,5 i 4,5 -- > 5

Używając javascript otrzymamy 4.5 jako wynik 4500/1000, ponieważ javascript asume tylko wynik jako "typ numeryczny" i zwróci wynik bezpośrednio jako float

Powodzenia!!

Jeśli nie chcesz niczego importować, zawsze możesz napisać swoją prostą funkcję jako:

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

Możesz użyć floor devision i dodać do niego 1. 2.3 // 2 + 1

Myślę, że mylą Pan mechanizmy działania pomiędzy int() i round().

int() Zawsze obcina liczby dziesiętne, jeśli podana jest liczba zmienna; podczas gdy round(), w przypadku 2.5 Gdzie 2 i 3 znajdują się w równej odległości od 2.5, Python zwraca tę, która jest bardziej oddalona od punktu 0.

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

Jestem w zasadzie początkujący w Pythonie, ale jeśli próbujesz tylko zaokrąglić w górę zamiast w dół, dlaczego nie zrobić:

round(integer) + 1