如何将索引编入字典？

我有一本字典如下:

colors = {
"blue" : "5",
"red" : "6",
"yellow" : "8",
}

如何索引字典中的第一个条目？

由于显而易见的原因，colors[0]将返回 KeyError。

648113 次浏览
小开

你不能，因为 dict是无序的。您可以使用 .popitem()来获取任意项，但是这将从 dict 中删除它。

小开

如果你需要一个有序的字典，你可以使用 奥迪克特。

小开
最佳答案

在 Python 3.6以前的版本中，字典是无序的，包括 Python 3.6。如果您不关心条目的顺序，并且无论如何都想通过索引访问键或值，那么您可以使用 keys = list(d)为字典 d创建一个键列表，然后通过索引 keys[i]访问列表中的键，以及与 d[keys[i]]相关联的值。

如果您确实关心条目的顺序，那么可以从 Python 2.7开始使用 collections.OrderedDict。或者使用成对列表

l = [("blue", "5"), ("red", "6"), ("yellow", "8")]

如果您不需要按键访问(顺便问一下，为什么您的数字字符串?)

在 Python 3.7中，普通字典是有序的，所以不再需要使用 OrderedDict(但是仍然可以使用——它基本上是相同的类型)。Python 3.6的 CPython 实现已经包含了这个更改，但是由于它不是语言规范的一部分，所以在 Python 3.6中不能依赖它。

小开

实际上，我找到了一个新颖的解决方案，它真的帮了我很大的忙。如果你特别关心一个列表或数据集中某个值的索引，你可以将字典的值设置为那个索引！:

看好了:

list = ['a', 'b', 'c']
dictionary = {}
counter = 0
for i in list:
dictionary[i] = counter
counter += 1


print(dictionary) # dictionary = {'a':0, 'b':1, 'c':2}

现在通过散列映射的强大功能，您可以在固定时间(也就是更快地)提取索引条目

小开

解释词典的一个要素就像坐在驴子上享受骑行。

作为 Python 的一个规则，字典是无序的

如果有的话

dic = {1: "a", 2: "aa", 3: "aaa"}

现在假设我像 dic[10] = "b"那样运算，那么它不会总是像这样添加

dic = {1:"a",2:"aa",3:"aaa",10:"b"}

就好像

dic = {1: "a", 2: "aa", 3: "aaa", 10: "b"}

或者

dic = {1: "a", 2: "aa", 10: "b", 3: "aaa"}

或者

dic = {1: "a", 10: "b", 2: "aa", 3: "aaa"}

或者任何这样的组合。

所以经验法则是 字典就是 无序！

小开

如果还有人在关注这个问题，那么目前公认的答案已经过时了:

因为 Python 3.7 * ，所以字典是 维护秩序，也就是说它们现在的行为类似于 collections.OrderedDict。遗憾的是，仍然没有专门的方法索引到字典的 keys()/values()中，因此获取字典中的第一个键/值可以如下所示

first_key = list(colors)[0]
first_val = list(colors.values())[0]

或者(这样可以避免将键视图实例化为列表) :

def get_first_key(dictionary):
for key in dictionary:
return key
raise IndexError


first_key = get_first_key(colors)
first_val = colors[first_key]

如果您需要 n-th 键，那么类似地

def get_nth_key(dictionary, n=0):
if n < 0:
n += len(dictionary)
for i, key in enumerate(dictionary.keys()):
if i == n:
return key
raise IndexError("dictionary index out of range")

* CPython 3.6已经包含了插入顺序的 dicts，但这只是一个实现细节。语言规范包括从3.7开始的插入顺序字典。

小开

这个问题很难回答。这里基本上是每个项目的两个值。然后你试着用一个数字作为钥匙打电话给他们。不幸的是，您的一个值已经被设置为键！

试试这个:

colors = {1: ["blue", "5"], 2: ["red", "6"], 3: ["yellow", "8"]}

现在您可以按数字调用这些键，就好像它们像列表一样被编入索引一样。还可以根据颜色和数字在列表中的位置来引用它们。

比如说,

colors[1][0]
// returns 'blue'


colors[3][1]
// returns '8'

当然，你必须想出另一种方法来记录每种颜色所在的位置。也许你可以有另一个字典，存储每种颜色的关键字作为它的值。

Color _ key = {‘ blue’: 1，‘ red’: 6，‘ yllow’: 8}

然后，如果需要的话，你还可以查找颜色键。

Color [ color _ key [‘ blue’][0]将返回‘ blue’

差不多吧。

然后，当你这样做的时候，你可以用数值作为键来做一个 dict，这样你就可以随时用它来查找你的颜色，你知道，如果你需要的话。

Value = {5: [1，‘ blue’] ，6: [2，‘ red’] ，8: [3，‘ Yellow’]}

然后，(color [ color _ key [ values [5][1]]][0])将返回“ blue”。

或者您可以使用列表列表。

祝你好运！

小开

考虑为什么要建立索引

首先，我想说，要确保你真的需要索引到结果。最初甚至不打算使用一个订单，因此也许有其他方法来解决使用现有基本 Python 数据类型的优点建立索引的需要。

例如，如果您有一个按照特定顺序需要的颜色列表，只需存储颜色列表，然后索引到这些颜色中，并将它们提供给 dict 以获得值。

color_order = [ 'blue', 'yellow', 'yellow', 'blue' ]
value_0 = colors[color_order[0]]

另一方面，如果你需要一些默认的颜色值作为索引0，可以考虑使用一个单独的值来存储默认值，或者添加一个额外的条目来设置默认值，你可以直接键入，而不必索引:

default_color = 'blue'
default_value = colors[default_color]


colors = { 'default': '5', 'blue': '5', 'red': '6', 'yellow': '8' }
default_value = colors['default']

用函数查找索引

您可以通过循环计数到 dict.keys()中来查找 dictindex。如果使用 enumerate()函数，它将自动生成索引值。

这是最直接的方法，但是每次查找索引时都会花费更多的 CPU。这里假设一个有序的 dict (Python 3.7 + 保证了这一点)。

在给定索引处查找密钥:

def key_at_index(mydict, index_to_find):
for index, key in enumerate(mydict.keys()):
if index == index_to_find:
return key
return None  # the index doesn't exist

查找键的索引:

def index_of_key(mydict, key_to_find):
for index, key in enumerate(mydict.keys()):
if key == key_to_find:
return index
return None  # the key doesn't exist

创建一个键列表

如果您需要一个可以被大量访问的解决方案，您可以创建一个重复的键列表，该列表反映了当前字典中的键，然后如果您知道索引，则将索引编入该列表，或者使用该列表的 list.index(item)方法来查找索引。列表优于使用索引创建 dict，因为列表本身已经具有索引，而且内置函数通常更快，更有可能正确处理边缘和角落情况。

这种方法存在额外的开销，但是如果您需要进行大量的数据分析并且需要定期访问索引，那么这样做是值得的。

# Note: you don't actually need the `.keys()`, but it's easier to understand
colors_i = list(colors.keys())
index_blue = colors.index('blue')
index0 = colors_i[0]
value0 = colors[index0]


print(f'colors: {colors}\ncolor_i: {colors_i}')
print(f'index_blue = {index_blue}, index0 = "{index0}", value0 = "{value0}"')
# colors: {'blue': '5', 'red': '6', 'yellow': '8'}
# color_i: ['blue', 'red', 'yellow']
# index_blue = 0, index0 = "blue", value0 = "5"

注意: 这是静态的，如果源字典得到更新，则不会更新。您将需要添加新的项目，以保持它们的同步列表和字典

函数更新 dict 和列表

下面是一个函数，它将同时更新您的查询结果和索引列表。如果一个条目已经存在，它将更新该值，而不会将其添加到列表中(否则列表中将有一个重复条目，而 dict 将只更新现有条目)。

如果要进行大量处理，这种方法可以扩展为一个类，特别是在需要其他扩展函数的情况下。

def index_add_item(mydict, index_list, key, value):
# Note: The dict and list are passed by reference, so we can just update them
try: # in case key doesn't exist
existing_value = colors[key]
except KeyError: # key does not exist, update dict and list
mydict.update({key: value})
index_list.append(key)
else: # key already exists, just update value
mydict[key] = value


index_add_item(colors, colors_i, 'purple', '99')
print(f'colors: {colors}\ncolors_i: {colors_i}')
# colors: {'blue': '5', 'red': '6', 'yellow': '8', 'purple': '99'}
# colors_i: ['blue', 'red', 'yellow', 'purple']


index_add_item(colors, colors_i, 'blue', '1')
print(f'colors: {colors}\ncolors_i: {colors_i}')
# colors: {'blue': '1', 'red': '6', 'yellow': '8', 'purple': '99'}
# colors_i: ['blue', 'red', 'yellow', 'purple']
小开

我进一步提出了 LightCC 的回答:

def key_value(mydict, find_code, find_key, return_value):
for key in mydict:
if key[find_code] == find_key:
return key[return_value]
return None

而且我不确定这个 def是否可以进一步优化(接近一线程)。

小开

给出 Python 3.7及更高版本中的 dict 麦迪，在 dict按插入顺序排列之后，可以这样做:

  • next(iter(mydict.items()))检索插入的第一个键值对。
  • next(iter(mydict.keys()))检索插入的第一个密钥。
  • 检索插入的第一个值。

这种方法不需要遍历字典的所有元素。


提交答案