在 Python 中访问字典中的任意元素

问题描述：

如果mydict不为空，我可以按如下方式访问任意元素：

mydict[list(mydict.keys())[0]]

有没有更好的方法可以做到这一点？

解决方案 1：

在 Python 3 上，非破坏性地和迭代地：

next(iter(mydict.values()))

在 Python 2 上，非破坏性地和迭代地：

mydict.itervalues().next()

如果你希望它在 Python 2 和 3 中都能工作，你可以使用该six包：

six.next(six.itervalues(mydict))

尽管现在它还很神秘，但我更喜欢你的代码。

如果您想删除任何项目，请执行以下操作：

key, value = mydict.popitem()

请注意，“first”在这里可能不是一个合适的术语，因为dict它在 Python < 3.6 中不是有序类型。Python 3.6+dicts是有序的。

解决方案 2：

如果你只需要访问一个元素（碰巧是第一个元素，因为字典不能保证排序），你可以在Python 2中简单地执行以下操作：

my_dict.keys()[0]    # key of "first" element
my_dict.values()[0]  # value of "first" element
my_dict.items()[0]   # (key, value) tuple of "first" element

请注意（据我所知）Python 不保证对这些方法中的任何一个的两次连续调用将返回具有相同顺序的列表。Python3 不支持此功能。

在Python 3中：

list(my_dict.keys())[0]    # key of "first" element
list(my_dict.values())[0]  # value of "first" element
list(my_dict.items())[0]   # (key, value) tuple of "first" element

解决方案 3：

在python3中，方法如下：

dict.keys() 

返回一个类型为：dict_keys() 的值，当我们通过这种方式获取字典中键的第一个成员时，我们会得到一个错误：

dict.keys()[0]
TypeError: 'dict_keys' object does not support indexing

最后，我将dict.keys()转换为列表@1st，并通过列表拼接方法获取第一个成员：

list(dict.keys())[0]

解决方案 4：

拿到钥匙

next(iter(mydict))

获得一个值

next(iter(mydict.values()))

两者兼得

next(iter(mydict.items())) # or next(iter(mydict.viewitems())) in python 2

前两个是 Python 2 和 3。后两个在 Python 3 中是惰性的，但在 Python 2 中不是。

解决方案 5：

正如其他人提到的，没有“第一项”，因为字典没有保证的顺序（它们被实现为哈希表）。例如，如果您想要与最小键相对应的值，thedict[min(thedict)]就可以这样做。如果您关心键的插入顺序，即“第一”是指“最早插入”，那么在 Python 3.1 中，您可以使用collections.OrderedDict，它也在即将推出的 Python 2.7 中；对于旧版本的 Python，请下载、安装并使用有序 dict 反向移植（2.4 及更高版本），您可以在此处找到。

Python 3.7
现在字典是按插入顺序排列的。

解决方案 6：

这个怎么样？这里还没有提到。

py2和3

a = {"a":2,"b":3}
a[list(a)[0]] # the first element is here
>>> 2

解决方案 7：

忽略有关字典排序的问题，这可能会更好：

next(dict.itervalues())

这样，我们就避免了查找项目并生成我们不使用的键列表。

Python3

next(iter(dict.values()))

解决方案 8：

在python3中

list(dict.values())[0]

解决方案 9：

first_key, *rest_keys = mydict

解决方案 10：

你总是可以这样做：

for k in sorted(d.keys()):
    print d[k]

如果排序对您有意义，这将为您提供一组可以处理的一致排序的键（我猜是相对于内置的.hash()）。这意味着，例如，即使您扩展字典，数字类型也会始终排序。

例子

# lets create a simple dictionary
d = {1:1, 2:2, 3:3, 4:4, 10:10, 100:100}
print d.keys()
print sorted(d.keys())

# add some other stuff
d['peter'] = 'peter'
d['parker'] = 'parker'
print d.keys()
print sorted(d.keys())

# some more stuff, numeric of different type, this will "mess up" the keys set order
d[0.001] = 0.001
d[3.14] = 'pie'
d[2.71] = 'apple pie'
print d.keys()
print sorted(d.keys())

请注意，打印时字典是排序的。但键集本质上是一个哈希表！

解决方案 11：

对于 Python 2 和 3：

import six

six.next(six.itervalues(d))

解决方案 12：

在保持字典完整的同时用一行完成此操作的另一种方法是：

arbitrary_value = mydict.setdefault(*mydict.popitem())

popitem()返回添加到字典中的最后一项的 (key, value) 元组，并将该对setdefault作为位置参数传递。如果尚不存在，则setdefault尝试将值key插入，但如果存在，则不执行任何操作；然后将该键的值返回给调用者。因为我们已经从字典中弹出了 (key, value) 对，所以我们通过将其重新插入字典，然后继续返回，这正是我们想要的。mydict`valuesetdefaultvalue`

解决方案 13：

无需外部库，适用于 Python 2.7 和 3.x：

>>> list(set({"a":1, "b": 2}.values()))[0]
1

对于任意键，只需省略 .values()

>>> list(set({"a":1, "b": 2}))[0]
'a'

解决方案 14：

子类化dict是一种方法，但效率不高。在这里，如果你提供一个整数，它将返回d[list(d)[n]]，否则按预期访问字典：

class mydict(dict):
    def __getitem__(self, value):
        if isinstance(value, int):
            return self.get(list(self)[value])
        else:
            return self.get(value)

d = mydict({'a': 'hello', 'b': 'this', 'c': 'is', 'd': 'a',
            'e': 'test', 'f': 'dictionary', 'g': 'testing'})

d[0]    # 'hello'
d[1]    # 'this'
d['c']  # 'is'