Python—为什么在映射两个列表时会缩短字典？

我有两张大单子，长度相等，每件2574件。我想将项目映射到字典中，因为映射时，我想知道哪些值与它们的键不同。每个键一个值。然而，当我映射它们时，我得到了一本长度为76的短得多的词典

这里有一个测试：

Python 2.7.6 (default, Mar 22 2014, 22:59:56) 
[GCC 4.8.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> list1 = [1, 1, 3, 4, 5, 6, 7, 8, 8, 8, 8, 8, 8, 10]
>>> list2 = [1, 2, 3, 4, 5, 6, 7, 8, 8, 8, 8, 8, 9, 10]
>>> 
>>> listdict = dict(zip(list1, list2))
>>> print len(list1)
14
>>> print len(list2)
14
>>> print len(listdict)
8
>>> print listdict
{1: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 9, 10: 10}

那么，为什么使用dict（zip（））会删除相互映射的1和相互映射但保留所有其他内容的8呢？基本上，我看到的两个列表长度相等，对于每个索引，我需要知道项目是否不同。每个列表中用于比较的位置必须匹配。因此，从列表1[0]到列表2[0]，而不是其他地方。当我拿到字典的时候，我想这样的东西会有用的：

for k,v in listdict:
if k != v:
print k, '\t', v

但它们不匹配…

字典键必须是唯一的。只有最后一个

1

键幸存下来，最后一个

8

键也幸存下来

当您多次指定密钥时，只有一个（处理的“最后一个”）获胜：

如果要找出哪些值与其键不同，不要使用字典，只需收集不同的值对：

different = [pair for pair in zip(list1, list2) if pair[0] != pair[1]]

您可以通过以下方式将索引添加到该文件：

演示：

字典键必须是唯一的。只有最后一个

1

键幸存下来，最后一个

8

键也幸存下来

当您多次指定密钥时，只有一个（处理的“最后一个”）获胜：

如果要找出哪些值与其键不同，不要使用字典，只需收集不同的值对：

different = [pair for pair in zip(list1, list2) if pair[0] != pair[1]]

您可以通过以下方式将索引添加到该文件：

演示：

---

dict将每个键映射到一个值。如果将同一关键点多次设置为不同的值（当然，也可以设置为相同的值），则每个关键点都会覆盖上一个关键点。例如：

>>> d = {}
>>> d[1] = 23
>>> d
{1: 23}
>>> d[1] = 69105
>>> d
{1: 69105}

如果您想为每个键存储多个值，您需要的是一个“multidict”，而不是dict。Python没有内置这样的东西，但使用

defaultdict

进行模拟非常容易：

>>> import collections
>>> d = collections.defaultdict(set)
>>> d[1].add(23)
>>> d
{1: {23}}
>>> d[1].add(69105)
>>> d
{1: {69105, 23}}

因此，如果您想要一个函数，它可以从一组对中创建一个multidict，那么您可以非常轻松地编写它：

def make_multidict(pairs):
    d = collections.defaultdict(set)
    for k, v in pairs:
        d[k].add(v)
    return d

---

dict将每个键映射到一个值。如果将同一关键点多次设置为不同的值（当然，也可以设置为相同的值），则每个关键点都会覆盖上一个关键点。例如：

>>> d = {}
>>> d[1] = 23
>>> d
{1: 23}
>>> d[1] = 69105
>>> d
{1: 69105}

如果您想为每个键存储多个值，您需要的是一个“multidict”，而不是dict。Python没有内置这样的东西，但使用

defaultdict

进行模拟非常容易：

>>> import collections
>>> d = collections.defaultdict(set)
>>> d[1].add(23)
>>> d
{1: {23}}
>>> d[1].add(69105)
>>> d
{1: {69105, 23}}

因此，如果您想要一个函数，它可以从一组对中创建一个multidict，那么您可以非常轻松地编写它：

def make_multidict(pairs):
    d = collections.defaultdict(set)
    for k, v in pairs:
        d[k].add(v)
    return d

---

正如其他答案所阐明的，

dict

s要求键是唯一的

听起来你更喜欢元组列表而不是字典。因此，不要使用

listdict=dict（zip（list1，list2））

，而是尝试以下操作：

listtup=list（zip（list1，list2））

---

正如其他答案所阐明的，

dict

s要求键是唯一的

听起来你更喜欢元组列表而不是字典。因此，不要使用

listdict=dict（zip（list1，list2））

，而是尝试以下操作：

listtup=list（zip（list1，list2））

---

要保留

列表1中的项目及其位置，请使用
枚举

>>> listdict = dict(zip(enumerate(list1), list2))
>>> listdict
{(0, 1): 1, (10, 8): 8, (6, 7): 7, (5, 6): 6, (7, 8): 8, (9, 8): 8, (13, 10): 10, (4, 5): 5, (8, 8): 8, (2, 3): 3, (11, 8): 8, (3, 4): 4, (1, 1): 2, (12, 8): 9}

listdict
中的每个键都是一个元组，由
list1
中的索引和该位置的项组成。
要保留
list1
中的项及其位置，请使用
枚举

>>> listdict = dict(zip(enumerate(list1), list2))
>>> listdict
{(0, 1): 1, (10, 8): 8, (6, 7): 7, (5, 6): 6, (7, 8): 8, (9, 8): 8, (13, 10): 10, (4, 5): 5, (8, 8): 8, (2, 3): 3, (11, 8): 8, (3, 4): 4, (1, 1): 2, (12, 8): 9}

listdict
中的每个键都是一个元组，由
list1
中的索引和该位置的项组成。
要保留列表中元素的长度和顺序，请使用

OrderedDict(zip(list1,list2))

要保留列表中元素的长度和顺序，请使用

OrderedDict(zip(list1,list2))

好的，这是有道理的。使用defaultdict会做同样的事情吗？如何将每个项目的位置与每个列表中的相应位置进行比较？@user3358205:使用
defaultdict
而不更改任何其他内容，也可以做同样的事情……但您可以轻松地更改它以做您想做的事情。我编辑答案是为了演示。@OllieFord我指的是列表中的位置，也许是为了避免字典中的键/值比较。@user3358205:我不理解你评论中的第二个问题，即使是在后续评论之后。您正在
zip
ping列表，因此它们对应的元素已经匹配。还有什么东西需要与其他东西相匹配吗？好的，这是有道理的。使用defaultdict会做同样的事情吗？如何将每个项目的位置与每个列表中的相应位置进行比较？@user3358205:使用
defaultdict
而不更改任何其他内容，也可以做同样的事情……但您可以轻松地更改它以做您想做的事情。我编辑答案是为了演示。@OllieFord我指的是列表中的位置，也许是为了避免字典中的键/值比较。@user3358205:我不理解你评论中的第二个问题，即使是在后续评论之后。您正在
zip
ping列表，因此它们对应的元素已经匹配。是否还有其他需要与之匹配的问题？很好的回答说明了问题，并提供了提问者想要的明确解决方案，即“。。。因为当映射时，我想知道哪些值与它们的键不同，这些键的正确答案演示了问题，并提供了提问者想要的明确解决方案，即“。。。因为在映射时，我想知道哪些值与它们的键try
len（set（list1））
相同的问题--您有未设置的list1try
len（set（list1））
相同的问题--您有未设置的list1