python - 即时编写多列列表

Question

嗨，我正在写一个列表，如下:

> l = [[10312, -13.069404602050781], [10313, -28.044403076171875],
>      [10314, -32.765602111816406], [10315, -47.353294372558594],
>      [10312, -63.069404602050781], [10313, -78.044403076171875],
>      [10314, -82.765602111816406], [10315, -97.353294372558594]]

正如您从第 3 行看到的，列表的第一项被重复，我想要实现的是，当循环达到 maxCount 时，它不会继续 append 在列表的底部，而是 append 在正确的。我理想中想要获得的是:

 l = [[10312, -13.069404602050781, -63.069404602050781], 
      [10313, -28.044403076171875, -78.044403076171875],
      [10314, -32.765602111816406, -82.765602111816406], 
      [10315, -47.353294372558594, -97.353294372558594]]

有什么想法吗？

我想出了一个解决方案，但我觉得有点有限，我现在使用的是列表生成器的列表，就像这样

 table=[]
     for k in range(0, len(elementContainer):
         k = []
         table.append(k)

我想给你一个字典生成器，但无法让它工作，任何帮助或者你是否有更好的解决方案。

Answer 1

如果我理解正确的话，这可以完成工作:

l = [[10312, -13.069404602050781], [10313, -28.044403076171875],
     [10314, -32.765602111816406], [10315, -47.353294372558594],
     [10312, -63.069404602050781], [10313, -78.044403076171875],
     [10314, -82.765602111816406], [10315, -97.353294372558594]]

from pprint import pprint
d = {}

for i,(x,n) in enumerate(l):
    print i,x,n
    if x in d:
        l[d[x]].append(n)
        del l[i][:]
    else:
        d[x] = i

l = filter(None,l)

pprint (l)

.

编辑

这是一个更好的算法，因为指令 l = filter(None,l) 不再对列表进行过滤，因此转换是就地的。

这条指令l = filter(None,l)创建了一个新列表，也就是说在内存中的另一个地址创建了一个新对象:那么上面的代码并没有实现一个in-列表的位置转换。
下面的例子执行了这样的就地转换，因为它通过在处理之前和之后打印列表 l 的身份(id est 地址)来证明。

l = [[10312, -13.069404602050781],
     [10313, -28.044403076171875],
     [10314, -32.765602111816406],
     [10312, -63.069404602050781, -55.4444],
     [20666, -91, -92, -93, -94],
     [10315, -47.353294372558594],
     [10314, -82.765602111816406],
     [10315, -97.353294372558594],
     [10313, -78.044403076171875],
     [20666, -40.33, -94, -50.33, -91, -93]
     ]

from pprint import pprint
d = {}
to_del = []
print 'id(l) before : ',id(l)
pprint (l)

for i,subli in enumerate(l):
    if subli[0] in d:
        d[subli.pop(0)].extend(subli)
        to_del.insert(0,i)
    else:
        d[subli[0]] = subli

for i in to_del:
    del l[i]
    
print '\nid(l) after  : ',id(l)
pprint (l)

• 请注意，在前面的代码中，d 的值是 l 子列表的索引。
  现在在这段新代码中，d 的值直接是l 的子列表。
  直接引用对象更符合Python风格，而不是通过它们作为元素的列表中的索引间接引用它们。

• 列表to_del记录了第一次循环后将被删除的子列表的索引。添加的每个索引都插入到 to_del 的开头(而不是 append 到它)，以便第二个循环 ( for i in to_del ) 将逆向运行 通过列表 l ，这是根据索引删除列表元素时必须遵守的条件。

指令d[subli.pop(0)].extend(subli)可能看起来有点难以理解。

操作从执行 subli.pop(0) 开始:该指令触发从子列表 subli 中提取索引为 0 的元素并返回它。< br/>然后d[subli.pop(0)]将对象subli.pop(0)提供给d作为键，同时该对象是从子列表 subli 中删除。
因此，此时，子列表 subli 已缩短其第一个元素，就好像已执行指令 subli[:] = subli[1:] ^{请参阅底部的备注}。

接下来是子列表 d[subli.pop(0)] ，它是在列表 l 迭代期间在 l 中先前遇到的> ，在该子列表被缩短后，用子列表 subli 中剩余的元素进行扩展，也就是说，用索引 1 到 len( subli)-1 在它被缩短之前。但是，由于 subli 已被缩短，我们只写 subli，而不是 subli[1:]。

而且它有效!结果:

id(l) before :  18732936
[[10312, -13.069404602050781],
 [10313, -28.044403076171875],
 [10314, -32.765602111816406],
 [10312, -63.06940460205078, -55.4444],
 [20666, -91, -92, -93, -94],
 [10315, -47.353294372558594],
 [10314, -82.7656021118164],
 [10315, -97.3532943725586],
 [10313, -78.04440307617188],
 [20666, -40.33, -94, -50.33, -91, -93]]

id(l) after  :  18732936
[[10312, -13.069404602050781, -63.06940460205078, -55.4444],
 [10313, -28.044403076171875, -78.04440307617188],
 [10314, -32.765602111816406, -82.7656021118164],
 [20666, -91, -92, -93, -94, -40.33, -94, -50.33, -91, -93],
 [10315, -47.353294372558594, -97.3532943725586]]

.

如果您希望仅将非冗余元素添加到先前存在的子列表中，则必须是:

for i,subli in enumerate(l):
    print 1,subli
    if subli[0] in d:
        precsubli = d[subli.pop(0)]
        precsubli.extend(el for el in subli
                         if el not in precsubli)
        to_del.insert(0,i)
    else:
        d[subli[0]] = subli

.

重要说明

注意区别:

N = [10000,2,3,4]

initial_id = id(N)
print initial_id, N

N = N[1:]

print id(N), N
print '%d==%d : %s' %\
      (initial_id, id(N), initial_id==id(N) )

print '------------------'

A = ['HEY','b','c','d']

initial_id = id(A)
print initial_id, A

A[:] = A[1:]

print id(A), A
print '%d==%d : %s' %\
      (initial_id, id(A), initial_id==id(A) )

结果

18669480 [10000, 2, 3, 4]
11868480 [2, 3, 4]
18669480==11868480 : False
------------------
18731816 ['HEY', 'b', 'c', 'd']
18731816 ['b', 'c', 'd']
18731816==18731816 : True

这意味着 A 被就地修改，而 N 引用的对象则不然:指令 N[1:] 构建一个新对象，位于内存中除 N 引用的对象位置之外的位置。