Я не собираюсь выполнять упражнения по выбору времени, но я покажу вам, во внутренний код, в которые превращаются различные опции.Ваш код 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]