I tested similar time complexity of both methods.

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

Output is:

# function floor takes 11.841985
# function int   takes 11.841325

1. math.floor(N) returns an int, and N // 1 returns a float.

   >>> type(math.floor(-4.4))
   <class 'int'>
   >>> type((-4.4) // 1)
   <class 'float'>
   

2. Because of this floor(nan) will raise ValueError while nan // 1 returns NaN (similar for ±inf.)

   >>> math.floor(math.nan)
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   ValueError: cannot convert float NaN to integer
   >>> math.nan // 1
   nan
   

I don't think there are other differences when N is a float, since x//y is defined as ⌊x/y⌋.

The range of floating point numbers usually exceeds the range of integers. By returning a floating point value, the functions can return a sensible value for input values that lie outside the representable range of integers.

Consider: If floor() returned an integer, what should floor(1.0e30) return?

Now, while Python's integers are now arbitrary precision, it wasn't always this way. The standard library functions are thin wrappers around the equivalent C library functions.