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]]

正如您从第 3 行中看到的那样，列表的第一项被重复，我想要实现的是，一旦循环达到 maxCount，它不会继续追加到列表的底部，而是追加到右侧。我理想地想要获得的是：

 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)

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

4

1 回答 1

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)创建了一个新列表，也就是说内存中另一个地址的新对象：那么上面的代码没有实现列表的就地转换。
下面的一个执行这种就地转换，因为它通过在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。
    直接引用对象更为 Pythonic，而不是通过它们在其元素所在的列表中的索引间接引用它们。

  • 该列表to_del记录了第一次循环后将被删除的子列表的索引。添加的每个索引都插入到（未附加到它的）开头，to_del 以便第二个循环（for i in to_del）将在列表中逆向运行l，这是根据索引删除列表元素时必须遵守的条件.

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

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

接下来，在通过 list 的迭代过程中d[subli.pop(0)]先前遇到的 sublist ，在该子列表被缩短之后被保留在子列表中的元素被扩展，也就是说，在它被缩短之前被索引到的元素。但是，正如已经缩短的那样，我们只写，而不是。llsubli1len(subli)-1sublisublisubli[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。

于 2013-12-02T23:14:30.723 回答