Python 从dict返回第一个N键：值对

考虑以下词典，d：

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

---

我想从d返回第一个N键：值对（N没有“前N”键这样的事情，因为a

dict

不记得先插入了哪些键

您可以通过以下方式获得任意n个键值对：

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

这使用了

的实现，从以下位置获取
：

在线查看它的工作情况：



Python 3.6的更新

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

Python的
dict
s没有顺序，因此请求“前N个”键是没有意义的

如果您需要的话，这个类是可用的。您可以高效地获得它的前四个元素

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

允许您惰性地从任何迭代器中获取元素片段。如果希望结果可重用，则需要将其转换为列表或类似的内容：

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

您可以通过多种方式实现这一点。如果顺序很重要，您可以这样做：

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

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

如果订单不是问题，您可以这样做：

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

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

请参阅对字典进行排序。然后使用前面提到的iterable代码

如果您需要提高排序键值对的效率，请使用不同的数据结构，即维护排序顺序和键值关联的数据结构

例如

导入对分
kvlist=[（'a'，1），（'b'，2），（'c'，3），（'e'，5）]
左内对分（kvlist，（'d'，4））
打印kvlist#[（'a'，1），（'b'，2），（'c'，3），（'d'，4），（'e'，5）]
这取决于在您的情况下什么是“最有效的”

如果您只需要一个大型字典的半随机样本
foo
，请使用
foo.iteritems（）
，并根据需要从中获取尽可能多的值，这是一个惰性操作，可以避免创建键或项的显式列表

如果您需要首先对键进行排序，那么无法使用类似于
keys=foo.keys（）；keys.sort（）
或
sorted（foo.iterkeys（））
，您必须构建一个键的显式列表。然后对前N个
键进行切片或迭代

顺便说一句，你为什么关心“高效”的方法？你对你的程序进行了分析吗？如果你没有，请先使用显而易见且易于理解的方法。很可能它会做得很好，而不会成为瓶颈。
检索任何内容的一个非常有效的方法是将列表或词典理解与切片相结合。如果你不需要订购对于项目（您只需要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]}

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

通常，这样的理解总是比等效的“for x in y”循环运行得更快。此外，通过使用.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]}

没有在这里看到它。将不会被排序，但最简单的语法，如果你只需要从字典中获取一些元素

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

字典不维护顺序，所以在选择前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”个元素：

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

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

基本上，将视图（dict_items）转换为迭代器，然后使用next（）对其进行迭代。
对于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会成功的：）
希望有帮助
 只需使用zip添加一个答案

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

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

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

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

list（dictionaryName.items（））[：N]

在您的情况下，您可以将其更改为：

list（d.items（））[：4]
我尝试了上面的一些答案，并注意到其中一些答案与版本有关，在3.7版中不起作用

我还注意到，从3.6开始，所有字典都是按插入项的顺序排序的

尽管字典从3.6开始被排序，但您希望使用有序结构的一些语句似乎不起作用

对OP问题的回答最适合我

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

在py3中，这将实现这一点

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

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

def GetNFirstItems(self):
    self.dict = {f'Item{i + 1}': round(uniform(20.40, 50.50), 2) for i in range(10)}#Example Dict
    self.get_items = int(input())
    for self.index,self.item in zip(range(len(self.dict)),self.dict.items()):
        if self.index==self.get_items:
          break
        else:
            print(self.item,",",end="")

不寻常的方法，因为它给出了强烈的O（N）时间复杂性。
对于Python 3.8正确的答案应该是：

import more_itertools

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

first_n = more_itertools.take(3, d.items())
print(len(first_n))
print(first_n)

其输出为：

3
[('a', 3), ('b', 2), ('c', 3)]

在
pip之后，当然要安装更多的itertools
。
是
d
是您的字典，
n
是打印号码：

for idx, (k, v) in enumerate(d):
  if idx == n: break
  print((k, v))

将词典放入列表可能会很慢。您的词典可能太大，您不需要为了打印第一个词典中的一些词典而强制转换所有词典。
您可以通过调用词典上的
.items（）
来获取词典项。然后将其转换为一个
列表
，并从中获得前N项，就像在任何列表中一样

下面的代码打印dictionary对象的前3项

e、 g

产出：

[('a', 3), ('b', 2), ('c', 3)]

在第一个代码片段中，为了清晰起见，您可能应该称它为
value
，而不是
item
。这是一个金融程序的应用程序，我尝试尽可能高效地构建每一行代码。我没有介绍该计划，并同意这可能不会成为瓶颈，但我喜欢在默认情况下寻求有效的解决方案。谢谢你的回复。我尝试了你的代码，但是我得到了这个错误：
TypeError:“dict_items”对象是不可订阅的
{key:value for key，value in stocks.items（）[0:n]}
（stocks是我字典的名称）@Moondra-在运行字典项之前必须转换成列表。在上面的代码中，如果{key:value for key，value in list（d.items（））[0:n]}{A:n for（A，n）in[x for x in d.items（）[:4]}这一行可以工作。如果您想选择n个多个key:value对作为字典，而不是作为索引，这是一个更好的解决方案list@fermat4214它是一个