1

我有一个看起来像这样的代码：

def somefunction(somelist):
    for item in somelist:
        if len(item) > 10:
            do something
        elif len(item) > 6:
            do something
        elif len(item) > 3:
            do something
        else:
            do something

由于我多次调用 len(item) ，这样做是否效率低下？最好按如下方式编写代码，还是它们的性能完全相同？

def somefunction(somelist):
    for item in somelist:
        x = len(item)
        if x > 10:
            do something
        elif x > 6:
            do something
        elif x > 3:
            do something
        else:
            do something
4

5 回答 5

2

len() 是O(1)操作。这意味着调用len()的成本非常便宜。所以，别再担心了，更好地改进代码的其他部分。

不过，我个人认为第二种方式更好。因为如果我将您的变量名称从 更改x为length，它将增加您的代码的可读性。

def somefunction(somelist):
    for item in somelist:
        length = len(item)
        if length > 10:
            do something
        elif length > 6:
            do something
        elif length > 3:
            do something
        else:
            do something

注意： len( )是 O(1)，包含字符串、集合和字典。

于 2013-04-02T12:48:54.267 回答
2

第二种方法肯定更好，因为调用的次数len()减少了：

In [16]: import dis

In [18]: lis=["a"*10000,"b"*10000,"c"*10000]*1000

In [19]: def first():
    for item in lis:
        if len(item)<100:
            pass
        elif 100<len(item)<200:
            pass
        elif 300<len(item)<400:
            pass
   ....:         

In [20]: def second():
    for item in lis:
        x=len(item)
        if x<100:
                pass
        elif 100<x<200:
                pass
        elif 300<x<400:
                pass
   ....:

您始终可以使用timeit模块对代码进行计时：

In [21]: %timeit first()
100 loops, best of 3: 2.03 ms per loop

In [22]: %timeit second()
1000 loops, best of 3: 1.66 ms per loop

用于dis.dis()查看将 Python 字节码反汇编成助记符

In [24]: dis.dis(first)
  2           0 SETUP_LOOP             109 (to 112)
              3 LOAD_GLOBAL              0 (lis)
              6 GET_ITER            
        >>    7 FOR_ITER               101 (to 111)
             10 STORE_FAST               0 (item)

  3          13 LOAD_GLOBAL              1 (len)
             16 LOAD_FAST                0 (item)
             19 CALL_FUNCTION            1
             22 LOAD_CONST               1 (100)
             25 COMPARE_OP               0 (<)
             28 POP_JUMP_IF_FALSE       34

  4          31 JUMP_ABSOLUTE            7

  5     >>   34 LOAD_CONST               1 (100)
             37 LOAD_GLOBAL              1 (len)
             40 LOAD_FAST                0 (item)
             43 CALL_FUNCTION            1
             46 DUP_TOP             
             47 ROT_THREE           
             48 COMPARE_OP               0 (<)
             51 JUMP_IF_FALSE_OR_POP    63
             54 LOAD_CONST               2 (200)
             57 COMPARE_OP               0 (<)
             60 JUMP_FORWARD             2 (to 65)
        >>   63 ROT_TWO             
             64 POP_TOP             
        >>   65 POP_JUMP_IF_FALSE       71

  6          68 JUMP_ABSOLUTE            7

  7     >>   71 LOAD_CONST               3 (300)
             74 LOAD_GLOBAL              1 (len)
             77 LOAD_FAST                0 (item)
             80 CALL_FUNCTION            1
             83 DUP_TOP             
             84 ROT_THREE           
             85 COMPARE_OP               0 (<)
             88 JUMP_IF_FALSE_OR_POP   100
             91 LOAD_CONST               4 (400)
             94 COMPARE_OP               0 (<)
             97 JUMP_FORWARD             2 (to 102)
        >>  100 ROT_TWO             
            101 POP_TOP             
        >>  102 POP_JUMP_IF_FALSE        7

  8         105 JUMP_ABSOLUTE            7
            108 JUMP_ABSOLUTE            7
        >>  111 POP_BLOCK           
        >>  112 LOAD_CONST               0 (None)
            115 RETURN_VALUE        

In [25]: dis.dis(second)
  2           0 SETUP_LOOP             103 (to 106)
              3 LOAD_GLOBAL              0 (lis)
              6 GET_ITER            
        >>    7 FOR_ITER                95 (to 105)
             10 STORE_FAST               0 (item)

  3          13 LOAD_GLOBAL              1 (len)
             16 LOAD_FAST                0 (item)
             19 CALL_FUNCTION            1
             22 STORE_FAST               1 (x)

  4          25 LOAD_FAST                1 (x)
             28 LOAD_CONST               1 (100)
             31 COMPARE_OP               0 (<)
             34 POP_JUMP_IF_FALSE       40

  5          37 JUMP_ABSOLUTE            7

  6     >>   40 LOAD_CONST               1 (100)
             43 LOAD_FAST                1 (x)
             46 DUP_TOP             
             47 ROT_THREE           
             48 COMPARE_OP               0 (<)
             51 JUMP_IF_FALSE_OR_POP    63
             54 LOAD_CONST               2 (200)
             57 COMPARE_OP               0 (<)
             60 JUMP_FORWARD             2 (to 65)
        >>   63 ROT_TWO             
             64 POP_TOP             
        >>   65 POP_JUMP_IF_FALSE       71

  7          68 JUMP_ABSOLUTE            7

  8     >>   71 LOAD_CONST               3 (300)
             74 LOAD_FAST                1 (x)
             77 DUP_TOP             
             78 ROT_THREE           
             79 COMPARE_OP               0 (<)
             82 JUMP_IF_FALSE_OR_POP    94
             85 LOAD_CONST               4 (400)
             88 COMPARE_OP               0 (<)
             91 JUMP_FORWARD             2 (to 96)
        >>   94 ROT_TWO             
             95 POP_TOP             
        >>   96 POP_JUMP_IF_FALSE        7

  9          99 JUMP_ABSOLUTE            7
            102 JUMP_ABSOLUTE            7
        >>  105 POP_BLOCK           
        >>  106 LOAD_CONST               0 (None)
            109 RETURN_VALUE
于 2013-04-02T12:54:17.947 回答
1

Python 不像大多数其他语言那样自动优化事物（除非你使用 PyPy），所以第二个版本可能更快。但除非item有一个len需要一段时间的自定义实现，否则它可能也不会加快速度。在分析表明存在问题后，这种微优化应该保留给紧密的内部循环。

于 2013-04-02T12:44:37.010 回答
1

您可以通过以下方式检查此类事情dis.dis：

import dis

def somefunction1(item):
    if len(item) > 10:
        print 1
    elif len(item) > 10:
        print 2

def somefunction2(item):
    x = len(item)
    if x > 10:
        print 1
    elif x > 10:
        print 2

print "#1"
dis.dis(somefunction1)

print "#2"
dis.dis(somefunction2)

解释输出：

#1
  4           0 LOAD_GLOBAL              0 (len)
              3 LOAD_FAST                0 (item)
              6 CALL_FUNCTION            1
              9 LOAD_CONST               1 (10)
             12 COMPARE_OP               4 (>)
             15 POP_JUMP_IF_FALSE       26
[...]
  6     >>   26 LOAD_GLOBAL              0 (len)
             29 LOAD_FAST                0 (item)
             32 CALL_FUNCTION            1
             35 LOAD_CONST               1 (10)
             38 COMPARE_OP               4 (>)
             41 POP_JUMP_IF_FALSE       52
[...]
#2
 10           0 LOAD_GLOBAL              0 (len)
              3 LOAD_FAST                0 (item)
              6 CALL_FUNCTION            1
              9 STORE_FAST               1 (x)

 11          12 LOAD_FAST                1 (x)
             15 LOAD_CONST               1 (10)
             18 COMPARE_OP               4 (>)
             21 POP_JUMP_IF_FALSE       32
[...]
 13     >>   32 LOAD_FAST                1 (x)
             35 LOAD_CONST               1 (10)
             38 COMPARE_OP               4 (>)
             41 POP_JUMP_IF_FALSE       52

您可以看到，在第一个示例中，len(item)它被调用了两次（看到这两个CALL_FUNCTION语句吗？），而在第二个实现中它只被调用了一次。

这意味着您的问题的其余部分归结为如何len()实现 - 例如列表是 O(1) （即便宜），但特别是对于您可能自己构建的列表，它不需要。

于 2013-04-02T12:48:25.313 回答
1

Python 不会使两者等价。原因是两者对于任意函数是不等价的。让我们考虑这个函数x()：

y = 1

def x():
    return 1

而这两个测试：

>>> print(x() + y)
2
>>> print(x() + y)
2

和：

>>> hw = x()
>>> print(hw + y)
2
>>> print(hw + y)
2

这些是完全一样的，但是，如果我们的函数有副作用怎么办？

y = 1

def x():
    global y
    y += 1
    return 1

第一种情况：

>>> print(x() + y)
3
>>> print(x() + y)
4

第二种情况：

>>> hw = x()
>>> print(hw + y)
3
>>> print(hw + y)
3

你可以看到这个优化只有在函数没有副作用的情况下才有效，否则它会改变程序。由于 Python 无法判断函数是否具有副作用，因此无法进行此优化。

因此，将值存储在本地并重复使用它是有意义的，而不是一次又一次地调用该函数，尽管现实情况是它不太重要，因为差异很小。也就是说，它也更具可读性，意味着您不必重复很多次，因此以这种方式编写代码通常是一个好主意。

于 2013-04-02T12:56:39.813 回答