返回第一个 N 键: 来自 dict 的值对

没有这样的“第一个 n”键，因为 dict不记得哪个键是第一个插入的。

不过，您可以得到 任何n 键值对:

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

这使用了来自 itertools食谱的 take的实现:

from itertools import islice


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

在线观看: 想法

Python 3.6更新 < br >

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

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))

你可以通过多种方式来解决这个问题。如果秩序很重要，你可以这样做:

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

如果秩序不是一个问题，你可以这样做:

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

请参阅字典排序的 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)]

这取决于在你的情况下什么是“最有效率的”。

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

如果您需要首先对键进行排序，那么就没有办法使用类似于 keys = foo.keys(); keys.sort()或 sorted(foo.iterkeys())的东西，您必须构建一个显式的键列表。然后对第一个 N keys进行切片或迭代。

顺便说一句，你为什么关心“高效”的方式？你给你的项目做侧写了吗？如果你没有，使用 很明显和 很容易理解的方式第一。它很可能在不成为瓶颈的情况下表现得相当不错。

检索任何内容的一种非常有效的方法是将列表或字典理解与切片相结合。如果你不需要对条目进行排序(你只需要 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 x in y”循环运行得更快。另外，通过使用。Key ()来创建一个字典键的列表，并在构建新字典时避免“触及”任何不必要的键。

如果你不需要键(只需要值) ，你可以使用列表内涵:

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

Dictionary 没有维护顺序，所以在选择顶部 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

现在我们可以检索 top‘ 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

得到前两个元素，然后简单地使用这个结构:

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)

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 _ item)转换为迭代器，然后使用 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))

伊斯里斯就能做到:) 希望能有帮助！

用 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 install more-itertools之后。

如果 d是你的字典，而 n是打印号码:

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

将字典转换为列表可能会很慢。您的字典可能太大了，您不需要为了打印第一个字典中的几个而将所有的字典都投入使用。