Search in lists of lists by given index

Question

I have a list of two-item lists and need to search for things in it.

If the list is:

list = [['a','b'], ['a','c'], ['b','d']] 

I can search for a pair easily by doing

['a','b'] in list 

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:

for i in range (0, len(list)):     if list[i][1]==search:        found=1 

But is there a (better) way without the for loop? I don't need to know i or keep the loop going after it's found.

Answer 1

Here's the Pythonic way to do it:

data = [['a','b'], ['a','c'], ['b','d']] search = 'c' any(e[1] == search for e in data) 

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 any() is definitely more typical Python style than a for loop as in e.g. RichieHindle's answer,

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

---

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 for 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:

1. RichieHindle's answer with the for loop, clocking in at 0.22 μs
2. Terence Honles' first suggestion which creates a list, at 0.36 μs
3. Pierre-Luc Bedard's answer (last code block), at 0.43 μs
4. Essentially tied between Markus's answer and the for loop from the original question, at 0.48 μs
5. Coady's answer using operator.itemgetter(), at 0.53 μs
6. Close enough to count as a tie between Alex Martelli's answer with ifilter() and Anon's answer, at 0.67 μs (Alex's is consistently about half a microsecond faster)
7. Another close-enough tie between jojo's answer, mine, Brandon E Taylor's (which is identical to mine), and Terence Honles' second suggestion using any(), all coming in at 0.81-0.82 μs
8. And then user27221's answer using nested list comprehensions, at 0.95 μs

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:

1. RichieHindle's answer, at the same 0.22 μs as with the shorter list
2. Coady's answer using operator.itemgetter(), again at 0.53 μs
3. Terence Honles' first suggestion which creates a list, at 0.36 μs
4. Another virtual tie between Alex Martelli's answer with ifilter() and Anon's answer, at 0.67 μs
5. Again a close-enough tie between my answer, Brandon E Taylor's identical method, and Terence Honles' second suggestion using any(), all coming in at 0.81-0.82 μs

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

6. The for loop from the original question, at 1.24 μs
7. Terence Honles' first suggestion which creates a list, at 7.49 μs
8. Pierre-Luc Bedard's answer (last code block), at 8.12 μs
9. Markus's answer, at 10.27 μs
10. jojo's answer, at 19.87 μs
11. And finally user27221's answer using nested list comprehensions, at 60.59 μs