从 dict 返回前 N 个键：值对

Question

考虑以下字典，d：

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

我想从 d 中返回前 N 个键：值对（在本例中为 N

Answer 1

您可以通过在字典上调用.items() 来获取字典项。然后将其转换为 list 并从那里获得前 N 项，就像在任何列表中一样。

以下代码打印字典对象的前 3 项

例如

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

first_three_items = list(d.items())[:3]

print(first_three_items)

输出：

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

Answer 2

d 是您的字典，n 是印刷号码：

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

将您的字典转换为列表可能会很慢。你的字典可能太大了，你不需要为了打印一些第一个而把它全部转换。

Answer 3

对于 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 之后。

Answer 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) 时间复杂度。

Answer 5

在 py3 中，这可以解决问题

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

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

Answer 6

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

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

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

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

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

Answer 7

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

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

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

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

Answer 8

没有“前 n”个键这样的东西，因为 dict 不记得先插入了哪些键。

你可以得到 any n 个键值对：

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

这使用来自itertools recipes 的take 的实现：

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

Answer 9

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

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

Answer 10

只需使用 zip 添加答案，

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

Answer 11

考虑一个字典

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

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

islice 可以解决问题 :) 希望有帮助！

Answer 12

检索任何内容的一种非常有效的方法是将列表或字典推导与切片相结合。如果您不需要订购项目（您只需要 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”循环运行得更快。此外，通过使用 .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]}

Answer 13

对于 Python 3 及以上版本，选择前 n 对

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

Answer 14

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()进行迭代。

Answer 15

字典没有顺序，所以在选择前 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)

Answer 16

这里没看到。如果您只需要从字典中获取一些元素，则不会被排序，而是最简单的语法。

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

Answer 17

请参阅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)]

Answer 18

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

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

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

顺便说一句，您为什么关心“高效”方式？你介绍过你的程序吗？如果没有，请先使用明显和易于理解的方式。它很有可能会做得很好而不会成为瓶颈。

Answer 19

您可以通过多种方式解决此问题。如果顺序很重要，您可以这样做：

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

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

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

Answer 20

Python 的dicts 没有排序，所以要求“前 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))