Есть ли в Python потолочный эквивалент оператора //?

Я узнал об //операторе в Python, который в Python 3 делает разделение с полом.

Есть ли вместо этого оператор деления на ceil? (Я знаю об /операторе, который в Python 3 выполняет деление с плавающей запятой.)

Нет оператора деления с ceil. Вам нужно import mathи использоватьmath.ceil

Можно просто сделать перевернутое деление этажа:

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

Это работает, потому что оператор деления Python выполняет деление пола (в отличие от C, где целочисленное деление усекает дробную часть).

Это также работает с большими целыми числами Python, потому что здесь нет преобразования с плавающей запятой (с потерями).

Вот демонстрация:

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

Вы могли бы сделать (x + (d-1)) // dпри делении xна d, то есть (x + 4) // 5.

Решение 1. Преобразуйте пол в потолок с отрицанием

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

Напоминающий трюк с левитацией Пенна и Теллера , это «переворачивает мир вверх дном (с отрицанием), использует простое деление пола (где потолок и пол поменяны местами), а затем переворачивает мир правой стороной вверх (снова с отрицанием) "

Решение 2. Позвольте divmod () сделать всю работу

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

Функция divmod () дает (a // b, a % b)для целых чисел (это может быть менее надежным с числами с плавающей запятой из-за ошибки округления). Шаг с bool(r)добавляет единицу к частному всякий раз, когда есть ненулевой остаток.

Решение 3. Настройте числитель перед делением

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

Переместите числитель вверх, чтобы разделение пола округлялось до предполагаемого потолка. Обратите внимание, это работает только для целых чисел.

Решение 4. Преобразование в числа с плавающей запятой для использования math.ceil ()

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

Код math.ceil () прост для понимания, но он преобразует целые числа в числа с плавающей запятой и обратно. Это не очень быстро и может иметь проблемы с округлением. Кроме того, он опирается на семантику Python 3, где «истинное деление» производит число с плавающей запятой, а функция ceil () возвращает целое число.

Вы всегда можете просто сделать это встроенным

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

В python3 это всего лишь на порядок быстрее, чем принудительное деление с плавающей запятой и вызов ceil (), при условии, что вы заботитесь о скорости. Чего вам не следует делать, если вы не доказали на практике, что вам это нужно.

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

Обратите внимание, что math.ceil ограничен 53 битами точности. Если вы работаете с большими целыми числами, вы можете не получить точных результатов.

Библиотека gmpy2 предоставляет c_divфункцию, которая использует округление потолка.

Отказ от ответственности: я поддерживаю gmpy2.

Простое решение: a // b + 1