Hello,
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…
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
times[c].append(t)
for c in codes:
print(stats(c), c)
print('\nPython:', sys.version)
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.