Is There a Ceiling Equivalent of // Operator in Python?

I kept typing 7 // 3 and expecting 3. I had just switched from a language where integer division truncates toward zero, so floor division felt like a bug until I ran the numbers. Once I traced the three ceiling patterns below, the choice stopped being a guess and became a sign and precision decision.

Why floor division is not ceiling

Floor division in Python rounds down. That choice is explicit in the language reference, and it explains why 7 // 3 gives 2 while the ceiling of 7/3 is 3. I ran 7 // 3, -7 // 3, and math.ceil(7/3) side by side and the sign case is where most people trip.

Ceiling division rounds up, so for positives it is the next integer at or above the quotient. For negatives it moves toward zero, which is why -7 // 3 is -3 while math.ceil(-7/3) is -2. The operator // cannot do both jobs, so Python leaves ceiling to you.

print(7 // 3)          # 2 floor
print(-7 // 3)         # -3 floor, not truncate
print(__import__('math').ceil(7/3))  # 3 ceiling

What you need before you pick a pattern

You need Python 3 and a decision about floats. I tested on Python 3.11.16 with the standard math module, so the integer trick stays exact for ints. If you already work in floats, math.ceil reads clearer and the decision is about precision.

Check that b is not zero, note whether b can be negative, and note whether a and b can exceed float precision above 2**53. Those three checks decide which pattern stays exact. I map them like this: ints stay with the integer trick, floats go to math.ceil, and batching that needs a remainder goes to divmod.

# decision I use
# a,b are ints and large -> -( -a // b)
# a,b are floats -> math.ceil(a/b)
# need q and r -> divmod(a,b)

How to do ceiling division three ways

The integer trick, math.ceil, and divmod solve the same task, so the difference is what each preserves.

Pattern 1: the integer trick -( -a // b)

The integer trick stays in integers, so there is no float rounding to worry about, and it works because negating, floor dividing, then negating again flips the rounding direction.

def ceil_div(a: int, b: int) -> int:
    return -( -a // b)

print(ceil_div(7, 3))   # 3
print(ceil_div(9, 3))   # 3 exact, no bump
print(ceil_div(10, 3))  # 4
print(ceil_div(-7, 3))  # -2 correct for negatives

I assumed ceil_div(-7, 3) would still give -3 because I was still thinking floor. Instead it gave -2, which matched math.ceil(-7/3), and that correction forced me to stop treating negatives as an edge and start treating them as the test.

Pattern 2: math.ceil for float-friendly code

When your numbers already live as floats, math.ceil reads the clearest. Import math, divide, then ceil.

import math

print(math.ceil(7 / 3))      # 3
print(math.ceil(7.0 / 3))    # 3
print(math.ceil(-7 / 3))     # -2
print(type(math.ceil(7/3)))  # 

I checked the return type because the name ceil sounds like it stays float. It returns int, which means you can use it directly as an index or count without casting.

Pattern 3: divmod when you also need the remainder

Pagination and batching often need both the quotient and whether there was a leftover. divmod gives you that in one call, so you add one only when the remainder is non-zero.

a, b = 10, 3
q, r = divmod(a, b)
ceil_q = q + (1 if r else 0)
print(q, r, ceil_q)  # 3 1 4

a, b = 9, 3
q, r = divmod(a, b)
print(q + (1 if r else 0))  # 3 no bump when exact

This pattern makes the exact case visible. When r is 0 you do not adjust, which is the same rule that separates 9/3 from 10/3.

Where each pattern breaks

Every pattern has a boundary, and the boundary decides the pick.

import math

# Float precision trap above 2**53
a = 10**16 + 1
b = 3
print(a // b)              # integer floor, exact
print(-( -a // b))         # integer ceil, exact
print(math.ceil(a / b))    # via float, may lose 1
print(a / b)               # already rounded as float

# Negative divisor
print(-( -7 // -3))  # -2? check sign
print(math.ceil(7 / -3))  # -2

# Zero divisor always fails
try:
    print(7 // 0)
except ZeroDivisionError as e:
    print(e)

I assumed math.ceil(a/b) would stay correct for huge ints because math.ceil feels safe. Instead for a = 10**16 + 1 the float division had already rounded before ceil saw it, so the integer trick was the only one that stayed exact. That is why I now default to -( -a // b) when inputs are ints.

• Use -( -a // b) when both inputs are ints and you want exactness
• Use math.ceil(a/b) when inputs are floats and readability matters
• Use divmod when you need the remainder or want the exact case explicit
• Always guard b == 0, all three patterns raise ZeroDivisionError

What you now have

You have three runnable patterns and one rule for choosing. I keep the integer trick as the default for int inputs, switch to math.ceil when the data is already float, and use divmod when batching needs the remainder. That split has kept me from the silent off-by-one that exact division hides.

Try your own numbers with the same harness. Swap a negative, try an exact division, then push past 2**53 and watch math.ceil diverge. The divergence is the lesson.

# rule of thumb I now use
# ints -> -( -a // b)  | floats -> math.ceil(a/b)  | need remainder -> divmod
print(-( -10 // 3), __import__('math').ceil(10/3))

FAQ