Is there a benefit to using one over the other? In Python 2, they both seem to return the same results:

>>> 6/3 2 >>> 6//3 2

Skip to content
# python – What is the difference between ‘/’ and ‘//’ when used for division?

## The Question :

*494 people think this question is useful*
*The Question Comments :*
## The Answer 1

*688 people think this answer is useful*
## The Answer 2

*70 people think this answer is useful*
### Python 2.x Clarification:

## The Answer 3

*33 people think this answer is useful*
## The Answer 4

*30 people think this answer is useful*
## The Answer 5

*22 people think this answer is useful*
## The Answer 6

*12 people think this answer is useful*
## The Answer 7

*6 people think this answer is useful*
## The Answer 8

*4 people think this answer is useful*
## The Answer 9

*3 people think this answer is useful*
## The Answer 10

*2 people think this answer is useful*
## The Answer 11

*2 people think this answer is useful*
## The Answer 12

*-1 people think this answer is useful*
## The Answer 13

*-1 people think this answer is useful*

2021-01-13

Is there a benefit to using one over the other? In Python 2, they both seem to return the same results:

>>> 6/3 2 >>> 6//3 2

- Please refer The Problem with Integer Division for the reason for introducing the
`//`

operator to do integer division.

In Python 3.x, `5 / 2`

will return `2.5`

and `5 // 2`

will return `2`

. The former is floating point division, and the latter is ** floor division**, sometimes also called

In Python 2.2 or later in the 2.x line, there is no difference for integers unless you perform a `from __future__ import division`

, which causes Python 2.x to adopt the 3.x behavior.

Regardless of the future import, `5.0 // 2`

will return `2.0`

since that’s the floor division result of the operation.

You can find a detailed description at https://docs.python.org/whatsnew/2.2.html#pep-238-changing-the-division-operator

To clarify for the Python 2.x line, `/`

is neither floor division nor true division. The current accepted answer is not clear on this.

`/`

is floor division when **both** args are `int`

, but is true division when **either or both** of the args are `float`

.

The above tells more truth, and is more clear than the 2nd paragraph in the accepted answer.

`//`

implements “floor division”, regardless of your type. So
`1.0/2.0`

will give `0.5`

, but both `1/2`

, `1//2`

and `1.0//2.0`

will give `0`

.

See https://docs.python.org/whatsnew/2.2.html#pep-238-changing-the-division-operator for details

**/** –> Floating point division

**//** –> Floor division

Lets see some examples in both python 2.7 and in Python 3.5.

**Python 2.7.10 vs. Python 3.5**

print (2/3) ----> 0 Python 2.7 print (2/3) ----> 0.6666666666666666 Python 3.5

**Python 2.7.10 vs. Python 3.5**

print (4/2) ----> 2 Python 2.7 print (4/2) ----> 2.0 Python 3.5

Now if you want to have (in python 2.7) same output as in python 3.5, you can do the following:

**Python 2.7.10**

from __future__ import division print (2/3) ----> 0.6666666666666666 #Python 2.7 print (4/2) ----> 2.0 #Python 2.7

Where as there is no differece between Floor division in both python 2.7 and in Python 3.5

138.93//3 ---> 46.0 #Python 2.7 138.93//3 ---> 46.0 #Python 3.5 4//3 ---> 1 #Python 2.7 4//3 ---> 1 #Python 3.5

As everyone has already answered, `//`

is floor division.

Why this is important is that `//`

is unambiguously floor division, in all Python versions from 2.2, including Python 3.x versions.

The behavior of `/`

can change depending on:

- Active
`__future__`

import or not (module-local) - Python command line option, either
`-Q old`

or`-Q new`

>>> print 5.0 / 2 2.5 >>> print 5.0 // 2 2.0

Python 2.7 and other upcoming version of python:

- Division (
`/`

)

Divides left hand operand by right hand operand

Example: `4 / 2 = 2`

- Floor Division (
`//`

)

The division of operands where the result is the quotient in which the digits after the decimal point are removed. But if one of the operands is negative, the result is floored, i.e., rounded away from zero (towards negative infinity):

Examples: `9//2 = 4`

and `9.0//2.0 = 4.0`

, `-11//3 = -4`

, `-11.0//3 = -4.0`

Both `/`

Division and `//`

floor division operator are operating in similar fashion.

The double slash, `//`

, is floor division:

>>> 7//3 2

`//`

is floor division, it will always give you the integer floor of the result. The other is ‘regular’ division.

The answer of the equation is rounded to the next smaller integer or float with .0 as decimal point.

>>>print 5//2 2 >>> print 5.0//2 2.0 >>>print 5//2.0 2.0 >>>print 5.0//2.0 2.0

The above answers are good. I want to add another point. Up to some values both of them result in the same quotient. After that floor division operator (`//`

) works fine but not division (`/`

) operator.

- > int(755349677599789174/2) - > 377674838799894592 #wrong answer - > 755349677599789174 //2 - > 377674838799894587 #correct answer

`5.0//2`

results in `2.0`

, and not `2`

because the **return type** of the return value from `//`

operator follows python coercion (type casting) rules.

Python promotes conversion of lower datatype (integer) to higher data type (float) to avoid data loss.

`//`

is floor division, it will always give you the floor value of the result.- And the other one
`/`

is the floating-point division.

Followings are the difference between `/`

and `//`

;
I have run these arithmetic operations in Python 3.7.2

>>> print (11 / 3) 3.6666666666666665 >>> print (11 // 3) 3 >>> print (11.3 / 3) 3.7666666666666667 >>> print (11.3 // 3) 3.0