Python-从字典返回前N个key：value对

考虑以下字典d：

d = {'a': 3, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

我想从d返回前N个key：value对（在这种情况下，N <= 4）。最有效的方法是什么？

不需要“前n个”键，因为a dict不会记住首先插入的键。

你可以任意 n键-值对，但：

n_items = take(n, d.iteritems())

这使用take来自itertools配方的实现：

from itertools import islice

def take(n, iterable):
    "Return first n items of the iterable as a list"
    return list(islice(iterable, n))

看到它在线上工作：ideone

Python 3.6更新

n_items = take(n, d.items())

检索任何内容的一种非常有效的方法是将列表或字典理解与切片结合在一起。如果您不需要订购商品（您只需要n个随机对），则可以使用如下的字典理解：

# Python 2
first2pairs = {k: mydict[k] for k in mydict.keys()[:2]}
# Python 3
first2pairs = {k: mydict[k] for k in list(mydict)[:2]}

通常，这样的理解总是比等效的“ for y中的x”循环要快。另外，通过使用.keys（）创建字典关键字列表并对该列表进行切片，可以避免在构建新字典时“触摸”任何不必要的关键字。

如果不需要键（仅值），则可以使用列表推导：

first2vals = [v for v in mydict.values()[:2]]

如果您需要根据其键对值进行排序，那么麻烦就不多了：

first2vals = [mydict[k] for k in sorted(mydict.keys())[:2]]

或者，如果您还需要按键：

first2pairs = {k: mydict[k] for k in sorted(mydict.keys())[:2]}

Python的dict不排序，因此要求“前N个”键毫无意义。

collections.OrderedDict如果您需要，可以使用该课程。您可以有效地获得其前四个要素

import itertools
import collections

d = collections.OrderedDict((('foo', 'bar'), (1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')))
x = itertools.islice(d.items(), 0, 4)

for key, value in x:
    print key, value

itertools.islice允许您懒惰地从任何迭代器中获取元素的一部分。如果您希望结果可重用，则需要将其转换为列表或类似内容，例如：

x = list(itertools.islice(d.items(), 0, 4))

foo = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5, 'f':6}
iterator = iter(foo.items())
for i in range(3):
    print(next(iterator))

基本上，将视图（dict_items）变成一个迭代器，然后使用next（）对其进行迭代。

在这里没有看到它。如果只需要从字典中提取某些元素，则不会在语法上排序，而是从语法上最简单。

n = 2
{key:value for key,value in d.items()[0:n]}

要从python字典中获取前N个元素，可以使用以下代码行：

list(dictionaryName.items())[:N]

您可以将其更改为：

list(d.items())[:4]

参见PEP 0265有关对字典进行排序。然后使用前面提到的可迭代代码。

如果您需要更高效率的已排序键值对。使用不同的数据结构。也就是说，它保持排序顺序和键值关联。

例如

import bisect

kvlist = [('a', 1), ('b', 2), ('c', 3), ('e', 5)]
bisect.insort_left(kvlist, ('d', 4))

print kvlist # [('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)]

在py3中，这可以解决问题

{A:N for (A,N) in [x for x in d.items()][:4]}

{'a'：3，'b'：2，'c'：3，'d'：4}

只需使用zip添加答案，

{k: d[k] for k, _ in zip(d, range(n))}

这取决于您的情况下“最有效”的方法。

如果您只想要一个巨大词典的半随机样本foo，foo.iteritems()并根据需要使用它并从中获取尽可能多的值，那么这是一个懒惰的操作，可以避免创建键或项的显式列表。

如果您需要先对键进行排序，则无法使用keys = foo.keys(); keys.sort()或sorted(foo.iterkeys())来构建键的显式列表。然后对第一个N进行切片或迭代keys。

顺便说一句，您为什么关心“有效”方式？您是否对程序进行了简介？如果您没有这样做，请首先使用明显且易于理解的方法。它很有可能在不成为瓶颈的情况下做得很好。

您可以通过多种方法来实现。如果订单很重要，则可以执行以下操作：

for key in sorted(d.keys()):
  item = d.pop(key)

如果不需要订购，可以执行以下操作：

for i in range(4):
  item = d.popitem()

字典没有顺序，因此在选择前N个键值对之前，先对其进行排序。

import operator
d = {'a': 3, 'b': 2, 'c': 3, 'd': 4}
d=dict(sorted(d.items(),key=operator.itemgetter(1),reverse=True))
#itemgetter(0)=sort by keys, itemgetter(1)=sort by values

现在，我们可以使用以下方法结构来检索前N个元素：

def return_top(elements,dictionary_element):
    '''Takes the dictionary and the 'N' elements needed in return
    '''
    topers={}
    for h,i in enumerate(dictionary_element):
        if h<elements:
            topers.update({i:dictionary_element[i]})
    return topers

要获得前2个元素，则只需使用以下结构：

d = {'a': 3, 'b': 2, 'c': 3, 'd': 4}
d=dict(sorted(d.items(),key=operator.itemgetter(1),reverse=True))
d=return_top(2,d)
print(d)

对于Python 3及更高版本，要选择前n对

n=4
firstNpairs = {k: Diction[k] for k in list(Diction.keys())[:n]}

考虑一个命令

d = {'a': 3, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

from itertools import islice
n = 3
list(islice(d.items(),n))

islice可以解决问题：)希望能有所帮助！

这可能不是很优雅，但是对我有用：

d = {'a': 3, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

x= 0
for key, val in d.items():
    if x == 2:
        break
    else:
        x += 1
        # Do something with the first two key-value pairs

我已经尝试了上面的一些答案，并注意到其中一些是依赖于版本的，并且在3.7版中不起作用。

我还注意到，自3.6起，所有字典均按插入项的顺序排序。

尽管从3.6版开始就对字典进行了排序，但是您希望使用有序结构的某些语句似乎不起作用。

最适合我的OP问题的答案。

itr = iter(dic.items())
lst = [next(itr) for i in range(3)]