## The Question :

*439 people think this question is useful*

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?

*The Question Comments :*

## The Answer 1

*544 people think this answer is useful*

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.

## The Answer 2

*187 people think this answer is useful*

`//`

is unconditionally “flooring division”, e.g:

>>> 4.0//1.5
2.0

As you see, even though both operands are `float`

s, `//`

*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!-)

## The Answer 3

*22 people think this answer is useful*

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

## The Answer 4

*21 people think this answer is useful*

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.

## The Answer 5

*9 people think this answer is useful*

`//`

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