In Python, the operators in
and not in
test membership in lists, tuples, dictionaries, and so on.
This article describes the following contents.
- How to use the
in
operator- Basic usage
- With
if
statement in
for the dictionary (dict
)in
for the string (str
)
not in
(negation ofin
)in
for multiple elements- Use
and
,or
- Use sets
- Use
- Time complexity of
in
- Slow for the list:
O(n)
- Fast for the set:
O(1)
- For the dictionary
- Slow for the list:
in
infor
statements and list comprehensions
How to use the in operator in Python
Basic usage
x in y
returns True
if x
is included in y
, and False
if it is not.
1 2 3 4 5 6 7 | print(1 in [0, 1, 2]) # True print(100 in [0, 1, 2]) # False |
Not only list
, but also tuple
, set
, range
, and other iterable objects can be operated.
1 2 3 4 5 6 7 8 9 10 | print(1 in (0, 1, 2)) # True print(1 in {0, 1, 2}) # True print(1 in range(3)) # True |
The dictionary (dict
) and the string (str
) are described later.
With if statement
in
returns a bool value (True
, False
) and can be used directly in if
statement.
1 2 3 4 5 6 7 8 9 10 | l = [0, 1, 2] i = 0 if i in l: print('{} is a member of {}.'.format(i, l)) else: print('{} is not a member of {}.'.format(i, l)) # 0 is a member of [0, 1, 2]. |
1 2 3 4 5 6 7 8 9 10 | l = [0, 1, 2] i = 100 if i in l: print('{} is a member of {}.'.format(i, l)) else: print('{} is not a member of {}.'.format(i, l)) # 100 is not a member of [0, 1, 2]. |
Note that lists, tuples, strings, etc. are evaluated as False
if they are empty, and as True
if they are not. If you want to check whether an object is empty or not, you can use the object as it is.
1 2 3 4 5 6 7 8 9 | l = [0, 1, 2] if l: print('not empty') else: print('empty') # not empty |
1 2 3 4 5 6 7 8 9 | l = [] if l: print('not empty') else: print('empty') # empty |
“in” for the dictionary (dict)
The in
operation for the dictionary (dict
) tests on the key.
1 2 3 4 5 6 7 8 9 | d = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'} print('key1' in d) # True print('value1' in d) # False |
Use values()
, items()
if you want to test on values or key-value pairs.
1 2 3 4 5 6 7 8 9 10 | print('value1' in d.values()) # True print(('key1', 'value1') in d.items()) # True print(('key1', 'value2') in d.items()) # False |
“in” for the string (str)
The in
operation for the string (str
) tests the existence of a substring.
1 2 3 4 5 6 7 8 9 10 11 12 13 | print('a' in 'abc') # True print('x' in 'abc') # False print('ab' in 'abc') # True print('ac' in 'abc') # False |
not in (negation of “in”)
x not in y
returns the negation of x in y
1 2 3 4 5 6 7 | print(10 in [1, 2, 3]) # False print(10 not in [1, 2, 3]) # True |
The same result is returned by adding not
to the entire in
operation.
1 2 3 4 | print(not 10 in [1, 2, 3]) # True |
However, if you add not
to the entire in
operation, it will be interpreted in two ways, as shown below, so it is recommended to use the more explicit not in
.
1 2 3 4 5 6 7 | print(not (10 in [1, 2, 3])) # True print((not 10) in [1, 2, 3]) # False |
Since in
has a higher precedence than not
, it is treated as the former if there are no parentheses.
The latter case is recognized as follows.
1 2 3 4 5 6 7 | print(not 10) # False print(False in [1, 2, 3]) # False |
“in” for multiple elements
If you want to check if multiple elements are included, using a list of those elements as follows will not work. It will be tested whether the list itself is included or not.
1 2 3 4 5 6 7 | print([0, 1] in [0, 1, 2]) # False print([0, 1] in [[0, 1], [1, 0]]) # True |
Use and
, or
or sets.
Use and, or
Combine multiple in
operations using and
and or
. It will be tested whether both or either are included.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | l = [0, 1, 2] v1 = 0 v2 = 100 print(v1 in l and v2 in l) # False print(v1 in l or v2 in l) # True print((v1 in l) or (v2 in l)) # True |
Since in
and not in
have higher precedence than and
and or
, parentheses are not necessary. Of course, if it is difficult to read, you can enclose it in parentheses as in the last example.
Use sets
If you have a lot of elements you want to check, it is easier to use the set than and
, or
.
For example, whether list A
contains all the elements of list B
is equivalent to whether list B
is a subset of list A
.
1 2 3 4 5 6 7 8 9 10 11 12 | l1 = [0, 1, 2, 3, 4] l2 = [0, 1, 2] l3 = [0, 1, 5] l4 = [5, 6, 7] print(set(l2) <= set(l1)) # True print(set(l3) <= set(l1)) # False |
Whether list A
does not contain the elements of list B
is equivalent to whether list A
and list B
are relatively prime.
1 2 3 4 | print(set(l1).isdisjoint(set(l4))) # True |
If list A
and list B
are not relatively prime, it means that list A
contains at least one element of list B
.
1 2 3 4 | print(not set(l1).isdisjoint(set(l3))) # True |
Time complexity of “in”
The execution speed of the in
operator depends on the type of the target object.
The measurement results of the execution time of in
for lists, sets, and dictionaries are shown below.
Note that the code below uses the Jupyter Notebook magic command %%timeit
and does not work when run as a Python script.
Take a list of 10 elements and 10000 elements as an example.
1 2 3 4 5 6 7 | n_small = 10 n_large = 10000 l_small = list(range(n_small)) l_large = list(range(n_large)) |
The sample code below is executed in CPython 3.7.4, and of course, the results may vary depending on the environment.
Slow for the list: O(n)
The average time complexity of the in
operator for lists is O(n)
. It becomes slower when there are many elements.
1 2 3 4 5 6 7 8 9 | %%timeit -1 in l_small # 178 ns ± 4.78 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each) %%timeit -1 in l_large # 128 µs ± 11.5 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each) |
The execution time varies greatly depending on the position of the value to look for. It takes the longest time when its value is at the end or when it does not exist.
1 2 3 4 5 6 7 8 9 10 11 12 13 | %%timeit 0 in l_large # 33.4 ns ± 0.397 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each) %%timeit 5000 in l_large # 66.1 µs ± 4.38 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each) %%timeit 9999 in l_large # 127 µs ± 2.17 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each) |
Fast for the set: O(1)
The average time complexity of the in
operator for sets is O(1)
. It does not depend on the number of elements.
1 2 3 4 5 6 7 8 9 10 11 12 | s_small = set(l_small) s_large = set(l_large) %%timeit -1 in s_small # 40.4 ns ± 0.572 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each) %%timeit -1 in s_large # 39.4 ns ± 1.1 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each) |
The execution time does not change depending on the value to look for.
1 2 3 4 5 6 7 8 9 10 11 12 13 | %%timeit 0 in s_large # 39.7 ns ± 1.27 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each) %%timeit 5000 in s_large # 53.1 ns ± 0.974 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each) %%timeit 9999 in s_large # 52.4 ns ± 0.403 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each) |
If you want to repeat in
operation for a list with many elements, it is faster to convert it to a set in advance.
1 2 3 4 5 6 7 8 9 10 11 12 | %%timeit for i in range(n_large): i in l_large # 643 ms ± 29.8 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) %%timeit s_large_ = set(l_large) for i in range(n_large): i in s_large_ # 746 µs ± 6.7 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) |
Note that it takes time to convert a list to a set, so it may be faster to keep it as a list if the number of in
operations is small.
For the dictionary
Take the following dictionary as an example.
1 2 3 4 5 6 7 8 9 10 11 | d = dict(zip(l_large, l_large)) print(len(d)) # 10000 print(d[0]) # 0 print(d[9999]) # 9999 |
As mentioned above, the in
operation for the dictionary tests on keys.
The key of the dictionary is a unique value as well as the set, and the execution time is about the same as for sets.
1 2 3 4 5 6 | %%timeit for i in range(n_large): i in d # 756 µs ± 24.9 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) |
On the other hand, dictionary values are allowed to be duplicated like a list. The execution time of in
for values()
is about the same as for lists.
1 2 3 4 5 6 7 8 | dv = d.values() %%timeit for i in range(n_large): i in dv # 990 ms ± 28.8 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) |
Key-value pairs are unique. The execution time of in
for items()
is about set
+ α.
1 2 3 4 5 6 7 8 | di = d.items() %%timeit for i in range(n_large): (i, i) in di # 1.18 ms ± 26.2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) |
“in” in for statements and list comprehensions
The word in
is also used in for
statements and list comprehensions.
1 2 3 4 5 6 7 8 9 | l = [0, 1, 2] for i in l: print(i) # 0 # 1 # 2 |
1 2 3 4 | print([i * 10 for i in l]) # [0, 10, 20] |
Note that the in
operator may be used as a conditional expression in list comprehensions, which is confusing.
1 2 3 4 5 6 7 | l = ['oneXXXaaa', 'twoXXXbbb', 'three999aaa', '000111222'] l_in = [s for s in l if 'XXX' in s] print(l_in) # ['oneXXXaaa', 'twoXXXbbb'] |
The first in
is in
for the list comprehensions, and the second in
is the in
operator.
Source: