Esiste un equivalente del soffitto dell'operatore // in Python?

Ho scoperto l' //operatore in Python che in Python 3 fa la divisione con il pavimento.

Esiste invece un operatore che divide con ceil? (Conosco l' /operatore che in Python 3 esegue la divisione in virgola mobile.)

Non c'è operatore che divide con ceil. È necessario import mathe utilizzaremath.ceil

Puoi semplicemente eseguire la divisione del pavimento capovolta:

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

Questo funziona perché l'operatore di divisione di Python esegue la divisione dei piani (a differenza di C, dove la divisione intera tronca la parte frazionaria).

Funziona anche con i grandi interi di Python, perché non c'è conversione in virgola mobile (con perdita).

Ecco una dimostrazione:

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

Potresti fare (x + (d-1)) // dquando dividi xper d, ad es (x + 4) // 5.

Soluzione 1: convertire il pavimento in soffitto con la negazione

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

Ricorda il trucco della levitazione Penn & Teller , questo "capovolge il mondo (con negazione), usa una divisione semplice del pavimento (dove il soffitto e il pavimento sono stati scambiati), e poi gira il mondo sul lato destro (di nuovo con la negazione) "

Soluzione 2: lascia che divmod () faccia il lavoro

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

La funzione divmod () fornisce gli (a // b, a % b)interi (questo potrebbe essere meno affidabile con i float a causa di un errore di arrotondamento). Il passaggio con bool(r)aggiunge uno al quoziente ogni volta che è presente un resto diverso da zero.

Soluzione 3: regolare il numeratore prima della divisione

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

Traslare il numeratore verso l'alto in modo che la divisione del pavimento si arrotondi per difetto al soffitto previsto. Nota, questo funziona solo per i numeri interi.

Soluzione 4: converti in float per utilizzare math.ceil ()

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

Il codice math.ceil () è facile da capire, ma converte da int a float e viceversa . Non è molto veloce e potrebbe avere problemi di arrotondamento. Inoltre, si basa sulla semantica di Python 3 dove "true division" produce un float e dove la funzione ceil () restituisce un numero intero.

Puoi sempre farlo anche in linea

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

In python3, questo è appena un ordine di grandezza più veloce che forzare la divisione in virgola mobile e chiamare ceil (), a patto che ti interessi della velocità. Cosa che non dovresti, a meno che tu non abbia dimostrato attraverso l'uso che è necessario.

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

Si noti che math.ceil è limitato a 53 bit di precisione. Se stai lavorando con numeri interi di grandi dimensioni, potresti non ottenere risultati esatti.

La libreria gmpy2 fornisce una c_divfunzione che utilizza l'arrotondamento del soffitto.

Disclaimer: mantengo gmpy2.

Soluzione semplice: a // b + 1