What does // mean in Python?

What does Python's // operator do? How is it different from the / operator?

The / operator

The / operator is the division operator in Python.

When / is used between two numbers, you'll always get the exact (as exact as Python can manage) result back:

>>> 5 / 2
2.5

Unlike some programming languages, / in Python does not act any differently when used between integers; in Python 3 that is. In Python 2, division between two integers would would the result downward to the nearest integer:

>>> 5 / 2  # Python 2
2

But in Python 3, division between two integers always returns a floating point number with the exact result:

>>> 4 / 2
2.0

The // operator between integers

The // operator is the floor division operator in Python. When // is used between two integers, you'll always get an integer back:

>>> 5 // 2
2

The // operator provides divides while rounding the result down to the nearest integer. This is often called integer division or floor division.

When using // with a floating point number, you'll get a floating point number back:

>>> 5.0 // 2
2.0

But, just as with integers, that floating point number will also be rounded down to the nearest integer.

When should you use // in Python?

If you've ever seen code like this:

>>> n = 5
>>> int(n / 2)
2

Then you've likely witnessed an opportunity to use the // operator. If you're dividing and then immediately converting the result to an integer, you could probably use the // operator instead.

In this split_in_half function, we're using the int function to make sure the mid_point value is an integer:

def split_in_half(sequence):
    """Return two halves of given sequence (list, string, etc)."""
    mid_point = int(len(sequence) / 2)
    return sequence[:mid_point], sequence[mid_point:]

The numbers we're dividing are both integers, so we could use // to force an integer result:

def split_in_half(sequence):
    """Return two halves of given sequence (list, string, etc)."""
    mid_point = len(sequence) // 2
    return sequence[:mid_point], sequence[mid_point:]

This is a bit more efficient than dividing to get an exact floating point number and then flooring that floating point number to get back to an integer.

Note that // always rounds down

Before you go about replacing all the uses of int(a / b) in your code with a // b, you should note that these two act differently when the result of the division is a negative number:

Let's say we divide and the result is -2.5:

>>> a = -5
>>> b = 2
>>> a / 2
-2.5

When using / and int, we'll end up with -2 but when dividing with // we'll get -3 instead:

>>> int(a / 2)
-2
>>> a // 2
-3

The // operator always rounds down. It acts less like the built-in int function and more like math.floor:

>>> from math import floor
>>> floor(a / 2)
-3
>>> a // 2
-3

Also remember that a // b returns a floating point number when either a or b are floating point numbers.

>>> a = 52.0
>>> b = 4
>>> a // b
13.0

So you'll most likely want to stick to using // only for division between positive integers.

Using divmod instead

What if you want both integer division (with //) and the remainder of that division (with %):

>>> duration = 500
>>> minutes = duration // 60
>>> seconds = duration % 60
>>> print(f"{minutes}:{seconds}")
8:20

Instead of using // and % separately, you could use the divmod function to get both results at once:

>>> duration = 500
>>> minutes, seconds = divmod(duration, 60)
>>> print(f"{minutes}:{seconds}")
8:20

In theory, this could be optimized to perform both operations at once, but in practice CPython doesn't perform that optimization so this is primarily about readability.

Sometimes divmod can make for considerably more readable code. For example here we're using // and % cleverly to get hours, minutes, and seconds:

>>> duration = 9907
>>> hours = duration // (60 * 60)
>>> minutes = (duration // 60) % 60
>>> seconds = duration % 60
>>> print(f"{hours}:{minutes:02d}:{seconds:02d}")
2:46:07

But we could use divmod twice instead:

>>> duration = 9907
>>> minutes, seconds = divmod(duration, 60)
>>> hours, minutes = divmod(minutes, 60)
>>> print(f"{hours}:{minutes:02d}:{seconds:02d}")
2:46:07

I find that divmod approach much clearer than the alternative uses of // and %. If you need both the quotient (to use a math term) and the remainder of your division, consider using divmod.

Note: if you're curious about that :02d syntax above, see zero-padding in f-strings.

Use // for integer division

For most uses of division in Python, you'll likely use / because precise answers are often desirable:

>>> amount = 67
>>> groups = 9
>>> per_portion = amount / groups
>>> per_portion
7.444444444444445

But in rare moments when you want floor division (a.k.a. integer division) you'll want the // operator.

>>> amount = 67
>>> groups = 9
>>> minimum_per_group = amount // groups
>>> minimum_per_group
7

If you want both a remainder % and integer division //, also keep Python's divmod function in mind.

>>> duration = 784
>>> minutes, seconds = divmod(duration, 60)
>>> print(f"{minutes}m{seconds}s")
13m4s