这是在python中将float转换为int的有效方法

我一直在使用n = int(n)将float转换为int。

最近，我发现了另一种做同样事情的方法：

n = n // 1

哪种方法最有效，为什么？

用timeit:测试

$ bin/python -mtimeit -n10000000 -s 'n = 1.345' 'int(n)'
10000000 loops, best of 3: 0.234 usec per loop
$ bin/python -mtimeit -n10000000 -s 'n = 1.345' 'n // 1'
10000000 loops, best of 3: 0.218 usec per loop

因此，地板分割只是以很小的差距更快。请注意，这些值非常接近，我不得不提高循环重复次数，以消除对我的机器的随机影响。即使有这么高的计数，你也需要重复实验几次，看看数字仍然有多大变化，以及在大多数情况下，什么结果更快。

这是合乎逻辑的，因为int()需要全局查找和函数调用（因此状态被推送和弹出）：

>>> import dis
>>> def use_int(n):
...     return int(n)
... 
>>> def use_floordiv(n):
...     return n // 1
... 
>>> dis.dis(use_int)
  2           0 LOAD_GLOBAL              0 (int)
              3 LOAD_FAST                0 (n)
              6 CALL_FUNCTION            1
              9 RETURN_VALUE        
>>> dis.dis(use_floordiv)
  2           0 LOAD_FAST                0 (n)
              3 LOAD_CONST               1 (1)
              6 BINARY_FLOOR_DIVIDE 
              7 RETURN_VALUE

是LOAD_GLOBAL和CALL_FUNCTION操作码比LOAD_CONST和BINARY_FLOOR_DIVIDE操作码慢；LOAD_CONST是一个简单的数组查找，LOAD_GLOBAL需要进行字典查找。

将int()绑定到本地名称可以产生很小的差异，使其再次具有优势（因为它所做的工作比// 1楼层划分少）：

$ bin/python -mtimeit -n10000000 -s 'n = 1.345' 'int(n)'
10000000 loops, best of 3: 0.233 usec per loop
$ bin/python -mtimeit -n10000000 -s 'n = 1.345; int_=int' 'int_(n)'
10000000 loops, best of 3: 0.195 usec per loop
$ bin/python -mtimeit -n10000000 -s 'n = 1.345' 'n // 1'
10000000 loops, best of 3: 0.225 usec per loop

同样，您需要使用1000万个循环来运行此操作，以一致地查看差异。

也就是说，int(n)要明确得多，除非你在时间关键的循环中这样做，否则int(n)在可读性方面胜过n // 1。时间差异太小，以至于必须计算出// 1在这里做什么的认知成本是值得的。

尽管Martijn Pieters回答了您关于什么更快以及如何测试它的问题，但我觉得速度对于这样一个小操作来说并不那么重要。正如Inbar Rose所说，我会使用int（）来提高可读性。通常，在处理某些内容时，这种小的可读性要重要得多；不过，一个常见的方程式可能是一个例外。

实际上，int似乎比除法更快。缓慢的部分是在全局范围内查找函数。

如果我们避开它，以下是我的数字：

$ python -mtimeit -s 'i=int; a=123.456' 'i(a)'
10000000 loops, best of 3: 0.122 usec per loop
$ python -mtimeit -s 'i=int; a=123.456' 'a//1'
10000000 loops, best of 3: 0.145 usec per loop

太长；未阅读：

使用float.__trunc__()比builtins.int() 快30%

我喜欢长篇大论的解释：

@MartijnPieters绑定builtins.int的技巧确实很有趣，它让我想起了优化轶事。然而，调用builtins.int并不是最有效的。

让我们看看这个：

python -m timeit -n10000000 -s "n = 1.345" "int(n)"
10000000 loops, best of 5: 48.5 nsec per loop
python -m timeit -n10000000 -s "n = 1.345" "n.__trunc__()"
10000000 loops, best of 5: 33.1 nsec per loop

这是30%的收益！这里发生了什么？

事实证明，builtints.int所做的只是调用以下方法链：

如果定义了1.345.__int__，则返回1.345.__int__() else:
如果定义了1.345.__index__，则返回1.345.__index__() else:
如果定义了1.345.__trunc__，则返回1.345.__trunc__()

1.345.__int__没有被定义为¹-，1.345.__index__也没有被定义。因此，直接调用1.345.__trunc__()允许我们跳过所有不必要的方法调用，这是相对昂贵的。

捆绑技巧怎么样？float.__trunc__本质上只是一个实例方法，我们可以传递1.345作为self参数。

python -m timeit -n10000000 -s "n = 1.345; f=int" "f(n)"
10000000 loops, best of 5: 43 nsec per loop
python -m timeit -n10000000 -s "n = 1.345; f=float.__trunc__" "f(n)"
10000000 loops, best of 5: 27.4 nsec per loop

两种方法都按照预期的²进行了改进，并且它们保持大致相同的比例！

¹我对此并不完全确定——如果有人知道的话，请纠正我。

²这让我很惊讶，因为我认为float.__trunc__在创建实例时绑定到了1.345。如果有人能向我解释一下那就太好了。

还有一种方法builtins.float.__floor__，文档中没有提到，它比builtins.int快，但比buitlins.float.__trunc__慢。

python -m timeit -n10000000 -s "n = 1.345; f=float.__floor__" "f(n)"
10000000 loops, best of 5: 32.4 nsec per loop

它似乎在负浮动和正浮动上都产生了相同的结果。如果有人能解释一下这在其他方法中是如何适用的，那就太棒了。

请注意，您没有使用float除法运算符将float转换为int。此操作的结果仍然是一个浮点值。在Python 2.7.5（CPython）中，n=n//1与完全相同

n.__floordiv__(1)

这与基本相同

n.__divmod__(1)[0]

两个函数都返回一个float而不是int。在CPython __divmod__函数中，分母和分子必须从PyObject转换为double。因此，在这种情况下，使用floor函数而不是//运算符会更快，因为只需要一次转换。

from cmath import floor
n=floor(n)

如果您真的想将浮点值转换为整数，我认为没有任何方法可以提高int（n）的性能。

只是一个有趣的统计测试-将测试时间更改为您喜欢的时间：

import timeit
from scipy import mean, std, stats, sqrt
# Parameters:
reps = 100000
dups = 50
signif = 0.01
timeit_setup1 = 'i=int; a=123.456'
timeit_test1 = 'i(a)'
timeit_setup2 = 'i=int; a=123.456'
timeit_test2 = 'a//1'
#Some vars
t1_data = []
t2_data = []
frmt = '{:.3f}'
testformat = '{:<'+ str(max([len(timeit_test1), len(timeit_test2)]))+ '}'
def reportdata(mylist):
    string = 'mean = ' + frmt.format(mean(mylist)) + ' seconds, st.dev. = ' + 
             frmt.format(std(mylist))
    return string
for i in range(dups):
    t1_data.append(timeit.timeit(timeit_test1, setup = timeit_setup1,
                                    number = reps))
    t2_data.append(timeit.timeit(timeit_test2, setup = timeit_setup2,
                                    number = reps))
print testformat.format(timeit_test1) + ':', reportdata(t1_data)
print testformat.format(timeit_test2) + ':', reportdata(t2_data)
ttest = stats.ttest_ind(t1_data, t2_data)
print 't-test: the t value is ' + frmt.format(float(ttest[0])) + 
      ' and the p-value is ' + frmt.format(float(ttest[1]))
isit = ''
if float(ttest[1]) > signif:
    isit = "not "
print 'The difference of ' + 
      '{:.2%}'.format(abs((mean(t1_data)-mean(t2_data))/mean(t1_data))) + 
      ' +/- ' + 
      '{:.2%}'.format(3*sqrt((std(t1_data)**2 + std(t2_data)**2)/dups)) + 
      ' is ' + isit + 'significative.'

太长；未阅读：

我喜欢长篇大论的解释：

相关内容

最新更新

热门标签：