Question

在那个人身上摸不着头脑。

我有一个嵌套列表格式：

( (value1, value2, value3), (value1, value2, value3), ... (value1, value2, value3))

现在我想把它归结为：

( (value1, value2), (value1, value2), ... (value1, value2))

简而言之，尝试删除每个嵌套列表的第3个元素。

这是否可以直接在Python中使用？

Answer 1

您只需使用列表解析即可完成此操作：

>>> x = [(1, 2, 3), (1, 2, 3), (1, 2, 3)]
>>> x = [(a, b) for (a, b, c) in x]
[(1, 2), (1, 2), (1, 2)]

Answer 2

使用列表理解：

outerlist = [sublist[:-1] for sublist in outerlist]

这使用切片来删除每个包含的子列表的最后一个元素。

以上内容会创建list()，而非tuple();以下将再次创建一个元组：

outertuple = tuple(sublist[:-1] for sublist in outertuple)

切片子列表比解包和重新打包元组需要更少的操作码，更快地得到结果。

使用元组进行演示：

>>> outertuple = ((1, 2, 3), (4, 5, 6), (7, 8, 9))
>>> tuple(sublist[:-1] for sublist in outertuple)
((1, 2), (4, 5), (7, 8))

使用列表进行演示：

>>> outerlist = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> [sublist[:-1] for sublist in outerlist]
[[1, 2], [4, 5], [7, 8]]

最后但并非最不重要的是，列表推导的内部循环的字节码反汇编显示切片使用的操作码比解包和重新打包更少：

>>> import dis
>>> def foo(x): return [sublist[:-1] for sublist in x]
... 
>>> def bar(x): return [(a, b) for (a, b, c) in x]
... 
>>> dis.dis(foo)
  1           0 BUILD_LIST               0
              3 LOAD_FAST                0 (x)
              6 GET_ITER            
        >>    7 FOR_ITER                16 (to 26)
             10 STORE_FAST               1 (sublist)
             13 LOAD_FAST                1 (sublist)
             16 LOAD_CONST               1 (-1)
             19 SLICE+2             
             20 LIST_APPEND              2
             23 JUMP_ABSOLUTE            7
        >>   26 RETURN_VALUE        
>>> dis.dis(bar)
  1           0 BUILD_LIST               0
              3 LOAD_FAST                0 (x)
              6 GET_ITER            
        >>    7 FOR_ITER                27 (to 37)
             10 UNPACK_SEQUENCE          3
             13 STORE_FAST               1 (a)
             16 STORE_FAST               2 (b)
             19 STORE_FAST               3 (c)
             22 LOAD_FAST                1 (a)
             25 LOAD_FAST                2 (b)
             28 BUILD_TUPLE              2
             31 LIST_APPEND              2
             34 JUMP_ABSOLUTE            7
        >>   37 RETURN_VALUE

11对14个操作码。这是一个额外的UNPACK_SEQUENCE和另外两个STORE_FAST操作码，以及一个BUILD_TUPLE操作码与SLICE+2。

这些差异使拆包和包装变得相当慢：

>>> import timeit
>>> test = [(42, 69, 180) for _ in xrange(1000)]
>>> timeit.timeit('f(x)', 'from __main__ import test as x, foo as f', number=10000)
1.1722910404205322
>>> timeit.timeit('f(x)', 'from __main__ import test as x, bar as f', number=10000)
1.6375460624694824

Answer 3

>>> a = ((1,2,3), (4,5,6), (7,8,9))
>>> a = tuple([(x1, x2) for (x1, x2, x3) in a])
>>> a
((1, 2), (4, 5), (7, 8))

Answer 4

nested_list= [[1,2,3],[4,5,6]]

for regular_list in nested_list:
    del regular_list[2]

Answer 5

试试这个：

[a[ :-1] for a in b]

或者这个：

[a[:n]+a[n+1:] for a in b]

Answer 6

使用地图：

l = [[0,1,2], [1,2,3]]
print map(lambda l : l[:-1], l)
# Outputs [[0, 1], [1, 2]]

鉴于所有子列表的长度均为3。

如果你想要这个元组：

l = ((0,1,2), (1,2,3))
print tuple(map(lambda l : l[:-1], l))
# Outputs ((0, 1), (1, 2))

Answer 7

x = [(1, 2, 3), (1, 2, 3), (1, 2, 3)]
>>> [i[:2] for i in x ]

[（1,2），（1,2），（1,2）]

如何删除嵌套列表的第n个索引？

7 个答案: