Check if something is (not) in a list in Python

The bug is probably somewhere else in your code, because it should work fine:

>>> 3 not in [2, 3, 4]False>>> 3 not in [4, 5, 6]True

Or with tuples:

>>> (2, 3) not in [(2, 3), (5, 6), (9, 1)]False>>> (2, 3) not in [(2, 7), (7, 3), "hi"]True

How do I check if something is (not) in a list in Python?

The cheapest and most readable solution is using the in operator (or in your specific case, not in). As mentioned in the documentation,

The operators in and not in test for membership. x in s evaluates to True if x is a member of s, and False otherwise. x not in s returns the negation of x in s.

Additionally,

The operator not in is defined to have the inverse true value of in.

y not in x is logically the same as not y in x.

Here are a few examples:

'a' in [1, 2, 3]# False'c' in ['a', 'b', 'c']# True'a' not in [1, 2, 3]# True'c' not in ['a', 'b', 'c']# False

This also works with tuples, since tuples are hashable (as a consequence of the fact that they are also immutable):

(1, 2) in [(3, 4), (1, 2)]#  True

If the object on the RHS defines a __contains__() method, in will internally call it, as noted in the last paragraph of the Comparisons section of the docs.

... in and not in, are supported by types that are iterable or implement the __contains__() method. For example, you could (but shouldn't) do this:

[3, 2, 1].__contains__(1)# True

in short-circuits, so if your element is at the start of the list, in evaluates faster:

lst = list(range(10001))%timeit 1 in lst%timeit 10000 in lst  # Expected to take longer time.68.9 ns ± 0.613 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)178 µs ± 5.01 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

If you want to do more than just check whether an item is in a list, there are options:

• list.index can be used to retrieve the index of an item. If that element does not exist, a ValueError is raised.
• list.count can be used if you want to count the occurrences.

The XY Problem: Have you considered sets?

Ask yourself these questions:

• do you need to check whether an item is in a list more than once?
• Is this check done inside a loop, or a function called repeatedly?
• Are the items you're storing on your list hashable? IOW, can you call hash on them?

If you answered "yes" to these questions, you should be using a set instead. An in membership test on lists is O(n) time complexity. This means that python has to do a linear scan of your list, visiting each element and comparing it against the search item. If you're doing this repeatedly, or if the lists are large, this operation will incur an overhead.

set objects, on the other hand, hash their values for constant time membership check. The check is also done using in:

1 in {1, 2, 3} # True'a' not in {'a', 'b', 'c'}# False(1, 2) in {('a', 'c'), (1, 2)}# True

If you're unfortunate enough that the element you're searching/not searching for is at the end of your list, python will have scanned the list upto the end. This is evident from the timings below:

l = list(range(100001))s = set(l)%timeit 100000 in l%timeit 100000 in s2.58 ms ± 58.9 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)101 ns ± 9.53 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

As a reminder, this is a suitable option as long as the elements you're storing and looking up are hashable. IOW, they would either have to be immutable types, or objects that implement __hash__.