I saw this in someone's code:
y = img_index // num_images where img_index is a running index and num_images is 3.
When I mess around with // in IPython, it seems to act just like a division sign (i.e. one forward slash). I was just wondering if there is any reason for having double forward slashes?
5 Answers
In Python 3, they made the / operator do a floating-point division, and added the // operator to do integer division (i.e., quotient without remainder); whereas in Python 2, the / operator was simply integer division, unless one of the operands was already a floating point number.
In Python 2.X:
>>> 10/3 3 >>> # To get a floating point number from integer division: >>> 10.0/3 3.3333333333333335 >>> float(10)/3 3.3333333333333335 In Python 3:
>>> 10/3 3.3333333333333335 >>> 10//3 3 For further reference, see PEP238.
6// is unconditionally "flooring division", e.g:
>>> 4.0//1.5 2.0 As you see, even though both operands are floats, // still floors -- so you always know securely what it's going to do.
Single / may or may not floor depending on Python release, future imports, and even flags on which Python's run, e.g.:
$ python2.6 -Qold -c 'print 2/3' 0 $ python2.6 -Qnew -c 'print 2/3' 0.666666666667 As you see, single / may floor, or it may return a float, based on completely non-local issues, up to and including the value of the -Q flag...;-).
So, if and when you know you want flooring, always use //, which guarantees it. If and when you know you don't want flooring, slap a float() around other operand and use /. Any other combination, and you're at the mercy of version, imports, and flags!-)
To complement these other answers, the // operator also offers significant (3x) performance benefits over /, presuming you want integer division.
$ python -m timeit '20.5 // 2' 100,000,000 loops, best of 3: 14.9 nsec per loop $ python -m timeit '20.5 / 2' 10,000,000 loops, best of 3: 48.4 nsec per loop $ python -m timeit '20 / 2' 10,000,000 loops, best of 3: 43.0 nsec per loop $ python -m timeit '20 // 2' 100,000,000 loops, best of 3: 14.4 nsec per loop To complement Alex's response, I would add that starting from Python 2.2.0a2, from __future__ import division is a convenient alternative to using lots of float(…)/…. All divisions perform float divisions, except those with //. This works with all versions from 2.2.0a2 on.
// can be considered an alias to math.floor() for divisions with return value of type float. It operates as no-op for divisions with return value of type int.
import math # let's examine `float` returns # ------------------------------------- # divide >>> 1.0 / 2 0.5 # divide and round down >>> math.floor(1.0/2) 0.0 # divide and round down >>> 1.0 // 2 0.0 # now let's examine `integer` returns # ------------------------------------- >>> 1/2 0 >>> 1//2 0 
