New modulo operator to get both quotient and remainder


I was doing some computation and sometimes we have to get quotient and remainder of a value, for instance

quotient = value // divider
remainder = value % divider

So I was thinking maybe we could introduce a new operator to get both like

quotient, remainder = value %% divider

but I don’t know how useful this would be. Are there any people out there which think it would be helpful?

The built in divmod does this.


It does somewhat slowly, though. A benchmark:

 40.99 ±  0.15 ns  q, r = x // y, x % y
 40.92 ±  0.09 ns  x // y; x % y
 68.08 ±  0.30 ns  q, r = divmod(x, y)
 66.14 ±  0.42 ns  q, r = dm(x, y)

Python: 3.11.4 (main, Sep  9 2023, 15:09:21) [GCC 13.2.1 20230801]

Edit: Hmm, part of the slowness is from creating the tuple, which the operator would likely also do. So how fast would the operator be? I don’t see a way to find out other than implementing it…

Benchmark script
from timeit import timeit
from statistics import mean, stdev
import sys

setup = 'x, y, dm = 42, 23, divmod'
codes = [
    'q, r = x // y, x % y',
    'x // y; x % y',
    'q, r = divmod(x, y)',
    'q, r = dm(x, y)',

times = {c: [] for c in codes}
def stats(c):
    ts = [t * 1e9 for t in sorted(times[c])[:5]]
    return f'{mean(ts):6.2f} ± {stdev(ts):5.2f} ns '
for _ in range(100):
    for c in codes:
        t = timeit(';'.join([c] * 100), setup, number=10**3) / 1e5
for c in codes:
    print(stats(c), c)

print('\nPython:', sys.version)

Attempt This Online!

I’d prefer /% or //% though, to indicate both things it does and the order of the results:

quotient, remainder = value /% divider
quotient, remainder = value //% divider

About usefulness, @mdickinson wrote about divmod a while ago.

divmod has been around much longer than the // operator. From a readability perspective using // and % is probably better. That they are faster to boot (mostly from saving function call overhead I suspect) is just a bonus. Think of divmod as an appendix, not really useful anymore, but lingering around from a time when it was necessary.

When was it necessary for what?

Hmmm… that’s a good question. My brain wasn’t fully caffeinated when I responded. While // is newer than divmod, the / operator used to perform integer division. So, x / y, x % y as a readability improvement has always been available.

Still, it is quite possible that divmod was quite a bit faster than x / y, x % y once upon a time. The interpreter has undergone a huge amount of optimization over the past 25 years or so. Still, removing divmod because it’s now slower than the paired expressions [edit: probably] wasn’t deemed worthwhile because it would break functioning code.

Plus, there’s a significant readability boost when doing chained divisions like with time conversions:

minutes, seconds = divmod(target_time - time(), 60)
hours, minutes = divmod(minutes, 60)
days, hours = divmod(hours, 24)

If you had to repeat the expression left and right, there’d be the risk of desynchronization bugs, but with divmod it’s obvious there can’t be.

(And believe you me, it is a PAIN to have to figure out what’s going on when you had something like days = hours / 60; hours %= 24 and you’re staring at bizarre output in total confusion.)


Its can be replaced exactly for int args but not for float args I recall.
And as Chris shows it is often clearer to get the pair back in one go.