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

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

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

但是不要对可变对象使用这个:

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)

要回答第二部分，你需要的是对词典的理解:

{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)
{}

Python 2.7+中有字典推导式，但它们不像您尝试的那样工作。像列表理解一样，它们创建了一个新字典;不能使用它们向现有字典添加键。此外，您必须指定键和值，当然，如果您愿意，您可以指定一个虚拟值。

>>> 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)将新值合并到旧字典中。

>>> {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}

在元组列表上使用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[tuple([i for i in range(1,11)])] = True

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

而不是写作

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

or

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)”不是一个有效的键，这只是一个语法错误。如果字典支持将列表作为键，那么您将执行如下操作

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

而不是

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

但是列表是不可哈希的，所以不能将它们用作字典键。

我真的很喜欢@mgilson注释，因为如果你有两个可迭代对象，一个对应于键，另一个对应于值，你还可以做以下事情。

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

给

D = {'a': 1， 'b': 2， 'c': 3}

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

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}

字典推导式非常类似于列表推导式，但是我们在它的末尾得到了一个字典，所以我们需要分配键值对，而不仅仅是值。

假设我们有一个用户列表，其中每个用户信息都存储在一个元组中。我们有一个包含四个用户元组的列表。在其中，它们有一个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循环，以确保您在输入时使用了正确的用户名。