如何加入两个没有重复的元组列表
How to join two list of tuples without duplicates
我 运行 对数据库进行了两次查询,我从每个查询中得到的结果是一个完美的元组列表。我想将这些加入一个元组列表中。这些是元组的例子:
list1 = [('abc', 1 ), ('def', 2) ... ]
list2 = [(1000, 'abc'), (2000, 'def' ), (3000, 'def') ... ]
我只想创建一个元组列表,然后像这样加入它们:
q = []
for i in list1:
for j in list2:
if i[0] == (j[1]):
i = i + (j[0],)
q.append(i)
这个 returns 在我的新列表中重复 q
因为我得到这样的东西:
q = [('abc', 1 , 1000) , ('def', 2, 2000), ('def', 2, 2000, 3000) ...]
如何避免像 q 列表中的第二个元组列表那样重复?
我只想要 ('def', 2, 2000, 3000)
而不是这个 ('def', 2, 2000), ('def', 2, 2000, 3000)
我已经坚持了一段时间,所以感谢您的帮助。谢谢
您不需要在内循环中附加 i
。仅在外循环结束时出现一次。
q = []
for i in list1:
for j in list2:
if i[0] == j[1]:
i = i + (j[0],)
q.append(i)
外循环也有错别字。它应该是 list1
而不是 list
.
如果您的列表很小,使用嵌套循环是可以的,但对于较大的列表,它很快就会变得低效。例如,如果 len(list1) == 10 和 len(list2) == 20,则内循环中的代码将执行 200 次。
这是一个通过字典构建所需元组列表的算法。字典将元组数据存储在列表中,因为它更有效:可以附加到列表,而元组是不可变的,因此每次您将一个项目添加到带有 i = i + (j[0],)
的元组末尾时,您实际上是在创建一个新元组对象(以及临时 (j[0],)
元组)并丢弃绑定到 i
.
的旧元组对象
list1 = [('abc', 1 ), ('def', 2), ('ghi', 3)]
list2 = [
(1000, 'abc'),
(2000, 'def'),
(2100, 'def'),
(3000, 'ghi'),
(3100, 'ghi'),
(3200, 'ghi'),
]
# Insert list1 data into a dict of lists
d = {t[0]:list(t) for t in list1}
# Append list2 data to the correct list
for v, k in list2:
d[k].append(v)
# Convert lists back into tuples, using the key order from list1
result = [tuple(d[k]) for k, _ in list1]
for t in result:
print(t)
输出
('abc', 1, 1000)
('def', 2, 2000, 2100)
('ghi', 3, 3000, 3100, 3200)
使用这个算法,如果 len(list1) == 10 和 len(list2) == 20 那么我们有一个长度为 10 的循环来构建字典 d
,一个长度为 20 的循环来追加list2 数据到 d
的列表,以及另一个长度为 10 的循环来构建最终的元组列表。每个循环中的步骤都非常基本,与您的 i = i + (j[0],)
大致相当,显然 40 步比 200 步好很多。当然,如果输入列表每个有 1000 个项目,那么我的代码将需要 3000循环与嵌套循环方法所需的一百万个循环形成对比。
我还应该提到,如果 list2
包含不在 list1
中的密钥,此代码将引发 KeyError
。大概这不是您正在处理的数据的问题,因为您的代码(和 Sevanteri 的代码)默默地忽略了这些键。如果你 do 需要处理这样的键,那么这样做很简单,但如果它不必处理丢失的键,它会使我的 list2
循环更简单和更有效率。
我 运行 对数据库进行了两次查询,我从每个查询中得到的结果是一个完美的元组列表。我想将这些加入一个元组列表中。这些是元组的例子:
list1 = [('abc', 1 ), ('def', 2) ... ]
list2 = [(1000, 'abc'), (2000, 'def' ), (3000, 'def') ... ]
我只想创建一个元组列表,然后像这样加入它们:
q = []
for i in list1:
for j in list2:
if i[0] == (j[1]):
i = i + (j[0],)
q.append(i)
这个 returns 在我的新列表中重复 q
因为我得到这样的东西:
q = [('abc', 1 , 1000) , ('def', 2, 2000), ('def', 2, 2000, 3000) ...]
如何避免像 q 列表中的第二个元组列表那样重复?
我只想要 ('def', 2, 2000, 3000)
而不是这个 ('def', 2, 2000), ('def', 2, 2000, 3000)
我已经坚持了一段时间,所以感谢您的帮助。谢谢
您不需要在内循环中附加 i
。仅在外循环结束时出现一次。
q = []
for i in list1:
for j in list2:
if i[0] == j[1]:
i = i + (j[0],)
q.append(i)
外循环也有错别字。它应该是 list1
而不是 list
.
如果您的列表很小,使用嵌套循环是可以的,但对于较大的列表,它很快就会变得低效。例如,如果 len(list1) == 10 和 len(list2) == 20,则内循环中的代码将执行 200 次。
这是一个通过字典构建所需元组列表的算法。字典将元组数据存储在列表中,因为它更有效:可以附加到列表,而元组是不可变的,因此每次您将一个项目添加到带有 i = i + (j[0],)
的元组末尾时,您实际上是在创建一个新元组对象(以及临时 (j[0],)
元组)并丢弃绑定到 i
.
list1 = [('abc', 1 ), ('def', 2), ('ghi', 3)]
list2 = [
(1000, 'abc'),
(2000, 'def'),
(2100, 'def'),
(3000, 'ghi'),
(3100, 'ghi'),
(3200, 'ghi'),
]
# Insert list1 data into a dict of lists
d = {t[0]:list(t) for t in list1}
# Append list2 data to the correct list
for v, k in list2:
d[k].append(v)
# Convert lists back into tuples, using the key order from list1
result = [tuple(d[k]) for k, _ in list1]
for t in result:
print(t)
输出
('abc', 1, 1000)
('def', 2, 2000, 2100)
('ghi', 3, 3000, 3100, 3200)
使用这个算法,如果 len(list1) == 10 和 len(list2) == 20 那么我们有一个长度为 10 的循环来构建字典 d
,一个长度为 20 的循环来追加list2 数据到 d
的列表,以及另一个长度为 10 的循环来构建最终的元组列表。每个循环中的步骤都非常基本,与您的 i = i + (j[0],)
大致相当,显然 40 步比 200 步好很多。当然,如果输入列表每个有 1000 个项目,那么我的代码将需要 3000循环与嵌套循环方法所需的一百万个循环形成对比。
我还应该提到,如果 list2
包含不在 list1
中的密钥,此代码将引发 KeyError
。大概这不是您正在处理的数据的问题,因为您的代码(和 Sevanteri 的代码)默默地忽略了这些键。如果你 do 需要处理这样的键,那么这样做很简单,但如果它不必处理丢失的键,它会使我的 list2
循环更简单和更有效率。