在for循环中修改列表元素

Question

我有一个列表a，我想根据函数f更改元素a[i: j]。我能比天真的方式做得更好吗？

for index in range(i, j): 
    a[index] = f(a) 

[通过更好地我的意思是更接近于map(f, a)，或者说更快。]

Answer 1

您可以分配到切片：

a[i:j] = map(f, a[i:j]) 

Answer 2

使用列表理解...

a[i:j] = [f(ai) for ai in a[i:j]] 

或map相当...

a[i:j] = map(f, a[i:j]) 

Answer 3

我不打算做定时练习，但我会告诉你什么内部代码的各种选项变成。您的代码是naive。切片为l值的基于地图的解决方案为map_lvalue_slice。用切片作为l值的列表理解是list_comp_lvalue_slice。相关列表理解一个解决方案使用一个元组，被称为tuple_lvalue_slice：

>>> from dis import dis 
>>> 
>>> def naive(a, f, i, j): 
...  for index, ai in enumerate(a[i:j], start=i): 
...   a[index] = f(ai) 
... 
>>> def map_lvalue_slice(a, f, i, j): 
...  a[i:j] = map(f, a[i:j]) 
... 
>>> def list_comp_lvalue_slice(a, f, i, j): 
...  a[i:j] = [f(ai) for ai in a[i:j]] 
... 
>>> def tuple_lvalue_slice(a, f, i, j): 
...  a[i:j] = tuple(f(ai) for ai in a[i:j]) 
... 
>>> dis(naive) 
    2   0 SETUP_LOOP    55 (to 58) 
       3 LOAD_GLOBAL    0 (enumerate) 
       6 LOAD_FAST    0 (a) 
       9 LOAD_FAST    2 (i) 
      12 LOAD_FAST    3 (j) 
      15 SLICE+3    
      16 LOAD_CONST    1 ('start') 
      19 LOAD_FAST    2 (i) 
      22 CALL_FUNCTION   257 
      25 GET_ITER    
     >> 26 FOR_ITER    28 (to 57) 
      29 UNPACK_SEQUENCE   2 
      32 STORE_FAST    4 (index) 
      35 STORE_FAST    5 (ai) 

    3   38 LOAD_FAST    1 (f) 
      41 LOAD_FAST    5 (ai) 
      44 CALL_FUNCTION   1 
      47 LOAD_FAST    0 (a) 
      50 LOAD_FAST    4 (index) 
      53 STORE_SUBSCR   
      54 JUMP_ABSOLUTE   26 
     >> 57 POP_BLOCK   
     >> 58 LOAD_CONST    0 (None) 
      61 RETURN_VALUE   
>>> 
>>> dis(map_lvalue_slice) 
    2   0 LOAD_GLOBAL    0 (map) 
       3 LOAD_FAST    1 (f) 
       6 LOAD_FAST    0 (a) 
       9 LOAD_FAST    2 (i) 
      12 LOAD_FAST    3 (j) 
      15 SLICE+3    
      16 CALL_FUNCTION   2 
      19 LOAD_FAST    0 (a) 
      22 LOAD_FAST    2 (i) 
      25 LOAD_FAST    3 (j) 
      28 STORE_SLICE+3  
      29 LOAD_CONST    0 (None) 
      32 RETURN_VALUE   
>>> 
>>> dis(list_comp_lvalue_slice) 
    2   0 BUILD_LIST    0 
       3 LOAD_FAST    0 (a) 
       6 LOAD_FAST    2 (i) 
       9 LOAD_FAST    3 (j) 
      12 SLICE+3    
      13 GET_ITER    
     >> 14 FOR_ITER    18 (to 35) 
      17 STORE_FAST    4 (ai) 
      20 LOAD_FAST    1 (f) 
      23 LOAD_FAST    4 (ai) 
      26 CALL_FUNCTION   1 
      29 LIST_APPEND    2 
      32 JUMP_ABSOLUTE   14 
     >> 35 LOAD_FAST    0 (a) 
      38 LOAD_FAST    2 (i) 
      41 LOAD_FAST    3 (j) 
      44 STORE_SLICE+3  
      45 LOAD_CONST    0 (None) 
      48 RETURN_VALUE   
>>> 
>>> dis(tuple_lvalue_slice) 
    2   0 LOAD_GLOBAL    0 (tuple) 
       3 LOAD_CLOSURE    0 (f) 
       6 BUILD_TUPLE    1 
       9 LOAD_CONST    1 (<code object <genexpr> at 0xb748dc38, file "<stdin>", line 2>) 
      12 MAKE_CLOSURE    0 
      15 LOAD_FAST    0 (a) 
      18 LOAD_FAST    2 (i) 
      21 LOAD_FAST    3 (j) 
      24 SLICE+3    
      25 GET_ITER    
      26 CALL_FUNCTION   1 
      29 CALL_FUNCTION   1 
      32 LOAD_FAST    0 (a) 
      35 LOAD_FAST    2 (i) 
      38 LOAD_FAST    3 (j) 
      41 STORE_SLICE+3  
      42 LOAD_CONST    0 (None) 
      45 RETURN_VALUE   

的解决方案，解决最快的C代码，最好是在一个紧密的循环，是最可取的在我的意见，因为他们很可能大多采用优化C代码，而不是主要解释说明。我更喜欢切片作为你的代码的l值解决方案，我可能会倾向于地图解决方案，尽管我主要是一名列表理解家伙。

而且，这里是证明他们是等价代码：

>>> i, j = 4, 8 
>>> def f(ai): 
...  return -ai 
... 
>>> for fn in (naive, map_lvalue_slice, list_comp_lvalue_slice, tuple_lvalue_slice): 
...  a = range(10) 
...  fn(a, f, i, j) 
...  print "%-40s: %r" % (fn.__name__, a) 
... 
naive         : [0, 1, 2, 3, -4, -5, -6, -7, 8, 9] 
map_lvalue_slice      : [0, 1, 2, 3, -4, -5, -6, -7, 8, 9] 
list_comp_lvalue_slice     : [0, 1, 2, 3, -4, -5, -6, -7, 8, 9] 
tuple_lvalue_slice      : [0, 1, 2, 3, -4, -5, -6, -7, 8, 9]