I have two integer values a
and b
, but I need their ratio in floating point. I know that a < b
and I want to calculate a / b
, so if I use integer division I'll always get 0 with a remainder of a
.
How can I force c
to be a floating point number in Python in the following?
c = a / b
This question is related to
python
floating-point
integer
division
python-2.x
from operator import truediv
c = truediv(a, b)
from operator import truediv
c = truediv(a, b)
where a is dividend and b is the divisor. This function is handy when quotient after division of two integers is a float.
How can I force division to be floating point in Python?
I have two integer values a and b, but I need their ratio in floating point. I know that a < b and I want to calculate a/b, so if I use integer division I'll always get 0 with a remainder of a.
How can I force c to be a floating point number in Python in the following?
c = a / b
What is really being asked here is:
"How do I force true division such that a / b
will return a fraction?"
In Python 3, to get true division, you simply do a / b
.
>>> 1/2
0.5
Floor division, the classic division behavior for integers, is now a // b
:
>>> 1//2
0
>>> 1//2.0
0.0
However, you may be stuck using Python 2, or you may be writing code that must work in both 2 and 3.
In Python 2, it's not so simple. Some ways of dealing with classic Python 2 division are better and more robust than others.
You can get Python 3 division behavior in any given module with the following import at the top:
from __future__ import division
which then applies Python 3 style division to the entire module. It also works in a python shell at any given point. In Python 2:
>>> from __future__ import division
>>> 1/2
0.5
>>> 1//2
0
>>> 1//2.0
0.0
This is really the best solution as it ensures the code in your module is more forward compatible with Python 3.
If you don't want to apply this to the entire module, you're limited to a few workarounds. The most popular is to coerce one of the operands to a float. One robust solution is a / (b * 1.0)
. In a fresh Python shell:
>>> 1/(2 * 1.0)
0.5
Also robust is truediv
from the operator
module operator.truediv(a, b)
, but this is likely slower because it's a function call:
>>> from operator import truediv
>>> truediv(1, 2)
0.5
Commonly seen is a / float(b)
. This will raise a TypeError if b is a complex number. Since division with complex numbers is defined, it makes sense to me to not have division fail when passed a complex number for the divisor.
>>> 1 / float(2)
0.5
>>> 1 / float(2j)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: can't convert complex to float
It doesn't make much sense to me to purposefully make your code more brittle.
You can also run Python with the -Qnew
flag, but this has the downside of executing all modules with the new Python 3 behavior, and some of your modules may expect classic division, so I don't recommend this except for testing. But to demonstrate:
$ python -Qnew -c 'print 1/2'
0.5
$ python -Qnew -c 'print 1/2j'
-0.5j
Add a dot (.
) to indicate floating point numbers
>>> 4/3.
1.3333333333333333
You can cast to float by doing c = a / float(b)
. If the numerator or denominator is a float, then the result will be also.
A caveat: as commenters have pointed out, this won't work if b
might be something other than an integer or floating-point number (or a string representing one). If you might be dealing with other types (such as complex numbers) you'll need to either check for those or use a different method.
c = a / (b * 1.0)
If you want to use "true" (floating point) division by default, there is a command line flag:
python -Q new foo.py
There are some drawbacks (from the PEP):
It has been argued that a command line option to change the default is evil. It can certainly be dangerous in the wrong hands: for example, it would be impossible to combine a 3rd party library package that requires -Qnew with another one that requires -Qold.
You can learn more about the other flags values that change / warn-about the behavior of division by looking at the python man page.
For full details on division changes read: PEP 238 -- Changing the Division Operator
In Python 3.x, the single slash (/
) always means true (non-truncating) division. (The //
operator is used for truncating division.) In Python 2.x (2.2 and above), you can get this same behavior by putting a
from __future__ import division
at the top of your module.
This will also work
>>> u=1./5
>>> print u
0.2
Just making any of the parameters for division in floating-point format also produces the output in floating-point.
Example:
>>> 4.0/3
1.3333333333333333
or,
>>> 4 / 3.0
1.3333333333333333
or,
>>> 4 / float(3)
1.3333333333333333
or,
>>> float(4) / 3
1.3333333333333333
Source: Stackoverflow.com