blocks|key|1437090|text|你总会有一个循环--有人可能会想出一个聪明的一行程序，将循环隐藏在对map()或类似程序的调用中，但它总是会存在的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1437091|除非性能是一个主要因素，否则我更喜欢拥有干净和简单的代码。|1437092|下面是您的代码的一个更具Pythonic风格的版本：|1437093|data+=+[['a','b'],+['a','c'],+['b','d']]
search+=+'c'
for+sublist+in+data:
++++if+sublist[1]+==+search:
++++++++print+"Found+it!",+sublist
++++++++break
#+Prints:+Found+it!+['a',+'c']|code-block|syntax|javascript|1437094|一旦找到匹配项，它就会跳出循环。|1437095|(顺便说一下，您在['b''d']中有一个拼写错误。)|1437096|entityMap^0|Y|5|0|0|0|0|0|9|8|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|Y|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|Z|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|10|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@]|E|$]]|$1|S|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|T|$]]

You're always going to have a loop - someone might come along with a clever one-liner that hides the loop within a call to <code>map()</code> or similar, but it's always going to be there.

My preference would always be to have clean and simple code, unless performance is a major factor.

Here's perhaps a more Pythonic version of your code:

<pre><code>data = [['a','b'], ['a','c'], ['b','d']]
search = 'c'
for sublist in data:
 if sublist[1] == search:
 print "Found it!", sublist
 break
# Prints: Found it! ['a', 'c']
</code></pre>

It breaks out of the loop as soon as it finds a match.

(You have a typo, by the way, in <code>['b''d']</code>.)

blocks|key|1439155|text|>>>+my_list+=[+['a',+'b'],+['a',+'c'],+['b',+'d']+]
>>>+'d'+in+(x[1]+for+x+in+my_list)
True|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1439156|编辑以添加：|unstyled|1439157|大卫使用any的答案和我在中使用的答案都将在找到匹配项时结束，因为我们使用的是生成器表达式。下面是一个使用无限生成器的测试，它显示了：|offset|length|style|BOLD|1439158|def+mygen():
++++'''+Infinite+generator+'''
++++while+True:
++++++++yield+'xxx'++#+Just+to+include+a+non-match+in+the+generator
++++++++yield+'d'

print+'d'+in+(x+for+x+in+mygen())+++++#+True
print+any('d'+==+x+for+x+in+mygen())++#+True
#+print+'q'+in+(x+for+x+in+mygen())+++++#+Never+ends+if+uncommented
#+print+any('q'+==+x+for+x+in+mygen())++#+Never+ends+if+uncommented|1439159|我只是喜欢在中简单地使用，而不是同时使用==和any。|1439160|entityMap^0|0|0|4|3|G|1F|0|0|0|6|C|F|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|T|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|U|8|@$I|V|J|W|K|L]|$I|X|J|Y|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$B|C]]|$1|O|3|P|5|F|7|10|8|@$I|11|J|12|K|L]|$I|13|J|14|K|L]]|9|@]|A|$]]|$1|Q|3|-4|5|F|7|15|8|@]|9|@]|A|$]]]|R|$]]

<pre><code>&gt;&gt;&gt; my_list =[ ['a', 'b'], ['a', 'c'], ['b', 'd'] ]
&gt;&gt;&gt; 'd' in (x[1] for x in my_list)
True
</code></pre>

Editing to add:

Both David's answer using any and mine using in will end when they find a match since we're using generator expressions. Here is a test using an infinite generator to show that:

<pre><code>def mygen():
 ''' Infinite generator '''
 while True:
 yield 'xxx' # Just to include a non-match in the generator
 yield 'd'

print 'd' in (x for x in mygen()) # True
print any('d' == x for x in mygen()) # True
# print 'q' in (x for x in mygen()) # Never ends if uncommented
# print any('q' == x for x in mygen()) # Never ends if uncommented
</code></pre>

I just like simply using in instead of both == and any.

blocks|key|137405|text|下面是Pythonic式的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|137406|data+=+[['a','b'],+['a','c'],+['b','d']]
search+=+'c'
any(e[1]+==+search+for+e+in+data)|code-block|syntax|javascript|137407|或者..。我不会说这是“一种真正的Pythonic方式”，因为在某种程度上，什么是Pythonic，什么不是，或者哪种方法比另一种方法更Pythonic，会变得有点主观。但是使用any()肯定比在例如RichieHindle's+answer中的for循环更典型的Python风格，|offset|length|style|CODE|137408|当然，在any的实现中有一个隐藏的循环，尽管一旦找到匹配，它就会中断循环。|137409|137410|因为我很无聊，所以我做了一个计时脚本来比较不同建议的性能，根据需要修改其中的一些建议，以使API相同。现在，我们应该记住，最快并不总是最好的，而且快速绝对不是Pythonic式的东西。话虽如此，结果是...真奇怪。显然，for循环的速度非常快，这不是我所期望的，所以我对它们持保留态度，并不理解它们为什么会这样。|137411|无论如何，当我使用问题中定义的三个子列表，每个子列表包含两个元素时，从最快到最慢，我得到了以下结果：|137412|137413|RichieHindle's+answer与代码循环，以0.22μs|ordered-list-item|137414|Terence+Honles'+first+suggestion计时，它在0.36μs|137415|Pierre-Luc+Bedard's+answer+(last+code+block)，、0.43μs|137416|Essentially时创建一个列表，在0.48μs|137417|Coady's+answer使用operator.itemgetter()时，在Markus's+answer和来自the+original+question的for循环之间，在0.53+for的|137418|时，足够接近到Alex+Martelli's+answer与ifilter()和<μ>c29之间的关系，在0.67s时(Alex的大约是0.5微秒，在jojo's+answer、faster)|137419|Another、Brandon+E+Taylor's+(和我的一样)和使用any()的Terence+Honles'+second+suggestion之间的关系足够紧密，所有这些都是在0.81-0.82s|137420|和0.95μs|137421|上使用嵌套列表理解的|137422|和user27221's+answer|unordered-list-item|137423|137424|显然，实际的计时在其他任何人的硬件上都没有意义，但它们之间的差异应该可以让我们对不同方法的接近程度有所了解。|137425|当我使用一个较长的列表时，情况会发生一些变化。我从问题中的列表开始，有三个子列表，并附加了另外197个子列表，总共有200个子列表，每个子列表的长度为2。使用这个较长的列表，结果如下：|137426|137427|RichieHindle's+answer，与使用较短的list|137428|Coady's+answer相同的0.22Code，同样是在0.53μs|137429|Terence+Honles'+first+suggestion，它创建了一个列表，在0.36Code+s+Alex+Martelli's+answer和ifilter()和Anon's+answer之间的另一个虚拟关系，在0.67Code|137430|再次在我的答案，Brandon+E+Taylor's相同的方法和使用<μ>D60的<μ>C59之间建立了足够紧密的关系，所有这些都出现在0.81-0.82μs+<代码>H261<代码>G262|137431|137432|这些是在列表扩展时保持其原始计时的那些。其余的，不是，是|137433|在1.24μs|137434|Terence+Honles'+first+suggestion，|137435|+for循环从the+original+question创建一个列表，在7.49μs|137436|Pierre-Luc+Bedard's+answer+(last+code+block)，，8.12μs|137437|Markus's+answer，，10.27μs|137438|jojo's+answer，，19.87+|137439|，最后user27221's+answer使用嵌套列表理解，在60.59μs|137440|137441|137442|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/1156114/56541|1|2|https://stackoverflow.com/a/1158136/56541|3|https://stackoverflow.com/a/18412156/56541|4|https://stackoverflow.com/a/1157153/56541|5|https://stackoverflow.com/a/1156582/56541|6|https://stackoverflow.com/q/1156087/56541|7|https://stackoverflow.com/a/1156628/56541|8|https://stackoverflow.com/a/13588121/56541|9|https://stackoverflow.com/a/1156145/56541|10|11|https://stackoverflow.com/a/30449870/56541|12|13|14|15|16|https://stackoverflow.com/a/1156128/56541|17|18|19|20|21|22|23^0|0|0|2H|5|3F|3|2S|L|0|0|4|3|0|0|32|3|0|0|0|0|L|1|0|0|W|2|0|0|18|3|0|0|G|L|28|3|2M|3|0|E|4|14|F|5|1M|L|6|0|U|9|7|M|7|23|D|8|0|11|5|8|I|9|17|X|A|0|0|0|1|I|B|0|0|0|0|0|0|L|C|0|0|E|D|0|25|9|0|W|E|1I|M|F|2F|D|G|0|8|I|H|0|0|0|0|0|W|I|0|1|3|7|L|J|0|0|18|K|0|0|F|L|0|0|D|M|0|3|I|N|0|0|0^^$0|@$1|2|3|4|5|6|7|3I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|3J|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|3K|8|@$I|3L|J|3M|K|L]|$I|3N|J|3O|K|L]]|9|@$I|3P|J|3Q|1|3R]]|A|$]]|$1|M|3|N|5|6|7|3S|8|@$I|3T|J|3U|K|L]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|3V|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|3W|8|@$I|3X|J|3Y|K|L]]|9|@]|A|$]]|$1|R|3|S|5|6|7|3Z|8|@]|9|@]|A|$]]|$1|T|3|-4|5|6|7|40|8|@]|9|@]|A|$]]|$1|U|3|V|5|W|7|41|8|@]|9|@$I|42|J|43|1|44]]|A|$]]|$1|X|3|Y|5|W|7|45|8|@]|9|@$I|46|J|47|1|48]]|A|$]]|$1|Z|3|10|5|W|7|49|8|@]|9|@$I|4A|J|4B|1|4C]]|A|$]]|$1|11|3|12|5|W|7|4D|8|@]|9|@]|A|$]]|$1|13|3|14|5|W|7|4E|8|@$I|4F|J|4G|K|L]|$I|4H|J|4I|K|L]|$I|4J|J|4K|K|L]]|9|@$I|4L|J|4M|1|4N]|$I|4O|J|4P|1|4Q]|$I|4R|J|4S|1|4T]]|A|$]]|$1|15|3|16|5|W|7|4U|8|@$I|4V|J|4W|K|L]]|9|@$I|4X|J|4Y|1|4Z]|$I|50|J|51|1|52]]|A|$]]|$1|17|3|18|5|W|7|53|8|@$I|54|J|55|K|L]]|9|@$I|56|J|57|1|58]|$I|59|J|5A|1|5B]]|A|$]]|$1|19|3|1A|5|W|7|5C|8|@]|9|@]|A|$]]|$1|1B|3|1C|5|6|7|5D|8|@]|9|@]|A|$]]|$1|1D|3|1E|5|1F|7|5E|8|@]|9|@$I|5F|J|5G|1|5H]]|A|$]]|$1|1G|3|-4|5|6|7|5I|8|@]|9|@]|A|$]]|$1|1H|3|1I|5|6|7|5J|8|@]|9|@]|A|$]]|$1|1J|3|1K|5|6|7|5K|8|@]|9|@]|A|$]]|$1|1L|3|-4|5|6|7|5L|8|@]|9|@]|A|$]]|$1|1M|3|1N|5|W|7|5M|8|@]|9|@$I|5N|J|5O|1|5P]]|A|$]]|$1|1O|3|1P|5|W|7|5Q|8|@]|9|@$I|5R|J|5S|1|5T]]|A|$]]|$1|1Q|3|1R|5|W|7|5U|8|@$I|5V|J|5W|K|L]]|9|@$I|5X|J|5Y|1|5Z]|$I|60|J|61|1|62]|$I|63|J|64|1|65]]|A|$]]|$1|1S|3|1T|5|W|7|66|8|@]|9|@$I|67|J|68|1|69]]|A|$]]|$1|1U|3|-4|5|6|7|6A|8|@]|9|@]|A|$]]|$1|1V|3|1W|5|6|7|6B|8|@]|9|@]|A|$]]|$1|1X|3|1Y|5|6|7|6C|8|@]|9|@]|A|$]]|$1|1Z|3|20|5|1F|7|6D|8|@]|9|@$I|6E|J|6F|1|6G]]|A|$]]|$1|21|3|22|5|W|7|6H|8|@$I|6I|J|6J|K|L]]|9|@$I|6K|J|6L|1|6M]]|A|$]]|$1|23|3|24|5|W|7|6N|8|@]|9|@$I|6O|J|6P|1|6Q]]|A|$]]|$1|25|3|26|5|W|7|6R|8|@]|9|@$I|6S|J|6T|1|6U]]|A|$]]|$1|27|3|28|5|W|7|6V|8|@]|9|@$I|6W|J|6X|1|6Y]]|A|$]]|$1|29|3|2A|5|W|7|6Z|8|@]|9|@$I|70|J|71|1|72]]|A|$]]|$1|2B|3|-4|5|6|7|73|8|@]|9|@]|A|$]]|$1|2C|3|-4|5|6|7|74|8|@]|9|@]|A|$]]|$1|2D|3|-4|5|6|7|75|8|@]|9|@]|A|$]]]|2E|$2F|$5|2G|2H|2I|A|$2J|2K]]|2L|$5|2G|2H|2I|A|$2J|2K]]|2M|$5|2G|2H|2I|A|$2J|2N]]|2O|$5|2G|2H|2I|A|$2J|2P]]|2Q|$5|2G|2H|2I|A|$2J|2R]]|2S|$5|2G|2H|2I|A|$2J|2T]]|2U|$5|2G|2H|2I|A|$2J|2V]]|2W|$5|2G|2H|2I|A|$2J|2X]]|2Y|$5|2G|2H|2I|A|$2J|2Z]]|30|$5|2G|2H|2I|A|$2J|31]]|32|$5|2G|2H|2I|A|$2J|2N]]|33|$5|2G|2H|2I|A|$2J|34]]|35|$5|2G|2H|2I|A|$2J|2K]]|36|$5|2G|2H|2I|A|$2J|2R]]|37|$5|2G|2H|2I|A|$2J|2N]]|38|$5|2G|2H|2I|A|$2J|2X]]|39|$5|2G|2H|2I|A|$2J|3A]]|3B|$5|2G|2H|2I|A|$2J|31]]|3C|$5|2G|2H|2I|A|$2J|2N]]|3D|$5|2G|2H|2I|A|$2J|2V]]|3E|$5|2G|2H|2I|A|$2J|2P]]|3F|$5|2G|2H|2I|A|$2J|2T]]|3G|$5|2G|2H|2I|A|$2J|2Z]]|3H|$5|2G|2H|2I|A|$2J|34]]]]

Here's the Pythonic way to do it:

<pre><code>data = [['a','b'], ['a','c'], ['b','d']]
search = 'c'
any(e[1] == search for e in data)
</code></pre>

Or... well, I'm not going to claim this is the "one true Pythonic way" to do it because at some point it becomes a little subjective what is Pythonic and what isn't, or which method is more Pythonic than another. But using <code>any()</code> is definitely more typical Python style than a <code>for</code> loop as in e.g. <a href="https://stackoverflow.com/a/1156114/56541">RichieHindle's answer</a>, 

Of course there is a hidden loop in the implementation of <code>any</code>, although it breaks out of the loop as soon as it finds a match.

<hr>

Since I was bored I made a timing script to compare performance of the different suggestions, modifying some of them as necessary to make the API the same. Now, we should bear in mind that fastest is not always best, and being fast is definitely not the same thing as being Pythonic. That being said, the results are... strange. Apparently <code>for</code> loops are very fast, which is not what I expected, so I'd take these with a grain of salt without understanding why they've come out the way they do.

Anyway, when I used the list defined in the question with three sublists of two elements each, from fastest to slowest I get these results:

<ol>
<li><a href="https://stackoverflow.com/a/1156114/56541">RichieHindle's answer</a> with the <code>for</code> loop, clocking in at 0.22 μs</li>
<li><a href="https://stackoverflow.com/a/1158136/56541">Terence Honles' first suggestion</a> which creates a list, at 0.36 μs</li>
<li><a href="https://stackoverflow.com/a/18412156/56541">Pierre-Luc Bedard's answer (last code block)</a>, at 0.43 μs</li>
<li>Essentially tied between <a href="https://stackoverflow.com/a/1156582/56541">Markus's answer</a> and the <code>for</code> loop from <a href="https://stackoverflow.com/q/1156087/56541">the original question</a>, at 0.48 μs</li>
<li><a href="https://stackoverflow.com/a/1157153/56541">Coady's answer</a> using <code>operator.itemgetter()</code>, at 0.53 μs</li>
<li>Close enough to count as a tie between <a href="https://stackoverflow.com/a/1156628/56541">Alex Martelli's answer</a> with <code>ifilter()</code> and <a href="https://stackoverflow.com/a/1156128/56541">Anon's answer</a>, at 0.67 μs (Alex's is consistently about half a microsecond faster)</li>
<li>Another close-enough tie between <a href="https://stackoverflow.com/a/13588121/56541">jojo's answer</a>, mine, <a href="https://stackoverflow.com/a/1156145/56541">Brandon E Taylor's</a> (which is identical to mine), and <a href="https://stackoverflow.com/a/1158136/56541">Terence Honles' second suggestion</a> using <code>any()</code>, all coming in at 0.81-0.82 μs</li>
<li>And then <a href="https://stackoverflow.com/a/30449870/56541">user27221's answer</a> using nested list comprehensions, at 0.95 μs</li>
</ol>

Obviously the actual timings are not meaningful on anyone else's hardware, but the differences between them should give some idea of how close the different methods are.

When I use a longer list, things change a bit. I started with the list in the question, with three sublists, and appended another 197 sublists, for a total of 200 sublists each of length two. Using this longer list, here are the results:

<ol>
<li><a href="https://stackoverflow.com/a/1156114/56541">RichieHindle's answer</a>, at the same 0.22 μs as with the shorter list</li>
<li><a href="https://stackoverflow.com/a/1157153/56541">Coady's answer</a> using <code>operator.itemgetter()</code>, again at 0.53 μs</li>
<li><a href="https://stackoverflow.com/a/1158136/56541">Terence Honles' first suggestion</a> which creates a list, at 0.36 μs</li>
<li>Another virtual tie between <a href="https://stackoverflow.com/a/1156628/56541">Alex Martelli's answer</a> with <code>ifilter()</code> and <a href="https://stackoverflow.com/a/1156128/56541">Anon's answer</a>, at 0.67 μs</li>
<li>Again a close-enough tie between my answer, <a href="https://stackoverflow.com/a/1156145/56541">Brandon E Taylor's</a> identical method, and <a href="https://stackoverflow.com/a/1158136/56541">Terence Honles' second suggestion</a> using <code>any()</code>, all coming in at 0.81-0.82 μs</li>
</ol>

Those are the ones that keep their original timing when the list is extended. The rest, which don't, are

<ol start="6">
<li>The <code>for</code> loop from <a href="https://stackoverflow.com/q/1156087/56541">the original question</a>, at 1.24 μs</li>
<li><a href="https://stackoverflow.com/a/1158136/56541">Terence Honles' first suggestion</a> which creates a list, at 7.49 μs</li>
<li><a href="https://stackoverflow.com/a/18412156/56541">Pierre-Luc Bedard's answer (last code block)</a>, at 8.12 μs</li>
<li><a href="https://stackoverflow.com/a/1156582/56541">Markus's answer</a>, at 10.27 μs</li>
<li><a href="https://stackoverflow.com/a/13588121/56541">jojo's answer</a>, at 19.87 μs</li>
<li>And finally <a href="https://stackoverflow.com/a/30449870/56541">user27221's answer</a> using nested list comprehensions, at 60.59 μs</li>
</ol>

blocks|key|1148931|text|>>>+the_list+=[+['a','b'],+['a','c'],+['b''d']+]
>>>+any('c'+==+x[1]+for+x+in+the_list)
True|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1148932|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

blocks|key|1437167|text|>>>+the_list+=[+['a','b'],+['a','c'],+['b','d']+]
>>>+"b"+in+zip(*the_list)[1]
True|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1437168|zip()采用一组列表并按索引将元素分组在一起，有效地转置了列表矩阵。星号接受the_list的内容并将其作为参数发送给zip，因此您实际上是在分别传递这三个列表，这正是zip想要的。剩下的工作就是检查"b"+(或其他什么)是否在由您感兴趣的索引的元素组成的列表中。|unstyled|offset|length|style|CODE|1437169|entityMap^0|0|0|5|13|8|1O|3|2D|3|2T|3|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@$G|O|H|P|I|J]|$G|Q|H|R|I|J]|$G|S|H|T|I|J]|$G|U|H|V|I|J]|$G|W|H|X|I|J]]|9|@]|A|$]]|$1|K|3|-4|5|F|7|Y|8|@]|9|@]|A|$]]]|L|$]]

<pre><code>&gt;&gt;&gt; the_list =[ ['a','b'], ['a','c'], ['b','d'] ]
&gt;&gt;&gt; "b" in zip(*the_list)[1]
True
</code></pre>

<code>zip()</code> takes a bunch of lists and groups elements together by index, effectively transposing the list-of-lists matrix. The asterisk takes the contents of <code>the_list</code> and sends it to <code>zip</code> as arguments, so you're effectively passing the three lists separately, which is what <code>zip</code> wants. All that remains is to check if <code>"b"</code> (or whatever) is in the list made up of elements with the index you're interested in.

blocks|key|4365724|text|Markus有一种方法可以避免使用单词for+--这是另一种方法，对于长the_list应该会有更好的性能...：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4365725|import+itertools
found+=+any(itertools.ifilter(lambda+x:x[1]=='b',+the_list)|code-block|syntax|javascript|4365726|entityMap^0|J|3|10|8|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

Markus has one way to avoid using the word <code>for</code> -- here's another, which should have much better performance for long <code>the_list</code>s...:

<pre><code>import itertools
found = any(itertools.ifilter(lambda x:x[1]=='b', the_list)
</code></pre>

blocks|key|1439248|text|使用gen+exp没有错，但如果目标是内联循环...|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1439249|>>>+import+itertools,+operator
>>>+'b'+in+itertools.imap(operator.itemgetter(1),+the_list)
True|code-block|syntax|javascript|1439250|也应该是最快的。|1439251|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|$]]

Nothing wrong with using a gen exp, but if the goal is to inline the loop...

<pre><code>&gt;&gt;&gt; import itertools, operator
&gt;&gt;&gt; 'b' in itertools.imap(operator.itemgetter(1), the_list)
True
</code></pre>

Should be the fastest as well.

blocks|key|1149076|text|上面这些看起来都不错。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1149077|但是你想保留结果吗？|1149078|如果是的话..。|1149079|您可以使用以下内容|1149080|result+=+[element+for+element+in+data+if+element[1]+==+search]|code-block|syntax|javascript|1149081|然后一个简单的|1149082|len(result)|1149083|让你知道是否找到了任何东西(现在你可以对结果做一些事情了)|1149084|当然，不处理长度小于1的元素(除非你知道它们总是大于1，否则你应该检查它，在这种情况下，你应该使用吗？)(元组是不可变的)|offset|length|style|BOLD|1149085|如果你知道所有的项目都有一个固定的长度，你也可以这样做：|1149086|any(second+==+search+for+_,+second+in+data)|1149087|或者对于len(数据)+==+4：|1149088|any(second+==+search+for+_,+second,+_,+_+in+data)|1149089|...and，我推荐使用|1149090|for+element+in+data:
+++...|1149091|而不是|1149092|for+i+in+range(len(data)):
+++...|1149093|(对于将来的使用，除非您想要保存或使用'i'，并且您知道'0‘不是必需的，否则仅当您从非零值开始时才需要使用完整语法)|1149094|entityMap^0|0|0|0|0|0|0|0|0|1D|C|0|0|S|0|0|0|H|0|0|0|C|0|0|0|3|0|0|0|1N|0^^$0|@$1|2|3|4|5|6|7|1I|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1J|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1K|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|1L|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|1M|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|1N|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|1O|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|1P|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1Q|8|@$U|1R|V|1S|W|X]]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1T|8|@$U|1U|V|1V|W|X]]|9|@]|A|$]]|$1|10|3|11|5|J|7|1W|8|@]|9|@]|A|$K|L]]|$1|12|3|13|5|6|7|1X|8|@$U|1Y|V|1Z|W|X]]|9|@]|A|$]]|$1|14|3|15|5|J|7|20|8|@]|9|@]|A|$K|L]]|$1|16|3|17|5|6|7|21|8|@$U|22|V|23|W|X]]|9|@]|A|$]]|$1|18|3|19|5|J|7|24|8|@]|9|@]|A|$K|L]]|$1|1A|3|1B|5|6|7|25|8|@$U|26|V|27|W|X]]|9|@]|A|$]]|$1|1C|3|1D|5|J|7|28|8|@]|9|@]|A|$K|L]]|$1|1E|3|1F|5|6|7|29|8|@$U|2A|V|2B|W|X]]|9|@]|A|$]]|$1|1G|3|-4|5|6|7|2C|8|@]|9|@]|A|$]]]|1H|$]]

the above all look good

but do you want to keep the result?

if so...

you can use the following

<pre><code>result = [element for element in data if element[1] == search]
</code></pre>

then a simple

<pre><code>len(result)
</code></pre>

lets you know if anything was found (and now you can do stuff with the results)

of course this does not handle elements which are length less than one
(which you should be checking unless you know they always are greater than
length 1, and in that case should you be using a tuple? (tuples are immutable))

if you know all items are a set length you can also do:

<pre><code>any(second == search for _, second in data)
</code></pre>

or for len(data[0]) == 4:

<pre><code>any(second == search for _, second, _, _ in data)
</code></pre>

...and I would recommend using

<pre><code>for element in data:
 ...
</code></pre>

instead of

<pre><code>for i in range(len(data)):
 ...
</code></pre>

(for future uses, unless you want to save or use 'i', and just so you know
the '0' is not required, you only need use the full syntax if you are starting
at a non zero value)

blocks|key|4365813|text|下面是什么：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4365814|list+=[+['a','b'],+['a','c'],+['b','d']+]
search+=+'b'

filter(lambda+x:x[1]==search,list)|code-block|syntax|javascript|4365815|这将返回列表列表中的每个列表，第二个元素等于search。|4365816|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|$]]

What about:

<pre><code>list =[ ['a','b'], ['a','c'], ['b','d'] ]
search = 'b'

filter(lambda x:x[1]==search,list)
</code></pre>

This will return each list in the list of lists with the second element being equal to search.

blocks|key|136661|text|下面给出了一种简单的方法，可以准确地找到该项目在列表中的位置。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|136662|for+i+in+range+(0,len(a)):
sublist=a[i]
for+i+in+range(0,len(sublist)):
++++if+search==sublist[i]:
++++++++print+"found+in+sublist+"%2B+"a"%2Bstr(i)|code-block|syntax|javascript|136663|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|$]]

Given below is a simple way to find exactly where in the list the item is.

<pre><code>for i in range (0,len(a)):
sublist=a[i]
for i in range(0,len(sublist)):
 if search==sublist[i]:
 print "found in sublist "+ "a"+str(i)
</code></pre>

blocks|key|1149159|text|K老帖子，但没有人使用列表表达式来回答:P|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1149160|list+=[+['a','b'],+['a','c'],+['b','d']+]
Search+=+'c'

#+return+if+it+find+in+either+item+0+or+item+1
print+[x+for+x,y+in+list+if+x+==+Search+or+y+==+Search]

#+return+if+it+find+in+item+1
print+[x+for+x,y+in+list+if+y+==+Search]|code-block|syntax|javascript|1149161|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|$]]

k old post but no one use list expression to answer :P

<pre><code>list =[ ['a','b'], ['a','c'], ['b','d'] ]
Search = 'c'

# return if it find in either item 0 or item 1
print [x for x,y in list if x == Search or y == Search]

# return if it find in item 1
print [x for x,y in list if y == Search]
</code></pre>

blocks|key|137568|text|我认为使用嵌套列表理解是解决这个问题的最好方法，因为中间结果就是元素所在的位置。一种实现方式是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|137569|list+=[+['a','b'],+['a','c'],+['b','d']+]
search+=+'c'
any([+(list.index(x),x.index(y))+for+x+in+list+for+y+in+x+if+y+==+search+]+)|code-block|syntax|javascript|137570|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|$]]

I think using nested list comprehensions is the most elegant way to solve this, because the intermediate result is the position where the element is. An implementation would be:

<pre><code>list =[ ['a','b'], ['a','c'], ['b','d'] ]
search = 'c'
any([ (list.index(x),x.index(y)) for x in list for y in x if y == search ] )
</code></pre>

blocks|key|1149199|text|我一直在找字典，但是没有找到。基于这篇文章，我能够创建以下内容。谢谢，祝您愉快！！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1149200|def+deapFind(+theList,+key,+value+):
++++result+=+False
++++for+x+in+theList:
++++++++if(+value+==+x[key]+):
++++++++++++return+True
++++return+result

theList+=+[{+"n":+"aaa",+"d":+"bbb"+},+{+"n":+"ccc",+"d":+"ddd"+}]
print+'Result:+'+%2B+str+(deapFind(+theList,+'n',+'aaa'))|code-block|syntax|javascript|1149201|我使用==而不是in操作符，因为in对于部分匹配返回true。IOW:在n个键上搜索aa返回true。我不认为这是我们所希望的。|1149202|HTH|1149203|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|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I was searching for a deep find for dictionaries and didn't find one. Based on this article I was able to create the following. Thanks and Enjoy!!

<pre><code>def deapFind( theList, key, value ):
 result = False
 for x in theList:
 if( value == x[key] ):
 return True
 return result

theList = [{ "n": "aaa", "d": "bbb" }, { "n": "ccc", "d": "ddd" }]
print 'Result: ' + str (deapFind( theList, 'n', 'aaa'))
</code></pre>

I'm using == instead of the in operator since in returns true for partial matches. IOW: searching aa on the n key returns true. I don't think that would be desired.

HTH

I have a list of two-item lists and need to search for things in it.
If the list is:
<pre><code>list = [['a','b'], ['a','c'], ['b','d']]
</code></pre>
I can search for a pair easily by doing
<pre><code>['a','b'] in list
</code></pre>
Now, is there a way to see if I have a pair in which a string is present in just the second position? I can do this:
<pre><code>for i in range (0, len(list)):
 if list[i][1]==search:
 found=1
</code></pre>
But is there a (better) way without the <code>for</code> loop? I don't need to know <code>i</code> or keep the loop going after it's found.

Search in lists of lists by given index

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我有一个包含两个项目的列表，需要在其中搜索内容。如果列表是：list = [['a','b'], ['a','c'], ['b','d']]我可以通过执行以下操作轻松地搜索一对['a','b'] in list现在，有没有办法来看看我是否有一个字符串出现在第二个位置的对？我可以这样做：for i in range (0...

问按给定索引在列表列表中搜索
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问按给定索引在列表列表中搜索EN