45

I have found two ways of taking floors in Python:

3.1415 // 1

and 

import math
math.floor(3.1415)

The problem with the first approach is that it return a float (namely 3.0). The second approach feels clumsy and too long.

Are there alternative solutions for taking floors in Python?

Martin Vseticka
  • 25,160
  • 25
  • 118
  • 187
Randomblue
  • 98,379
  • 133
  • 328
  • 526

6 Answers6

69

As long as your numbers are positive, you can simply convert to an int to round down to the next integer:

>>> int(3.1415)
3

For negative integers, this will round up, though.

Sven Marnach
  • 483,142
  • 107
  • 864
  • 776
  • To get any number (positive as well as negative) to round down, there's still `int(n // 1)`, like `int(-3.14 // 1)` that gives `-4`. Of course this is only useful if negative numbers might show up. – zezollo Jun 05 '17 at 15:27
  • @zezollo Unless you want to confuse readers of your code, using `int(math.floor(x))` is preferable over floor division by 1, since it's immediately obvious what it does. – Sven Marnach Jun 06 '17 at 12:49
13

You can call int() on the float to cast to the lower int (not obviously the floor but more elegant)

int(3.745)  #3

Alternatively call int on the floor result.

from math import floor

f1 = 3.1415
f2 = 3.7415

print floor(f1)       # 3.0
print int(floor(f1))  # 3
print int(f1)         # 3
print int(f2)         # 3 (some people may expect 4 here)
print int(floor(f2))  # 3

http://docs.python.org/library/functions.html#int

Matt Alcock
  • 10,631
  • 13
  • 41
  • 59
6

The second approach is the way to go, but there's a way to shorten it.

from math import floor
floor(3.1415)
Mark Ransom
  • 271,357
  • 39
  • 345
  • 578
  • 2
    `floor()` returns an integer in python3, but in python2 it returns float. – Eugene Yarmash Apr 09 '13 at 14:12
  • @eugeney, I was just pointing out that there was a way to leave off the `math.` part. I wonder why they didn't complain about getting a `float` result back from `floor` in the first place? And thanks for informing me of that change from 2 to 3, I didn't know that one. It makes sense, `floor` couldn't return an `int` until arbitrary size integers were interchangeable with normal ints starting in 2.4. – Mark Ransom Apr 09 '13 at 16:42
4

Cast it to int if you don't want a float

int(3.1415 // 1)
mVChr
  • 46,510
  • 10
  • 101
  • 99
3

Beware that taking the floor and casting to an int are not the same thing with negative numbers. If you really want the floor as an integer, you should cast to an int after calling math.floor().

>>> int(-0.5)
0
>>> math.floor(-0.5)
-1.0
>>> int(math.floor(-0.5))
-1
camomilk
  • 637
  • 4
  • 14
0
from math import floor


def ff(num, step=0):
    if not step:
        return floor(num)
    if step < 0:
        mplr = 10 ** (step * -1)
        return floor(num / mplr) * mplr
    ncnt = step
    if 1 > step > 0:
        ndec, ncnt = .0101, 1
        while ndec > step:
            ndec *= .1
            ncnt += 1
    mplr = 10 ** ncnt
    return round(floor(num * mplr) / mplr, ncnt)

You can use positive/negative numbers and float points .1, .01, .001...

Vadim
  • 1