# What does // mean in Python?

Share

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
``````
A Python Tip Every Week

Need to fill-in gaps in your Python skills? I send weekly emails designed to do just that.