Existe um teto equivalente a // operador em Python?

Eu descobri sobre o //operador em Python que em Python 3 faz divisão com chão.

Existe um operador que divide com teto em vez disso? (Eu sei sobre o /operador que no Python 3 faz a divisão de ponto flutuante.)

Não há operador que divida com teto. Você precisa import mathe usarmath.ceil

Você pode simplesmente fazer a divisão do piso de cabeça para baixo:

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

Isso funciona porque o operador de divisão do Python faz a divisão de piso (ao contrário de C, onde a divisão inteira trunca a parte fracionária).

Isso também funciona com os grandes inteiros do Python, porque não há conversão de ponto flutuante (com perdas).

Aqui está uma demonstração:

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

Você poderia fazer (x + (d-1)) // dao dividir xpor d, ou seja (x + 4) // 5.

Solução 1: converta chão em teto com negação

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

Uma reminiscência do truque de levitação de Penn & Teller , isso "vira o mundo de cabeça para baixo (com negação), usa divisão de piso simples (onde o teto e o piso foram trocados) e, em seguida, vira o mundo do lado direito (com negação novamente) "

Solução 2: deixe divmod () fazer o trabalho

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

A função divmod () fornece (a // b, a % b)para inteiros (isso pode ser menos confiável com flutuações devido ao erro de arredondamento). O passo com bool(r)adiciona um ao quociente sempre que houver um resto diferente de zero.

Solução 3: Ajuste o numerador antes da divisão

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

Transforme o numerador para cima para que a divisão do piso seja arredondada para baixo até o teto pretendido. Observe que isso só funciona para inteiros.

Solução 4: converta em flutuantes para usar math.ceil ()

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

O código math.ceil () é fácil de entender, mas converte de ints para floats e vice-versa. Isso não é muito rápido e pode ter problemas de arredondamento. Além disso, ele se baseia na semântica do Python 3, em que a "verdadeira divisão" produz um float e a função ceil () retorna um inteiro.

Você sempre pode fazer isso inline também

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

Em python3, isso é apenas uma ordem de magnitude mais rápido do que forçar a divisão flutuante e chamar ceil (), desde que você se preocupe com a velocidade. O que você não deveria fazer, a menos que tenha provado através do uso que você precisa.

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

Observe que math.ceil é limitado a 53 bits de precisão. Se você estiver trabalhando com números inteiros grandes, pode não obter resultados exatos.

A biblioteca gmpy2 fornece uma c_divfunção que usa arredondamento de teto.

Isenção de responsabilidade: eu mantenho o gmpy2.

Solução simples: a // b + 1