如何将索引编入字典？-IT科技

问题描述：

我有一本以下词典：

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

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

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

解决方案 1：

如果仍有人在关注这个问题，那么目前接受的答案已经过时了：

从 Python 3.7 * 开始，字典是保序的，也就是说，它们现在的行为与collections.OrderedDicts 类似。不幸的是，仍然没有专门的方法来索引字典中的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 已经包含插入顺序字典，但这只是一个实现细节。语言规范从 3.7 开始包含插入顺序字典。

解决方案 2：

在 Python 3.6 及之前的版本中，字典都是无序的。如果您不关心条目的顺序，并且无论如何都想通过索引访问键或值，则可以d使用为字典创建键列表keys = list(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 中依赖它。

解决方案 3：

如果您需要有序的字典，您可以使用odict。

解决方案 4：

哦，这很难。基本上，这里每个项目有两个值。然后你尝试用数字作为键来调用它们。不幸的是，你的一个值已经设置为键了！

尝试一下：

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

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

例如，

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

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

当然，您必须想出另一种方法来跟踪每种颜色的位置。也许您可以有另一个字典，将每种颜色的键存储为其值。

colors_key = {'蓝色': 1, '红色': 6, '黄色': 8}

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

colors[colors_key['blue']][0] 将返回 'blue'

类似这样的。

然后，当你这样做的时候，你可以创建一个以数字值作为键的字典，这样你就可以随时使用它们来查找你的颜色，如果你需要的话。

值 = {5：[1，'蓝色']，6：[2，'红色']，8：[3，'黄色']}

然后，(colorscolors_key[values[5]][0]) 将返回“蓝色”。

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

祝你好运！

解决方案 5：

解决字典中的一个元素就像骑在驴身上享受骑行的乐趣。

根据 Python 的规则，DICTIONARY 是无序的

如果有

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

或者任何这样的组合。

因此，经验法则是，字典是无序的！

解决方案 6：

考虑一下为什么要建立索引

首先，我想说的是，确保您确实需要对字典进行索引。字典最初甚至没有顺序，因此也许有另一种方法可以解决索引需求，即利用现有基本 Python 数据类型的优势。

例如，如果您有一个按特定顺序需要的颜色列表，则只需存储颜色列表，然后对其进行索引，并将它们输入到字典中以获取值。

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()。如果您使用该enumerate()函数，它将自动生成索引值。

这是最直接的方法，但每次查找索引时会消耗更多 CPU。这假设一个有序字典（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)列表的方法查找索引。列表比使用索引创建字典更可取，因为列表本身已经有索引，并且内置函数通常更快，更有可能正确处理边缘和极端情况。

这种方法会产生额外的开销，但是如果您正在进行大量数据分析并且需要定期访问索引，那么它可能是值得的。

# 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}
color_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"

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

更新字典和列表的函数

下面是一个同时更新字典和索引列表的函数。如果某个项目已经存在，它将更新该值，而不会将其添加到列表中（否则列表中将出现重复的条目，而字典将仅更新现有条目）。

如果进行大量处理，可以将此方法扩展为一个类，特别是如果在此基础上需要其他扩展功能。

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}
colors_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}
colors_i: {colors_i}')
# colors: {'blue': '1', 'red': '6', 'yellow': '8', 'purple': '99'}
# colors_i: ['blue', 'red', 'yellow', 'purple']

解决方案 7：

实际上，我发现了一个真正帮助我的新颖的解决方案，如果您特别关心列表或数据集中某个值的索引，那么您只需将字典的值设置为该索引即可！：

只需观看：

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}

现在，通过哈希表的强大功能，您可以在恒定时间内（即速度更快）提取条目的索引

解决方案 8：

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

解决方案 9：

我进一步提出了 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可以进一步优化它（尽可能单行优化）。

解决方案 10：

简单且有效的代码。

# Example dictionary
d = {
    'a': 5,
    'b': 6,
    'c': 7,
    'd': 8,
    'e': 9,
}
# Index you want
index = 3 
# Use the fact that d.keys() is ordered the same as d.values()
value = d[list(d.keys())[index]] 
print(value)

将打印

根据这个问题，键和值的顺序相同