Python字典理解答案

【问题标题】：Python Dictionary ComprehensionPython字典理解
【发布时间】：2013-01-08 13:52:02
【问题描述】：

是否可以在 Python 中创建字典解析（用于键）？

没有列表推导，你可以使用这样的东西：

l = []
for n in range(1, 11):
    l.append(n)

我们可以将其缩短为列表理解：l = [n for n in range(1, 11)]。

但是，假设我想将字典的键设置为相同的值。我能做到：

d = {}
for n in range(1, 11):
     d[n] = True # same value for each

我试过了：

d = {}
d[i for i in range(1, 11)] = True

但是，我在for 上收到了SyntaxError。

另外（我不需要这部分，只是想知道），你能把字典的键设置成一堆不同的值吗，像这样：

d = {}
for n in range(1, 11):
    d[n] = n

这可以通过字典理解实现吗？

d = {}
d[i for i in range(1, 11)] = [x for x in range(1, 11)]

这也会在for 上引发SyntaxError。

【问题讨论】：

供未来读者参考：NumPy 数组确实允许您将多个元素设置为单个值或值列表，就像您尝试做的那样。虽然如果你还没有理由使用 NumPy，那么仅仅为了这个功能可能不值得。

标签： python dictionary list-comprehension

【解决方案1】：

有dictionary comprehensions in Python 2.7+，但它们的工作方式与您尝试的方式不同。就像列表推导式一样，它们创建了一个 new 字典；您不能使用它们将键添加到现有字典中。此外，您必须指定键和值，当然您可以根据需要指定一个虚拟值。

>>> d = {n: n**2 for n in range(5)}
>>> print d
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

如果要将它们全部设置为 True：

>>> d = {n: True for n in range(5)}
>>> print d
{0: True, 1: True, 2: True, 3: True, 4: True}

您似乎要求的是一种在现有字典上一次设置多个键的方法。没有直接的捷径。您可以像已经展示的那样循环，也可以使用字典推导式创建一个包含新值的新字典，然后执行 oldDict.update(newDict) 将新值合并到旧字典中。

【讨论】：

FWIW，dict.update 也可以像 dict 构造函数一样接受可迭代的键值对
请注意，如果您要创建一个所有值都相同的字典，请使用dict.fromkeys()。所以要将所有值设置为True，请使用dict.fromkeys(range(5), True)。请注意，该值是未复制，因此当您有一个可变值时，您可能希望避免这种情况；它将在所有密钥之间共享。
注意：键也可以是方法的结果：{ n*2 : n for n in range(3) } => {0: 0, 2: 1, 4: 2}。两者都可以在同一个表达式中完成：{ n*2 : n*3 for n in range(3) } => { 0: 0, 2: 3, 4: 6 }.

【解决方案2】：

你可以使用dict.fromkeys类方法...

>>> dict.fromkeys(range(5), True)
{0: True, 1: True, 2: True, 3: True, 4: True}

这是创建所有键映射到相同值的字典的最快方法。

但是do not use this with mutable objects:

d = dict.fromkeys(range(5), [])
# {0: [], 1: [], 2: [], 3: [], 4: []}
d[1].append(2)
# {0: [2], 1: [2], 2: [2], 3: [2], 4: [2]} !!!

如果您实际上需要初始化所有键，defaultdict 也可能有用：

from collections import defaultdict
d = defaultdict(True)

要回答第二部分，你需要一个dict-comprehension：

{k: k for k in range(10)}

你可能不应该这样做，但你也可以创建一个dict 的子类，如果你覆盖__missing__，它的工作方式有点像defaultdict：

>>> class KeyDict(dict):
...    def __missing__(self, key):
...       #self[key] = key  # Maybe add this also?
...       return key
... 
>>> d = KeyDict()
>>> d[1]
1
>>> d[2]
2
>>> d[3]
3
>>> print(d)
{}

【讨论】：

请注意，在 d = defaultdict(lambda: True) 的情况下，不需要 lambda，因为 True 是（或不应该）是可变的。

【解决方案3】：

>>> {i:i for i in range(1, 11)}
{1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10}

【讨论】：

【解决方案4】：

我非常喜欢@mgilson 评论，因为如果您有两个可迭代对象，一个对应于键，另一个对应于值，您还可以执行以下操作。

keys = ['a', 'b', 'c']
values = [1, 2, 3]
d = dict(zip(keys, values))

给予

d = {'a': 1, 'b': 2, 'c': 3}

【讨论】：

【解决方案5】：

考虑这个使用字典理解计算列表中单词出现次数的示例

my_list = ['hello', 'hi', 'hello', 'today', 'morning', 'again', 'hello']
my_dict = {k:my_list.count(k) for k in my_list}
print(my_dict)

结果是

{'again': 1, 'hi': 1, 'hello': 3, 'today': 1, 'morning': 1}

【讨论】：

这很有趣，虽然不是最有效的，因为你会多次计算像“hello”这样的键
请记住这是 O(N^2) 并且即使对于小数据大小也非常慢。我将它添加到一些生产代码中，这是一个巨大的瓶颈，这个答案很危险，请注意。

【解决方案6】：

在元组列表上使用 dict()，此解决方案将允许您在每个列表中拥有任意值，只要它们的长度相同

i_s = range(1, 11)
x_s = range(1, 11)
# x_s = range(11, 1, -1) # Also works
d = dict([(i_s[index], x_s[index], ) for index in range(len(i_s))])

【讨论】：

附带说明，这与d = dict(zip(i_s,x_s))是一回事

【解决方案7】：

列表推导的主要目的是在不更改或破坏原始列表的情况下基于另一个列表创建新列表。

而不是写

l = []
for n in range(1, 11):
    l.append(n)

或

l = [n for n in range(1, 11)]

你应该只写

l = range(1, 11)

在上面的两个代码块中，您正在创建一个新列表，遍历它并返回每个元素。这只是创建列表副本的一种昂贵方式。

要根据另一个字典获取所有键设置为相同值的新字典，请执行以下操作：

old_dict = {'a': 1, 'c': 3, 'b': 2}
new_dict = { key:'your value here' for key in old_dict.keys()}

你收到一个 SyntaxError 是因为你写的时候

d = {}
d[i for i in range(1, 11)] = True

您基本上是在说：“将我的键 'i for i in range(1, 11)' 设置为 True”并且“i for i in range(1, 11)”不是有效键，它只是一个语法错误。如果 dicts 支持列表作为键，你会做类似的事情

d[[i for i in range(1, 11)]] = True

而不是

d[i for i in range(1, 11)] = True

但列表不可散列，因此您不能将它们用作 dict 键。

【讨论】：

【解决方案8】：

dictionary comprehension 与list comprehension 非常相似，但我们在其末尾得到一个字典，因此我们需要分配键值对而不是仅分配值。

假设我们有一个用户列表，其中每个用户信息都存储在一个元组中。所以我们有一个包含四个用户元组的列表。在其中，他们有一个 ID、每个用户的唯一标识号、用户名和密码。

因此，我们想要创建用户名到用户信息的映射。这是您经常会做的事情，尤其是当您在做网络应用程序之类的事情时。

users = [
    (0, "Bob", "password"),
    (1, "code", "python"),
    (2, "Stack", "overflow"),
    (3, "username", "1234"),
]

username_mapping = {user[1]: user for user in users}
userid_mapping = {user[0]: user for user in users}

print(username_mapping)

"""
Why can this be helpful?

Well, imagine you know a user's username,and you want to get their information out.
You just access, let's say, "Bob," in your username_mapping, and you've got the information out.
"""
print(username_mapping["Bob"])  # (0, "Bob", "password")

# -- Can be useful to log in for example --

username_input = input("Enter your username: ")
password_input = input("Enter your password: ")

_, username, password = username_mapping[username_input]

if password_input == password:
    print("Your details are correct!")
else:
    print("Your details are incorrect.")

所以这是一个在这里使用这个结构，这个字典理解来执行某种登录的例子。

这真的很有帮助，因为它使您不必在此处执行另一个 for 循环，以确保您使用正确的用户名进行输入。

【讨论】：

【解决方案9】：

你不能像这样散列一个列表。试试这个，它使用元组

d[tuple([i for i in range(1,11)])] = True

【讨论】：