# How can I force division to be floating point? Division keeps rounding down to 0?

## Question:

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 2 in the following?

```
c = a / b
```

## Answers:

```
c = a / (b * 1.0)
```

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.

In Python 2, division of two ints produces an int. In Python 3, it produces a float. We can get the new behaviour by importing from `__future__`

.

```
>>> from __future__ import division
>>> a = 4
>>> b = 6
>>> c = a / b
>>> c
0.66666666666666663
```

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.

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
```

This will also work

```
>>> u=1./5
>>> print u
0.2
```

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

Add a dot (`.`

) to indicate floating point numbers

```
>>> 4/3.
1.3333333333333333
```

```
from operator import truediv
c = truediv(a, b)
```

## 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?"

## Upgrade to Python 3

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.

## If Using Python 2

In Python 2, it’s not so simple. Some ways of dealing with classic Python 2 division are better and more robust than others.

### Recommendation for Python 2

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.

### Other Options for Python 2

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
```

### Not Recommended for Python 2

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
```

```
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.