Jak zaokrąglasz liczbę w Pythonie?

Ten problem mnie zabija. W jaki sposób jedno zaokrąglenie liczby UP w Pythonie?

Próbowałem zaokrąglić (liczbę), ale zaokrągliłem liczbę w dół. Przykład:

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

Próbowałem int (liczba + .5), ale ponownie zaokrągla liczbę w dół! Przykład:

int(2.3 + .5) = 2

Potem próbowałem zaokrąglić (liczba + .5), ale to nie zadziała w przypadku krawędzi. Przykład:

WAIT! THIS WORKED!

Proszę doradź.

Ceil (pułap) Funkcja:

import math
print(math.ceil(4.2))

Wiem, że ta odpowiedź jest na pytanie od jakiegoś czasu, ale jeśli nie chcesz importować matematyki i chcesz po prostu zaokrąglić w górę, to działa dla mnie.

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

Pierwsza część staje się 4, a druga część przyjmuje wartość „Prawda”, jeśli pozostała część, która dodatkowo Prawda = 1; False = 0. Więc jeśli nie ma reszty, to pozostaje ta sama liczba całkowita, ale jeśli jest reszta, dodaje 1.

Interesujący problem z Python 2.x, o którym należy pamiętać:

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

Problem polega na tym, że podzielenie dwóch liczb całkowitych w pythonie powoduje powstanie kolejnej liczby wewnętrznej, która jest obcięta przed wywołaniem pułapu. Musisz ustawić jedną wartość jako zmiennoprzecinkową (lub rzutową), aby uzyskać poprawny wynik.

W javascript ten sam kod daje inny wynik:

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

Jeśli pracujesz z liczbami całkowitymi, jednym ze sposobów zaokrąglania w górę jest skorzystanie z faktu, że //zaokrągla w dół: po prostu wykonaj podział na liczbę ujemną, a następnie zaneguj odpowiedź. Nie jest wymagany import, zmiennoprzecinkowy ani warunkowy.

rounded_up = -(-numerator // denominator)

Na przykład:

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

Możesz także polubić numpy:

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

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

W każdym razie tylko szczegół, z którym się spotkałem. Często używam numpy i byłem zaskoczony, że nie wspomniano o nim, ale oczywiście zaakceptowana odpowiedź działa doskonale.

Użyj,math.ceil aby zaokrąglić w górę:

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

UWAGA : Wejście powinno być zmiennoprzecinkowe.

Jeśli potrzebujesz liczby całkowitej, zadzwoń, intaby ją przekonwertować:

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

BTW, użyj, math.flooraby zaokrąglić w dół i roundzaokrąglić 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ę mogło wydawać, ale jest to potężna biblioteka.

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

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

Dziwię się, że nikt nie zasugerował

(numerator + denominator - 1) // denominator

do dzielenia liczb całkowitych z zaokrąglaniem w górę. Kiedyś był powszechnym sposobem dla C / C ++ / CUDA (por. divup)

Zaokrąglona wartość powinna być zmienna

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

ale

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

Spróbuj tego:

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

Ta funkcja nie wymaga modułów.

Powyższe odpowiedzi są poprawne, jednak importowanie mathmodułu tylko dla tej jednej funkcji zwykle wydaje mi się przesadą. Na szczęście istnieje inny sposób:

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

Truei Falsesą interpretowane jako 1oraz 0w instrukcji zawierającej liczby w pythonie. g.is_interger()w zasadzie tłumaczy się na g.has_no_decimal()lub g == int(g). Tak więc ostatnie zdanie w języku angielskim brzmiround 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)

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

Innym wariantem wykorzystują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

Jeśli ktoś chce zaokrąglić w górę do określonego miejsca po przecinku:

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

Dziwię się, że jeszcze nie widziałem tej odpowiedzi round(x + 0.4999), więc odłożę ją. Zauważ, że działa to z każdą wersją Pythona. Zmiany wprowadzone w schemacie zaokrąglania w Pythonie utrudniają pracę. 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 dokumentów

W przypadku wbudowanych typów obsługujących round () wartości są zaokrąglane do najbliższej wielokrotności 10 do potęgi minus n; jeśli dwa wielokrotności są jednakowo blisko siebie, zaokrąglanie odbywa się w kierunku równego wyboru

Dlatego 2,5 zostaje zaokrąglone do 2, a 3,5 zaokrąglone do 4. Jeśli tak nie było, zaokrąglanie w górę można wykonać, dodając 0,5, ale chcemy uniknąć dotarcia do połowy. Tak więc, jeśli dodasz 0,4999, zbliżysz się, ale z wystarczającym marginesem, aby zostać zaokrąglonym do tego, czego normalnie byś oczekiwał. Oczywiście to się nie powiedzie, jeśli x + 0.4999jest równe [n].5000, ale jest to mało prawdopodobne.

Aby to zrobić bez 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ż dawno temu, ale znalazłem dość interesującą odpowiedź, więc oto:

-round(-x-0.5)

Naprawia to przypadki krawędzi i działa zarówno dla liczb dodatnich, jak i ujemnych i nie wymaga importu żadnej funkcji

Twoje zdrowie

kiedy operujesz 4500/1000 w Pythonie, wynik będzie wynosił 4, ponieważ dla domyślnego Pythona przyjmujemy jako liczbę całkowitą wynik, logicznie: 4500/1000 = 4.5 -> int (4.5) = 4 i pułap 4 oczywiście wynosi 4

przy użyciu 4500 / 1000.0 wynik wyniesie 4,5, a pułap 4,5 -> 5

Za pomocą javascript otrzymasz 4.5 jako wynik 4500/1000, ponieważ javascript przyjmuje tylko wynik jako „typ liczbowy” i zwraca wynik bezpośrednio jako zmiennoprzecinkowy

Powodzenia!!

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

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

Możesz użyć podziału podłogi i dodać do niego 1. 2,3 // 2 + 1

Myślę, że mylisz mechanizmy robocze między int()i round().

int()zawsze obcina liczby dziesiętne, jeśli podano liczbę zmiennoprzecinkową; podczas gdy round()w przypadku 2.5gdzie 2i 3oba są w równej odległości 2.5, Python zwraca cokolwiek, co jest bardziej oddalone od punktu 0.

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

Moja część

Testowałem print(-(-101 // 5)) = 21 podany przykład powyżej.

Teraz do zaokrąglania w górę:

101 * 19% = 19.19

Nie mogę użyć, **więc podzielę mnożnik na dział:

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

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

round(integer) + 1