blocks|key|5035921|text|没有“前n”个键这样的东西，因为dict不会记住哪个键是首先插入的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5035922|不过，您可以获得任意n个键-值对：|5035923|n_items+=+take(n,+d.iteritems())|code-block|syntax|javascript|5035924|这使用itertools+recipes中的take实现|5035925|from+itertools+import+islice

def+take(n,+iterable):
++++"Return+first+n+items+of+the+iterable+as+a+list"
++++return+list(islice(iterable,+n))|5035926|在线查看它的工作方式：ideone|5035927|Python3.6的更新|BOLD|5035928|n_items+=+take(n,+d.items())|5035929|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/library/itertools.html#recipes|1|http://ideone.com/LLgFX^0|G|4|0|0|0|3|9|M|4|3|H|0|0|0|B|6|1|0|A|2|0|0^^$0|@$1|2|3|4|5|6|7|17|8|@$9|18|A|19|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1A|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1B|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1C|8|@$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]]|D|@$9|1H|A|1I|1|1J]]|E|$]]|$1|O|3|P|5|J|7|1K|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1L|8|@]|D|@$9|1M|A|1N|1|1O]]|E|$]]|$1|S|3|T|5|6|7|1P|8|@$9|1Q|A|1R|B|U]]|D|@]|E|$]]|$1|V|3|W|5|J|7|1S|8|@]|D|@]|E|$K|L]]|$1|X|3|-4|5|6|7|1T|8|@]|D|@]|E|$]]]|Y|$Z|$5|10|11|12|E|$13|14]]|15|$5|10|11|12|E|$13|16]]]]

There's no such thing a the "first n" keys because a <code>dict</code> doesn't remember which keys were inserted first.

You can get any n key-value pairs though:

<pre><code>n_items = take(n, d.iteritems())
</code></pre>

This uses the implementation of <code>take</code> from the <a href="http://docs.python.org/library/itertools.html#recipes" rel="noreferrer"><code>itertools</code> recipes</a>:

<pre><code>from itertools import islice

def take(n, iterable):
 "Return first n items of the iterable as a list"
 return list(islice(iterable, n))
</code></pre>

See it working online: <a href="http://ideone.com/LLgFX" rel="noreferrer">ideone</a>

 
Update for Python 3.6 

<pre><code>n_items = take(n, d.items())
</code></pre>

blocks|key|3138478|text|Python的dict是没有排序的，所以请求“前N”个键是没有意义的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3138479|如果需要的话，可以使用collections.OrderedDict类。您可以高效地将它的前四个元素获取为|3138480|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|code-block|syntax|javascript|3138481|itertools.islice允许您懒惰地从任何迭代器中获取元素切片。如果您希望结果可重用，则需要将其转换为列表或其他格式，如下所示：|3138482|x+=+list(itertools.islice(d.items(),+0,+4))|3138483|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/dev/library/collections.html#collections.OrderedDict|1|http://docs.python.org/library/itertools.html#itertools.islice^0|7|4|0|B|N|B|N|0|0|0|0|G|0|G|1|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|13|8|@$9|14|A|15|B|C]]|D|@$9|16|A|17|1|18]]|E|$]]|$1|H|3|I|5|J|7|19|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1A|8|@$9|1B|A|1C|B|C]]|D|@$9|1D|A|1E|1|1F]]|E|$]]|$1|O|3|P|5|J|7|1G|8|@]|D|@]|E|$K|L]]|$1|Q|3|-4|5|6|7|1H|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]|Y|$5|T|U|V|E|$W|Z]]]]

Python's <code>dict</code>s are not ordered, so it's meaningless to ask for the "first N" keys.

The <a href="http://docs.python.org/dev/library/collections.html#collections.OrderedDict" rel="noreferrer"><code>collections.OrderedDict</code></a> class is available if that's what you need. You could efficiently get its first four elements as

<pre><code>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
</code></pre>

<a href="http://docs.python.org/library/itertools.html#itertools.islice" rel="noreferrer"><code>itertools.islice</code></a> allows you to lazily take a slice of elements from any iterator. If you want the result to be reusable you'd need to convert it to a list or something, like so:

<pre><code>x = list(itertools.islice(d.items(), 0, 4))
</code></pre>

blocks|key|3138510|text|您可以通过许多方法来实现这一点。如果顺序很重要，您可以这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3138511|for+key+in+sorted(d.keys()):
++item+=+d.pop(key)|code-block|syntax|javascript|3138512|如果顺序不是问题，你可以这样做：|3138513|for+i+in+range(4):
++item+=+d.popitem()|3138514|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

You can approach this a number of ways. If order is important you can do this:

<pre><code>for key in sorted(d.keys()):
 item = d.pop(key)
</code></pre>

If order isn't a concern you can do this:

<pre><code>for i in range(4):
 item = d.popitem()
</code></pre>

blocks|key|798130|text|请参阅有关字典排序的PEP+0265。然后使用前面提到的可迭代代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|798131|如果您需要在排序的键值对中提高效率。使用不同的数据结构。也就是说，它维护排序顺序和键值关联。|798132|例如。|798133|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)]|code-block|syntax|javascript|798134|entityMap|0|LINK|mutability|MUTABLE|url|http://www.python.org/dev/peps/pep-0265/^0|A|8|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|Z|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|10|8|@]|9|@]|C|$K|L]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

See <a href="http://www.python.org/dev/peps/pep-0265/" rel="nofollow">PEP 0265</a> on sorting dictionaries. Then use the aforementioned iterable code.

If you need more efficiency in the sorted key-value pairs. Use a different data structure. That is, one that maintains sorted order and the key-value associations.

E.g.

<pre class="lang-py prettyprint-override"><code>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)]
</code></pre>

blocks|key|4753702|text|这取决于你的情况下什么是“最有效”的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4753703|如果您只想要一个大型字典foo的半随机样本，请使用foo.iteritems()并根据需要从其中获取任意多个值，这是一种延迟操作，可以避免创建显式的键或项列表。|offset|length|style|CODE|4753704|如果您需要首先对键进行排序，那么就没有办法使用keys+=+foo.keys();+keys.sort()或sorted(foo.iterkeys())之类的东西，您必须构建一个显式的键列表。然后对前N个keys进行切片或迭代。|4753705|顺便说一句，你为什么关心“高效”的方式？你描述你的程序了吗？如果没有，请先使用显而易见且易于理解的方法。它很有可能在不成为瓶颈的情况下做得很好。|4753706|entityMap^0|0|C|3|P|F|0|N|U|1I|M|2U|4|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@$D|P|E|Q|F|G]|$D|R|E|S|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|T|8|@$D|U|E|V|F|G]|$D|W|E|X|F|G]|$D|Y|E|Z|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|10|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|M|$]]

This depends on what is 'most efficient' in your case.

If you just want a semi-random sample of a huge dictionary <code>foo</code>, use <code>foo.iteritems()</code> and take as many values from it as you need, it's a lazy operation that avoids creation of an explicit list of keys or items. 

If you need to sort keys first, there's no way around using something like <code>keys = foo.keys(); keys.sort()</code> or <code>sorted(foo.iterkeys())</code>, you'll have to build an explicit list of keys. Then slice or iterate through first N <code>keys</code>.

BTW why do you care about the 'efficient' way? Did you profile your program? If you did not, use the obvious and easy to understand way first. Chances are it will do pretty well without becoming a bottleneck.

blocks|key|4753739|text|检索任何东西的一种非常有效的方法是将列表或字典理解与切片相结合。如果你不需要对项目进行排序(你只需要n个随机对)，你可以像这样使用字典理解：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4753740|#+Python+2
first2pairs+=+{k:+mydict[k]+for+k+in+mydict.keys()[:2]}
#+Python+3
first2pairs+=+{k:+mydict[k]+for+k+in+list(mydict)[:2]}|code-block|syntax|javascript|4753741|通常，像这样的理解总是比等效的"for+x+in+y“循环运行得更快。此外，通过使用.keys()创建字典键的列表并对该列表进行切片，可以避免在构建新字典时“接触”任何不必要的键。|4753742|如果你不需要键(只需要值)，你可以使用列表理解：|4753743|first2vals+=+[v+for+v+in+mydict.values()[:2]]|4753744|如果您需要根据值的键对值进行排序，则不会有太多麻烦：|4753745|first2vals+=+[mydict[k]+for+k+in+sorted(mydict.keys())[:2]]|4753746|或者，如果您还需要密钥：|4753747|first2pairs+=+{k:+mydict[k]+for+k+in+sorted(mydict.keys())[:2]}|4753748|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|10|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|12|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

A very efficient way to retrieve anything is to combine list or dictionary comprehensions with slicing. If you don't need to order the items (you just want n random pairs), you can use a dictionary comprehension like this:

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

Generally a comprehension like this is always faster to run than the equivalent "for x in y" loop. Also, by using .keys() to make a list of the dictionary keys and slicing that list you avoid 'touching' any unnecessary keys when you build the new dictionary. 

If you don't need the keys (only the values) you can use a list comprehension:

<pre><code>first2vals = [v for v in mydict.values()[:2]]
</code></pre>

If you need the values sorted based on their keys, it's not much more trouble:

<pre><code>first2vals = [mydict[k] for k in sorted(mydict.keys())[:2]]
</code></pre>

or if you need the keys as well:

<pre><code>first2pairs = {k: mydict[k] for k in sorted(mydict.keys())[:2]}
</code></pre>

blocks|key|4753761|text|在这上面没看到。如果您只需要从字典中获取一些元素，则不会进行排序，但在语法上是最简单的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4753762|n+=+2
{key:value+for+key,value+in+d.items()[0:n]}|code-block|syntax|javascript|4753763|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Did not see it on here. Will not be ordered but the simplest syntactically if you need to just take some elements from a dictionary.

<pre><code>n = 2
{key:value for key,value in d.items()[0:n]}
</code></pre>

blocks|key|5036139|text|字典不维护顺序，因此在选择前N个键值对之前，让我们对其进行排序。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5036140|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|code-block|syntax|javascript|5036141|现在我们可以检索前'N‘个元素：，使用如下的方法结构：|5036142|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|5036143|要获得前两个元素，只需使用以下结构：|5036144|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)|5036145|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Dictionary maintains no order , so before picking top N key value pairs lets make it sorted.

<pre><code>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
</code></pre>

Now we can do the retrieval of top 'N' elements:, using the method structure like this:

<pre><code>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&lt;elements:
 topers.update({i:dictionary_element[i]})
 return topers
</code></pre>

to get the top 2 elements then simply use this structure:

<pre><code>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)
</code></pre>

blocks|key|5036164|text|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))|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|5036165|基本上，将视图(dict_items)转换为迭代器，然后使用next()迭代它。|unstyled|5036166|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>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))
</code></pre>

Basically, turn the view (dict_items) into an iterator, and then iterate it with next().

blocks|key|4753846|text|对于Python+3及更高版本，选择前n对|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4753847|n=4
firstNpairs+=+{k:+Diction[k]+for+k+in+list(Diction.keys())[:n]}|code-block|syntax|javascript|4753848|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

For Python 3 and above,To select first n Pairs

<pre><code>n=4
firstNpairs = {k: Diction[k] for k in list(Diction.keys())[:n]}
</code></pre>

blocks|key|3138746|text|考虑一个字典|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3138747|d+=+{'a':+3,+'b':+2,+'c':+3,+'d':+4,+'e':+5}

from+itertools+import+islice
n+=+3
list(islice(d.items(),n))|code-block|syntax|javascript|3138748|islice将会做到这一点:)希望它能帮上忙！|3138749|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

consider a dict 

<pre><code>d = {'a': 3, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

from itertools import islice
n = 3
list(islice(d.items(),n))
</code></pre>

islice will do the trick :) 
hope it helps !

blocks|key|4753900|text|只需使用zip添加答案，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4753901|{k:+d[k]+for+k,+_+in+zip(d,+range(n))}|code-block|syntax|javascript|4753902|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

just add an answer using zip,

<pre><code>{k: d[k] for k, _ in zip(d, range(n))}
</code></pre>

blocks|key|5036237|text|这可能不是很优雅，但对我来说很有效：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5036238|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+%2B=+1
++++++++#+Do+something+with+the+first+two+key-value+pairs|code-block|syntax|javascript|5036239|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This might not be very elegant, but works for me:

<pre><code>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
</code></pre>

blocks|key|798244|text|要从python字典中获取前N个元素，可以使用以下代码行：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|798245|list(dictionaryName.items())[:N]|code-block|syntax|javascript|798246|在您的情况下，可以将其更改为：|798247|list(d.items())[:4]|798248|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

To get the top N elements from your python dictionary one can use the following line of code:

<pre class="lang-py prettyprint-override"><code>list(dictionaryName.items())[:N]
</code></pre>

In your case you can change it to:

<pre class="lang-py prettyprint-override"><code>list(d.items())[:4]
</code></pre>

blocks|key|802116|text|我已经尝试了上面的一些答案，并注意到其中一些是版本相关的，在3.7版本中不起作用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|802117|我还注意到，从3.6开始，所有字典都是按照插入条目的顺序排序的。|802118|尽管字典是从3.6版本开始排序的，但您希望与有序结构一起工作的一些语句似乎不起作用。|802119|最适合我的OP问题的答案。|802120|itr+=+iter(dic.items())
lst+=+[next(itr)+for+i+in+range(3)]|code-block|syntax|javascript|802121|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|R|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|S|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I have tried a few of the answers above and note that some of them are version dependent and do not work in version 3.7.

I also note that since 3.6 all dictionaries are ordered by the sequence in which items are inserted.

Despite dictionaries being ordered since 3.6 some of the statements you expect to work with ordered structures don't seem to work.

The answer to the OP question that worked best for me.

<pre><code>itr = iter(dic.items())
lst = [next(itr) for i in range(3)]
</code></pre>

blocks|key|798286|text|在py3中，这样做就可以了|type|unstyled|depth|inlineStyleRanges|entityRanges|data|798287|{A:N+for+(A,N)+in+[x+for+x+in+d.items()][:4]}|code-block|syntax|javascript|798288|{'a'：3，'b'：2，'c'：3，'d'：4}|798289|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

in py3, this will do the trick

<pre><code>{A:N for (A,N) in [x for x in d.items()][:4]}
</code></pre>

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

blocks|key|802164|text|def+GetNFirstItems(self):
++++self.dict+=+{f'Item{i+%2B+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="")|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|802165|不同寻常的方法，因为它给出了强烈的O(N)时间复杂度。|unstyled|802166|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>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,&quot;,&quot;,end=&quot;&quot;)
</code></pre>
Unusual approach, as it gives out intense O(N) time complexity.

blocks|key|3138994|text|对于Python3.8，正确答案应该是：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3138995|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)|code-block|syntax|javascript|3138996|其输出为：|3138997|3
[('a',+3),+('b',+2),+('c',+3)]|3138998|当然是在pip+install+more-itertools之后。|CODE|3138999|entityMap^0|2|9|0|0|0|0|4|Q|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|W|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|X|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|Z|8|@$9|10|A|11|B|Q]]|D|@]|E|$]]|$1|R|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|S|$]]

For Python 3.8 the correct answer should be:
<pre><code>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)
</code></pre>
Whose output is:
<pre><code>3
[('a', 3), ('b', 2), ('c', 3)]
</code></pre>
After <code>pip install more-itertools</code> of course.

blocks|key|798336|text|Were+d是您的字典，n是印刷编号：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|798337|for+idx,+(k,+v)+in+enumerate(d):
++if+idx+==+n:+break
++print((k,+v))|code-block|syntax|javascript|798338|将字典转换到列表中可能会很慢。你的字典可能太大了，你不需要把所有的字典都转换成第一个字典中的几个。|798339|entityMap^0|5|1|C|1|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

Were <code>d</code> is your dictionary and <code>n</code> is the printing number:
<pre><code>for idx, (k, v) in enumerate(d):
 if idx == n: break
 print((k, v))
</code></pre>
Casting your dictionary to list can be slow. Your dictionary may be too large and you don't need to cast all of it just for printing a few of the first.

blocks|key|5036519|text|您可以通过在字典上调用.items()来获取字典项。然后将其转换为list，并从那里获得前N个项目，就像在任何列表上一样。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5036520|下面的代码打印字典对象的前3项|5036521|例如：|5036522|d+=+{'a':+3,+'b':+2,+'c':+3,+'d':+4,+'e':+5}

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

print(first_three_items)|code-block|syntax|javascript|5036523|输出：|5036524|[('a',+3),+('b',+2),+('c',+3)]|5036525|entityMap^0|B|8|X|4|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|10|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|11|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|12|8|@]|D|@]|E|$]]|$1|Q|3|R|5|L|7|13|8|@]|D|@]|E|$M|N]]|$1|S|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|T|$]]

You can get dictionary items by calling <code>.items()</code> on the dictionary. then convert that to a <code>list</code> and from there get first N items as you would on any list.
below code prints first 3 items of the dictionary object
e.g.
<pre><code>d = {'a': 3, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

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

print(first_three_items)
</code></pre>
Outputs:
<pre><code>[('a', 3), ('b', 2), ('c', 3)]
</code></pre>

Consider the following dictionary, d:

<pre><code>d = {'a': 3, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
</code></pre>

I want to return the first N key:value pairs from d (N &lt;= 4 in this case). What is the most efficient method of doing this?

Return first N key:value pairs from dict

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

考虑下面的字典d：d = {'a': 3, 'b': 2, 'c': 3, 'd': 4, 'e': 5}我想从d返回前N个键:值对(在本例中是N <= 4)。执行此操作的最有效方法是什么？

问从dict返回前N个键:值对
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问从dict返回前N个键:值对EN