Czy istnieje odpowiednik operatora // w Pythonie?

Dowiedziałem się o //operatorze w Pythonie, który w Pythonie 3 dzieli się na podłogę.

Czy istnieje operator, który zamiast tego dzieli się na ceil? (Wiem o /operatorze, który w Pythonie 3 wykonuje dzielenie zmiennoprzecinkowe).

Nie ma operatora, który dzieli górą. Musisz import mathi używaćmath.ceil

Możesz po prostu wykonać podział piętra do góry nogami:

def ceildiv(a, b):
    return -(-a // b)

Działa to, ponieważ operator dzielenia w Pythonie wykonuje dzielenie na podłogę (w przeciwieństwie do C, gdzie dzielenie całkowite obcina część ułamkową).

Działa to również z dużymi liczbami całkowitymi Pythona, ponieważ nie ma (stratnej) konwersji zmiennoprzecinkowej.

Oto demonstracja:

>>> from __future__ import division   # a/b is float division
>>> from math import ceil
>>> b = 3
>>> for a in range(-7, 8):
...     print(["%d/%d" % (a, b), int(ceil(a / b)), -(-a // b)])
... 
['-7/3', -2, -2]
['-6/3', -2, -2]
['-5/3', -1, -1]
['-4/3', -1, -1]
['-3/3', -1, -1]
['-2/3', 0, 0]
['-1/3', 0, 0]
['0/3', 0, 0]
['1/3', 1, 1]
['2/3', 1, 1]
['3/3', 1, 1]
['4/3', 2, 2]
['5/3', 2, 2]
['6/3', 2, 2]
['7/3', 3, 3]

Można to zrobić (x + (d-1)) // ddzieląc xprzez d, tj (x + 4) // 5.

Rozwiązanie 1: Zamień podłogę na sufit z negacją

def ceiling_division(n, d):
    return -(n // -d)

Przypomina sztuczkę lewitacji Penn & Teller , która „odwraca świat do góry nogami (z negacją), wykorzystuje zwykły podział podłogi (gdzie zamieniono sufit i podłogę), a następnie obraca świat w prawą stronę (ponownie z negacją) "

Rozwiązanie 2: Pozwól divmod () wykonać pracę

def ceiling_division(n, d):
    q, r = divmod(n, d)
    return q + bool(r)

Funkcja divmod () podaje (a // b, a % b)liczby całkowite (może to być mniej niezawodne w przypadku wartości zmiennoprzecinkowych z powodu błędu zaokrąglenia). Krok z bool(r)dodaje jedynkę do ilorazu za każdym razem, gdy pozostaje niezerowa reszta.

Rozwiązanie 3: Dostosuj licznik przed dzieleniem

def ceiling_division(n, d):
    return (n + d - 1) // d

Przesuń licznik w górę, aby podział podłogi został zaokrąglony w dół do przewidywanego sufitu. Uwaga, działa to tylko dla liczb całkowitych.

Rozwiązanie 4: Konwertuj na elementy zmiennoprzecinkowe, aby używać funkcji math.ceil ()

def ceiling_division(n, d):
    return math.ceil(n / d)

Kod math.ceil () jest łatwy do zrozumienia, ale konwertuje z liczb całkowitych na zmiennoprzecinkowe iz powrotem. Nie jest to zbyt szybkie i może powodować problemy z zaokrąglaniem. Opiera się również na semantyce Pythona 3, gdzie „prawdziwy podział” tworzy liczbę zmiennoprzecinkową, a funkcja ceil () zwraca liczbę całkowitą.

Zawsze możesz to również zrobić w trybie inline

((foo - 1) // bar) + 1

W pythonie3 jest to o rząd wielkości szybsze niż wymuszanie dzielenia typu float i wywoływanie ceil (), pod warunkiem, że zależy Ci na szybkości. Czego nie powinieneś, chyba że udowodniłeś poprzez użycie, że musisz.

>>> timeit.timeit("((5 - 1) // 4) + 1", number = 100000000)
1.7249219375662506
>>> timeit.timeit("ceil(5/4)", setup="from math import ceil", number = 100000000)
12.096064013894647

Zauważ, że math.ceil jest ograniczona do 53 bitów precyzji. Jeśli pracujesz z dużymi liczbami całkowitymi, możesz nie uzyskać dokładnych wyników.

Gmpy2 Libary zapewnia c_divfunkcję zaokrąglania, który wykorzystuje na suficie.

Zastrzeżenie: utrzymuję gmpy2.

Proste rozwiązanie: a // b + 1