Question

我正在尝试解决一个练习，我有一个这样的列表列表：

outerlist = [[344,0,"str1"],[233,0,"str2"],[213,0,"str3"],[344,2,"str4"],
             [213,1,"str5"],[344,3,"str6"],[344,1,"str7"],[213,2,"str8"]]

内部列表中的第二个元素总是连续增加。

并想要这样的输出：

Group 1
213 0 str3
213 1 str5
213 2 str8
Group 2
233 0 str2
Group 3
344 0 str1
344 1 str7
344 2 str4
344 3 str6

起初，我很难按列表的第一个元素进行分组并编写此代码

list1 = []
list2 = []
list3 = []
for i in range(len(outerlist)):
    if outerlist[i][0] == 213:
        list1.append(outerlist[i])
    elif outerlist[i][0] == 233:
        list2.append(outerlist[i])
    elif outerlist[i][0] == 344:
        list3.append(outerlist[i])

但是外部列表可以具有更多的内部列表作为元素，并且这些内部列表可以在第一个元素中具有不同的元素（而不是只有213、233、344可以是579或1000，因此在输出中必须有一个组4和组5节）如果可以解决第一个问题，则可以使用这些功能，并且可以连续订购组我可以打印出来

def sortinlist(y):
    y.sort(key = lambda x: x[1])
    return y
def listtostr(y):
    return ' '.join(map(str, y)

但是我不知道外部列表中会有多少个内部列表，并且想找到一个可以通过查找内部列表的第一个元素来检测ID的代码，为此ID创建一个新列表，然后在中查找第一个元素第二个内部列表（如果其ID与第一个内部列表的ID相同）（如果不是，则追加到第1组列表），然后创建一个新列表，依此类推。基本上，我想找到一种通过示例结构提供输出的方法。

Answer 1

使用集合和列表的解决方案：

labels = list({l[0] for l in outerlist})
sortedlist = sorted(outerlist) 
groups = [[l for l in sortedlist if l[0]==x] for x in sorted(labels)]

for  i,values in enumerate(groups):
    print("Group",i+1)
    for v in values:
        print(*v)

产生

Group 1
213 0 str3
213 1 str5
213 2 str8
Group 2
233 0 str2
Group 3
344 0 str1
344 1 str7
344 2 str4
344 3 str6

Answer 2

您可以使组键到出现在其上的元素的字典中。 defaultdict用于确保值始终是列表。

 from collections import defaultdict 

 outer_list = sorted(outerlist, key=lambda seg: seg[0])
 d = defaultdict(list)
 for seg in outer_list:
     d[seg[0]].append(d)

 for group_idx, group in enumerate(d.values()):
     print(f'Group {group_idx + 1}')
     print('\n'.join(map(' '.join, group))))

如果您不想（或不能）导入defaultdict，则可以执行以下操作

 d = {}
 for seg in outer_list:
     d[seg[0]].setdefault([])
     d[seg[0]].append(d)

Answer 3

我们在这里

outerlist = [[344, 0, "str1"], [233, 0, "str2"], [213, 0, "str3"], [344, 2, "str4"],
             [213, 1, "str5"], [344, 3, "str6"], [344, 1, "str7"], [213, 2, "str8"]]
outerlist = sorted(outerlist, key=lambda x: x[1])

last_id, group_id = None, 0
for item in sorted(outerlist, key=lambda x: x[0]):
    if not last_id or item[0] != last_id:
        group_id += 1
        last_id = item[0]

        print('Group {}'.format(group_id))

    print(' '.join([str(x) for x in item]))

输出

python test.py
Group 1
213 0 str3
213 1 str5
213 2 str8
Group 2
233 0 str2
Group 3
344 0 str1
344 1 str7
344 2 str4
344 3 str6

对于这种情况，我们不必构建任何额外的列表或复杂的打印结构。

Answer 4

这似乎有点像一个家庭作业问题，所以我不会为您做所有的事情，但是我确实认为通过使用字典，您将可以找到大部分的学习方式

这解决了

的主要问题

但是外部列表可以具有更多的内部列表作为元素，并且这些内部列表可以在第一个元素中具有不同的元素（而不是只有213、233、344可以是579或1000，因此在输出中必须有一个组4和组5部分）如果可以解决第一个问题，则可以使用这些功能，并且可以连续订购组并打印它们

outerlist = [[344,0,"str1"],[233,0,"str2"],[213,0,"str3"],[344,2,"str4"],
             [213,1,"str5"],[344,3,"str6"],[344,1,"str7"],[213,2,"str8"]]

container = {}
for inner_list in outerlist:
    key_, ind_, string_ = inner_list

    if key_ in container:
        container[key_].append([ind_, string_])
    else:
        container[key_] = [[ind_, string_]]

此时，容器包含

{344: [[0, 'str1'], [2, 'str4'], [3, 'str6'], [1, 'str7']],
 233: [[0, 'str2']],
 213: [[0, 'str3'], [1, 'str5'], [2, 'str8']]}

您可以对其进行排序

Answer 5

您可以将它们存储在dict中，如下所示：

def group_by_id(data):
    grouped_data = {}

    for element in data:
        id = element[0]
        elements_same_id = grouped_data.get(id, [])
        elements_same_id.append(' '.join(element))
        grouped_data[id] = elements_same_id

    return grouped_data

for group_number, group in enumerate(group_by_id(outerlist), 1):
    print(f'Group {group_number}')
    for element in group:
        print(element)

Answer 6

您可以通过以下方式进行操作：

outerlist = [[344,0,"str1"],[233,0,"str2"],[213,0,"str3"],[344,2,"str4"],
             [213,1,"str5"],[344,3,"str6"],[344,1,"str7"],[213,2,"str8"]]


def sortinlist(y):
    y.sort(key = lambda x: x[0])
    return y

groups = {}

for group in outerlist:
    groups[group[0]] = groups.get(group[0], []) + [(group[1], group[2])]


for group in groups:
    group = sortinlist(groups[group])

group_id = 1
for group in sorted(groups.keys()):
    print("Group %d" % (group_id))
    for member in groups[group]:
        print("%d %d %s" % (group,member[0],member[1]))

将列表中的每个元素放入字典中，并使用键组（344、213、233，...），并将值的列表作为两个数据段的值：[（0，“ str1”），（2，“ str4”）...]
按元组的第一个值对其进行排序，以使组中的字符串按正确的顺序
按键顺序打印出来。

Answer 7

尝试将列表转换为字典，然后可以输出序列。

它根据列表中的第1，第2，第3元素对列表进行排序，并转换为字典并打印出来。

dt={}
count = 1

for i in sorted(outerlist,key=lambda x:(x[:])):
    dt[i[0]]=dt.get(i[0],[])
    dt[i[0]].append(i)

for i in dt.values():
    print('Group ', count)
    count += 1
    for j in i:
        print(' '.join(map(str,j)))

Answer 8

我认为这是一个不好的选择，但是我想让它成为为每个项目创建一个新变量的一种方法，我建议为此目的使用字典，但是上面已经包含了很好的答案，在这种情况下，我只会我以这种方式发布信息，但请记住，最好使用字典

outerlist = [[344,0,"str1"],[233,0,"str2"],[213,0,"str3"],[344,2,"str4"],
             [213,1,"str5"],[344,3,"str6"],[344,1,"str7"],[213,2,"str8"]]

count = 0
for l in outerlist:
    try:
        assert count != 0
        for c in range(count):
            if l[0] == locals()[f'new_list_{c}'][0][0]:
                locals()[f'new_list_{c}'].append(l)
                break
            if count == c + 1:
                raise UnboundLocalError
    except:
        locals()[f'new_list_{count}'] = [l]
        count += 1

for c in range(count):
    print(f'Group {c+1}')
    for n in locals()[f'new_list_{c}']:
        print(*n)

输出

Group 1
344 0 str1
344 2 str4
344 3 str6
344 1 str7
Group 2
233 0 str2
Group 3
213 0 str3
213 1 str5
213 2 str8

您可以打印出变量

print(new_list_0)
print(new_list_1)
print(new_list_2)

如何在Python中将列表列表转换为组？

8 个答案:

输出