283

Consider this division in Python 3:

>>> 2/2
1.0

Is this intended? I strongly remember earlier versions returning int/int = int. What should I do? Is there a new division operator or must I always cast?

In 2.x, the behaviour was indeed reversed; see How can I force division to be floating point? Division keeps rounding down to 0? for the opposite, 2.x-specific problem.

Improve this question
6
  • 43
    Yes, that's the way division works in 3.x. Commented Aug 15, 2009 at 22:49
  • 3
    Here's a post by Python's creator talking about how the rounding works, it's orthogonal to your question but I found it interesting: python-history.blogspot.com/2010/08/… Commented Feb 28, 2013 at 16:59
  • @hughdbrown so that means for all python 3 version essentially? Commented Feb 24, 2017 at 22:36
  • @hughdbrown: yes, PEP is final, meaning both accepted and implemented. Commented Mar 2, 2017 at 9:40
  • 2
    @brianlmerritt depends on what you're doing and why. Working in integer arithmetic is more straightforward, and problems with precision can typically be addressed by just making sure that multiplications happen before divisions: 480 * 320 // 640 wives the expected 240. Commented Oct 13, 2022 at 18:19

5 Answers 5

Reset to default
336

Take a look at PEP-238: Changing the Division Operator

The // operator will be available to request floor division unambiguously.

Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

@JonathanSternberg except for all the code that was written for python 2.0. I feel like the role of / and // should be reversed to keep backwards compatibility. Also, in pretty much every other language / preserves type. i would make more sense then for // to automatically convert to float, not /.
The second part (after the "Also") makes sense (similarity to other languages) but regarding the first part, the whole point of Python 3 was to NOT be backwards compatible with Python 2, but rather fix up a bunch of problems with Python 2. Enough people found the ambiguity of / to be enough of a language design "mistake" that needed to be fixed in Python 3. It may have been a controversial decision, but enough people felt it was the correct one. Count me in the group that loves the change. It is nice we can all agree to disagree. Cheers. :)
I understand the reason why Python does it in the instances of the answer not being #.0, but not for instances where the answer is #.0. Float 1.0 is the same as integer 1, so when the numbers being calculated are integers that result in a float that's the equivalent of an integer, why not just return or print an integer? That at least keeps the types consistent and intuitive. If an answer would include a non-zero decimal number, then the float should be returned. Other languages I've used work this way (smartly), none of them return #.0 when the answer is an integer.
79

Oops, immediately found 2//2. This will output an int rather than a float.

Improve this answer

7 Comments

This seems to not work for negative numbers. -1//5 return -1 and -5//5 returns -1.
@mschuett: this is to be expected, and is the same result as with Python 2.
Yeah I did some more digging and found that out as well. However I would imagine a decent size number of people do not realize this depending on the language they come from.
@TylerH I doubt there was any confusion in the past 12 years that warranted your edit?
// only yields an int if the two divisors are ints.
|
61

Behavior of the division operator in Python 2.7 and Python 3

In Python 2.7: By default, division operator will return integer output.

To get the result in double, multiply the dividend or divisor by 1.0.

100/35 => 2 # Expected is 2.857142857142857
(100*1.0)/35 => 2.857142857142857
100/(35*1.0) => 2.857142857142857

In Python 3

// => used for integer output
/ => used for double output

100/35 => 2.857142857142857
100//35 => 2
100.//35 => 2.0    # Floating-point result if the divisor or dividend is real
Improve this answer

2 Comments

By the way, no need to multiply by 1.0. It is enough that one of the numbers is a float. E.g., 100/35.0 = 100.0/35 = 2.857142857142857
// is not "used for integer output". // is the result of the floor() function to the result of the division, which in turns yields an integer if the two operands are integers and a float if at least one of them is a float, for types coherence.
25

The accepted answer already mentions PEP 238. I just want to add a quick look behind the scenes for those interested in what's going on without reading the whole PEP.

Python maps operators like +, -, * and / to special functions, such that e.g. a + b is equivalent to

a.__add__(b)

Regarding division in Python 2, there is by default only / which maps to __div__ and the result is dependent on the input types (e.g. int, float).

Python 2.2 introduced the __future__ feature division, which changed the division semantics the following way (TL;DR of PEP 238):

  • / maps to __truediv__ which must "return a reasonable approximation of the mathematical result of the division" (quote from PEP 238)
  • // maps to __floordiv__, which should return the floored result of /

With Python 3.0, the changes of PEP 238 became the default behaviour and there is no more special method __div__ in Python's object model.

If you want to use the same code in Python 2 and Python 3 use

from __future__ import division

and stick to the PEP 238 semantics of / and //.

Improve this answer

Comments

0

In Python 3, the standard division operator (/) always performs "true division" and returns a float result, even if both operands are integers and the division results in a whole number.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.