blocks|key|257174|text|这是一个速度测试，为什么不：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|257175|import+random
numEntries+=+1000000
d+=+dict(zip(range(numEntries),+[random.sample(range(0,+100),+2)+for+x+in+range(numEntries)]))

def+m1(d):
++++for+k+in+d:
++++++++for+x+in+d[k]:
++++++++++++pass

def+m2(d):
++++for+k,+dk+in+d.iteritems():
++++++++for+x+in+dk:
++++++++++++pass

import+cProfile

cProfile.run('m1(d)')

print

cProfile.run('m2(d)')

#+Ran+3+trials:
#+m1:+0.205,+0.194,+0.193:+average+0.197+s
#+m2:+0.176,+0.166,+0.173:+average+0.172+s

#+Method+1+takes+15%25+more+time+than+method+2|code-block|syntax|javascript|257176|cProfile示例输出：|257177|+++++++++3+function+calls+in+0.194+seconds

+++Ordered+by:+standard+name

+++ncalls++tottime++percall++cumtime++percall+filename:lineno(function)
++++++++1++++0.000++++0.000++++0.194++++0.194+<string>:1(<module>)
++++++++1++++0.194++++0.194++++0.194++++0.194+stackoverflow.py:7(m1)
++++++++1++++0.000++++0.000++++0.000++++0.000+{method+'disable'+of+'_lsprof.Profiler'+objects}



+++++++++4+function+calls+in+0.179+seconds

+++Ordered+by:+standard+name

+++ncalls++tottime++percall++cumtime++percall+filename:lineno(function)
++++++++1++++0.000++++0.000++++0.179++++0.179+<string>:1(<module>)
++++++++1++++0.179++++0.179++++0.179++++0.179+stackoverflow.py:12(m2)
++++++++1++++0.000++++0.000++++0.000++++0.000+{method+'disable'+of+'_lsprof.Profiler'+objects}
++++++++1++++0.000++++0.000++++0.000++++0.000+{method+'iteritems'+of+'dict'+objects}|257178|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|$]]

Here's a speed test, why not:

<pre><code>import random
numEntries = 1000000
d = dict(zip(range(numEntries), [random.sample(range(0, 100), 2) for x in range(numEntries)]))

def m1(d):
 for k in d:
 for x in d[k]:
 pass

def m2(d):
 for k, dk in d.iteritems():
 for x in dk:
 pass

import cProfile

cProfile.run('m1(d)')

print

cProfile.run('m2(d)')

# Ran 3 trials:
# m1: 0.205, 0.194, 0.193: average 0.197 s
# m2: 0.176, 0.166, 0.173: average 0.172 s

# Method 1 takes 15% more time than method 2
</code></pre>

cProfile example output:

<pre><code> 3 function calls in 0.194 seconds

 Ordered by: standard name

 ncalls tottime percall cumtime percall filename:lineno(function)
 1 0.000 0.000 0.194 0.194 &lt;string&gt;:1(&lt;module&gt;)
 1 0.194 0.194 0.194 0.194 stackoverflow.py:7(m1)
 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects}



 4 function calls in 0.179 seconds

 Ordered by: standard name

 ncalls tottime percall cumtime percall filename:lineno(function)
 1 0.000 0.000 0.179 0.179 &lt;string&gt;:1(&lt;module&gt;)
 1 0.179 0.179 0.179 0.179 stackoverflow.py:12(m2)
 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects}
 1 0.000 0.000 0.000 0.000 {method 'iteritems' of 'dict' objects}
</code></pre>

blocks|key|40434|text|下面是列表理解方法。嵌套的.|type|unstyled|depth|inlineStyleRanges|entityRanges|data|40435|r+=+[[i+for+i+in+d[x]]+for+x+in+d.keys()]
print+r

[[11,+12],+[21,+21]]|code-block|syntax|javascript|40436|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|$]]

Here's the list comprehension approach. Nested...

<pre><code>r = [[i for i in d[x]] for x in d.keys()]
print r

[[11, 12], [21, 21]]
</code></pre>

blocks|key|40478|text|我从Brionius代码中得到的结果：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|40479|+++++++++3+function+calls+in+0.173+seconds

+++Ordered+by:+standard+name

+++ncalls++tottime++percall++cumtime++percall+filename:lineno(function)
++++++++1++++0.000++++0.000++++0.173++++0.173+<string>:1(<module>)
++++++++1++++0.173++++0.173++++0.173++++0.173+speed.py:5(m1)
++++++++1++++0.000++++0.000++++0.000++++0.000+{method+'disable'+of+'_lsprof.Prof
iler'+objects}


+++++++++4+function+calls+in+0.185+seconds

+++Ordered+by:+standard+name

+++ncalls++tottime++percall++cumtime++percall+filename:lineno(function)
++++++++1++++0.000++++0.000++++0.185++++0.185+<string>:1(<module>)
++++++++1++++0.185++++0.185++++0.185++++0.185+speed.py:10(m2)
++++++++1++++0.000++++0.000++++0.000++++0.000+{method+'disable'+of+'_lsprof.Prof
iler'+objects}
++++++++1++++0.000++++0.000++++0.000++++0.000+{method+'iteritems'+of+'dict'+obje
cts}|code-block|syntax|javascript|40480|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|$]]

My results from Brionius code:

<pre><code> 3 function calls in 0.173 seconds

 Ordered by: standard name

 ncalls tottime percall cumtime percall filename:lineno(function)
 1 0.000 0.000 0.173 0.173 &lt;string&gt;:1(&lt;module&gt;)
 1 0.173 0.173 0.173 0.173 speed.py:5(m1)
 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Prof
iler' objects}


 4 function calls in 0.185 seconds

 Ordered by: standard name

 ncalls tottime percall cumtime percall filename:lineno(function)
 1 0.000 0.000 0.185 0.185 &lt;string&gt;:1(&lt;module&gt;)
 1 0.185 0.185 0.185 0.185 speed.py:10(m2)
 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Prof
iler' objects}
 1 0.000 0.000 0.000 0.000 {method 'iteritems' of 'dict' obje
cts}
</code></pre>

blocks|key|257276|text|我考虑了几种方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|257277|import+itertools

COLORED_THINGS+=+{'blue':+['sky',+'jeans',+'powerline+insert+mode'],
++++++++++++++++++'yellow':+['sun',+'banana',+'phone+book/monitor+stand'],
++++++++++++++++++'red':+['blood',+'tomato',+'test+failure']}

def+forloops():
++++"""+Nested+for+loops.+"""
++++for+color,+things+in+COLORED_THINGS.items():
++++++++for+thing+in+things:
++++++++++++pass

def+iterator():
++++"""+Use+itertools+and+list+comprehension+to+construct+iterator.+"""
++++for+color,+thing+in+(
++++++++itertools.chain.from_iterable(
++++++++++++[itertools.product((k,),+v)+for+k,+v+in+COLORED_THINGS.items()])):
++++++++pass

def+iterator_gen():
++++"""+Use+itertools+and+generator+to+construct+iterator.+"""
++++for+color,+thing+in+(
++++++++itertools.chain.from_iterable(
++++++++++++(itertools.product((k,),+v)+for+k,+v+in+COLORED_THINGS.items()))):
++++++++pass|code-block|syntax|javascript|257278|我使用ipython和memory_profiler来测试性能：|offset|length|257279|>>>+%25timeit+forloops()
1000000+loops,+best+of+3:+1.31+µs+per+loop

>>>+%25timeit+iterator()
100000+loops,+best+of+3:+3.58+µs+per+loop

>>>+%25timeit+iterator_gen()
100000+loops,+best+of+3:+3.91+µs+per+loop

>>>+%25memit+-r+1000+forloops()
peak+memory:+35.79+MiB,+increment:+0.02+MiB

>>>+%25memit+-r+1000+iterator()
peak+memory:+35.79+MiB,+increment:+0.00+MiB

>>>+%25memit+-r+1000+iterator_gen()
peak+memory:+35.79+MiB,+increment:+0.00+MiB|257280|正如您所看到的，该方法对峰值内存使用没有明显的影响，但是嵌套for循环在速度方面是无与伦比的(更不用说可读性了)。|style|CODE|257281|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/fabianp/memory_profiler#ipython-integration^0|0|0|B|F|0|0|0|U|3|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@]|9|@$I|11|J|12|1|13]]|A|$]]|$1|K|3|L|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|15|8|@$I|16|J|17|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]]]

I considered a couple methods:

<pre><code>import itertools

COLORED_THINGS = {'blue': ['sky', 'jeans', 'powerline insert mode'],
 'yellow': ['sun', 'banana', 'phone book/monitor stand'],
 'red': ['blood', 'tomato', 'test failure']}

def forloops():
 """ Nested for loops. """
 for color, things in COLORED_THINGS.items():
 for thing in things:
 pass

def iterator():
 """ Use itertools and list comprehension to construct iterator. """
 for color, thing in (
 itertools.chain.from_iterable(
 [itertools.product((k,), v) for k, v in COLORED_THINGS.items()])):
 pass

def iterator_gen():
 """ Use itertools and generator to construct iterator. """
 for color, thing in (
 itertools.chain.from_iterable(
 (itertools.product((k,), v) for k, v in COLORED_THINGS.items()))):
 pass
</code></pre>

I used ipython and <a href="https://github.com/fabianp/memory_profiler#ipython-integration" rel="noreferrer">memory_profiler</a> to test performance:

<pre><code>&gt;&gt;&gt; %timeit forloops()
1000000 loops, best of 3: 1.31 µs per loop

&gt;&gt;&gt; %timeit iterator()
100000 loops, best of 3: 3.58 µs per loop

&gt;&gt;&gt; %timeit iterator_gen()
100000 loops, best of 3: 3.91 µs per loop

&gt;&gt;&gt; %memit -r 1000 forloops()
peak memory: 35.79 MiB, increment: 0.02 MiB

&gt;&gt;&gt; %memit -r 1000 iterator()
peak memory: 35.79 MiB, increment: 0.00 MiB

&gt;&gt;&gt; %memit -r 1000 iterator_gen()
peak memory: 35.79 MiB, increment: 0.00 MiB
</code></pre>

As you can see, the method had no observable impact on peak memory usage, but nested <code>for</code> loops were unbeatable for speed (not to mention readability).

Given a dictionary of lists, such as 

<pre><code>d = {'1':[11,12], '2':[21,21]}
</code></pre>

Which is more pythonic or otherwise preferable:

<pre><code>for k in d:
 for x in d[k]:
 # whatever with k, x
</code></pre>

or

<pre><code>for k, dk in d.iteritems():
 for x in dk:
 # whatever with k, x
</code></pre>

or is there something else to consider?

EDIT, in case a list might be useful (e.g., standard dicts don't preserve order), this might be appropriate, although it's much slower.

<pre><code>d2 = d.items()
for k in d2:
 for x in d2[1]:
 # whatever with k, x
</code></pre>

python: iterating through a dictionary with list values

给定一个列表字典，例如d = {'1':[11,12], '2':[21,21]}哪一个更有蟒蛇气息或者更可取：for k in d:    for x in d[k]:        # whatever with k, x或for k, dk in d.iteritems():    for x in dk:   ...

问python:使用列表值遍历字典
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问python:使用列表值遍历字典EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问python:使用列表值遍历字典
EN