Skip to main content
 首页 » 编程设计

Python:多次调用内置函数的有效方法

2025年05月04日16lvdongjie

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

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 

请您参考如下方法:

第二种方法肯定更好,因为调用 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