floor() * 向下舍入 *。int() * 截断 *。使用负数时，差异很明显：

>>> import math
>>> math.floor(-3.5)
-4
>>> int(-3.5)
-3

对负数进行向下舍入意味着它们远离0，而截断则使它们更接近0。
换句话说，floor()总是会小于或等于原始值，int()会更接近零或等于零。

我测试了两种方法的时间复杂度，它们是相同的。

from time import time
import math
import random

r = 10000000
def floorTimeFunction():
    for i in range(r):
        math.floor(random.randint(-100,100))

def intTimeFunction():
    for i in range(r):
        int(random.randint(-100,100))

t0 = time()
floorTimeFunction()
t1 = time()
intTimeFunction()
t2 = time()

print('function floor takes %f' %(t1-t0))
print('function int     takes %f' %(t2-t1))

输出为：

# function floor takes 11.841985
# function int   takes 11.841325

我写了这个方法，它很有用，

def rightInteger(numa, numb):
    result = numa/numb
    next_int = math.ceil(result)
    difference = next_int -result
    if(difference <=0.5):
        return next_int
    else:
        return math.floor(result)

四舍五入的方式有很多种，有些方法是等效的，如内置的int、numpy.trunc、numpy.fix，可以对数字进行舍位。表示对于负数，它们返回的结果大于参数。floor不同，它实际上返回下一个较小的整数，而不考虑符号。这可能会引起混淆。in和numpy运算符：

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
         ROUNDING   -4   -3 -2.8 -2.5 -2.2   -2   -1    0    1  2.2  2.5  2.8    3    4
┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈
            floor   -4   -3   -3   -3   -3   -2   -1    0    1    2    2    2    3    4
             rint   -4   -3   -3   -2   -2   -2   -1    0    1    2    2    3    3    4
        round (0)   -4   -3   -3   -2   -2   -2   -1    0    1    2    2    3    3    4
              fix   -4   -3   -2   -2   -2   -2   -1    0    1    2    2    2    3    4
            (int)   -4   -3   -2   -2   -2   -2   -1    0    1    2    2    2    3    4
            trunc   -4   -3   -2   -2   -2   -2   -1    0    1    2    2    2    3    4
             ceil   -4   -3   -2   -2   -2   -2   -1    0    1    3    3    3    3    4
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━