I’m trying to find a short way to see if any of the following items is in a list, but my first attempt does not work. Besides writing a function to accomplish this, is the any short way to check if one of multiple items is in a list.

```
>>> a = [2,3,4]
>>> print (1 or 2) in a
False
>>> print (2 or 1) in a
True
```

```
>>> L1 = [2,3,4]
>>> L2 = [1,2]
>>> [i for i in L1 if i in L2]
[2]
>>> S1 = set(L1)
>>> S2 = set(L2)
>>> S1.intersection(S2)
set([2])
```

Both empty lists and empty sets are False, so you can use the value directly as a truth value.

Ah, Tobias you beat me to it. I was thinking of this slight variation on your solution:

```
print any(x in a for x in b)
```

Think about what the code actually says!

```
>>> (1 or 2)
1
>>> (2 or 1)
2
```

That should probably explain it. 🙂 Python apparently implements “lazy or”, which should come as no surprise. It performs it something like this:

```
def or(x, y):
if x: return x
if y: return y
return False
```

In the first example, `x == 1`

and `y == 2`

. In the second example, it’s vice versa. That’s why it returns different values depending on the order of them.

Maybe a bit more lazy:

```
a = [1,2,3,4]
b = [2,7]
print any((True for x in a if x in b))
```

```
a = {2,3,4}
if {1,2} & a:
pass
```

Code golf version. Consider using a set if it makes sense to do so.

I find this more readable than a list comprehension.

1 line without list comprehensions.

```
>>> any(map(lambda each: each in [2,3,4], [1,2]))
True
>>> any(map(lambda each: each in [2,3,4], [1,5]))
False
>>> any(map(lambda each: each in [2,3,4], [2,4]))
True
```

Best I could come up with:

```
any([True for e in (1, 2) if e in a])
```

In some cases (e.g. unique list elements), set operations can be used.

```
>>> a=[2,3,4]
>>> set(a) - set([2,3]) != set(a)
True
>>>
```

Or, using set.isdisjoint(),

```
>>> not set(a).isdisjoint(set([2,3]))
True
>>> not set(a).isdisjoint(set([5,6]))
False
>>>
```

When you think “check to see if a in b”, think hashes (in this case, sets). The fastest way is to hash the list you want to check, and then check each item in there.

This is why Joe Koberg’s answer is fast: checking set intersection is very fast.

When you don’t have a lot of data though, making sets can be a waste of time. So, you can make a set of the list and just check each item:

```
tocheck = [1,2] # items to check
a = [2,3,4] # the list
a = set(a) # convert to set (O(len(a)))
print [i for i in tocheck if i in a] # check items (O(len(tocheck)))
```

When the number of items you want to check is small, the difference can be negligible. But check lots of numbers against a large list…

tests:

```
from timeit import timeit
methods = ['''tocheck = [1,2] # items to check
a = [2,3,4] # the list
a = set(a) # convert to set (O(n))
[i for i in tocheck if i in a] # check items (O(m))''',
'''L1 = [2,3,4]
L2 = [1,2]
[i for i in L1 if i in L2]''',
'''S1 = set([2,3,4])
S2 = set([1,2])
S1.intersection(S2)''',
'''a = [1,2]
b = [2,3,4]
any(x in a for x in b)''']
for method in methods:
print timeit(method, number=10000)
print
methods = ['''tocheck = range(200,300) # items to check
a = range(2, 10000) # the list
a = set(a) # convert to set (O(n))
[i for i in tocheck if i in a] # check items (O(m))''',
'''L1 = range(2, 10000)
L2 = range(200,300)
[i for i in L1 if i in L2]''',
'''S1 = set(range(2, 10000))
S2 = set(range(200,300))
S1.intersection(S2)''',
'''a = range(200,300)
b = range(2, 10000)
any(x in a for x in b)''']
for method in methods:
print timeit(method, number=1000)
```

speeds:

```
M1: 0.0170331001282 # make one set
M2: 0.0164539813995 # list comprehension
M3: 0.0286040306091 # set intersection
M4: 0.0305438041687 # any
M1: 0.49850320816 # make one set
M2: 25.2735087872 # list comprehension
M3: 0.466138124466 # set intersection
M4: 0.668627977371 # any
```

The method that is consistently fast is to make one set (of the list), but the intersection works on large data sets the best!

This will do it in one line.

```
>>> a=[2,3,4]
>>> b=[1,2]
>>> bool(sum(map(lambda x: x in b, a)))
True
```

```
print (1 in a) or (2 in a)
print (2 in a) or (5 in a)
```

This is a very old question, but I wasn’t happy with any of the answers, so I had to add this for posterity’s sake.

Simple.

```
_new_list = []
for item in a:
if item in b:
_new_list.append(item)
else:
pass
```

Tags: laravellist