Python if word in array

We are given a String and our task is to test if the string contains elements from the list.

Example:

Input:    String: Geeks for Geeks is one of the best company.
        List: ['Geeks', 'for']

Output:    Does string contain any list element : True

Naive Approach checking each word in the string

Here we are splitting the string into list of words and then matching each word of this list with the already present list of words we want to check.

Output:

The original string : There are 2 apples for 4 persons
The original list : ['apples', 'oranges']
String contains the list element

Using list comprehension to check if string contains element from list

This problem can be solved using the list comprehension, in this, we check for the list and also with string elements if we can find a match, and return true, if we find one and false is not using the conditional statements.
 

Output:

The original string : There are 2 apples for 4 persons
The original list : ['apples', 'oranges']
Does string contain any list element : True

Using any() to check if string contains element from list

Using any function is the most classical way in which you can perform this task and also efficiently. This function checks for match in string with match of each element of list.
 

Output:

The original string : There are 2 apples for 4 persons
The original list : ['apples', 'oranges']
Does string contain any list element : True

Using find() method to check if string contains element from list

Here we are using the find() method to check the occurrence of the word and it returns -1 if the word does not exist in the list.

Output:

The original string : There are 2 apples for 4 persons
The original list : ['apples', 'oranges']
Does string contain any list element : True

Using Counter() function

The original string : There are 2 apples for 4 persons
The original list : ['apples', 'oranges']
Does string contain any list element : True

Time Complexity: O(N)

Auxiliary Space: O(N)

Using Set Intersection to Check if String Contains Element from List

One approach to check if a string contains an element from a list is to convert the string and the list into sets and then check for the intersection between the sets. If the intersection is not an empty set, it means that the string contains an element from the list.

The original string: There are 2 apples for 4 persons
The original list: ['apples', 'oranges']
String contains an element from the list

This approach has a time complexity of O(n) and an auxiliary space of O(n).

Using operator.countOf() method.

The original string : There are 2 apples for 4 persons
The original list : ['apples', 'oranges']
Does string contain any list element : True

Time Complexity: O(n)

Auxiliary Space: O(1)

Using operator.contains() method

Approach

1. Initiate a for loop to traverse list of strings and set res to False
2. Check whether each string of list is present in given string
3. If yes set res to True and break out of for loop
4. Display res

The original string : There are 2 apples for 4 persons
The original list : ['apples', 'oranges']
Does string contain any list element : True

Time Complexity : O(M*N) M-length of test_list N-length of test_string

Auxiliary Space : O(1)

Introduction

In this tutorial, we’ll take a look at how to check if a list contains an element or value in Python. We’ll use a list of strings, containing a few animals:

animals = ['Dog', 'Cat', 'Bird', 'Fish']

Check if List Contains Element With for Loop

A simple and rudimentary method to check if a list contains an element is looping through it, and checking if the item we’re on matches the one we’re looking for. Let’s use a for loop for this:

for animal in animals:
    if animal == 'Bird':
        print('Chirp!')

This code will result in:

Chirp!

Check if List Contains Element With in Operator

Now, a more succinct approach would be to use the built-in in operator, but with the if statement instead of the for statement. When paired with if, it returns True if an element exists in a sequence or not. The syntax of the in operator looks like this:

element in list

Making use of this operator, we can shorten our previous code into a single statement:

if 'Bird' in animals: print('Chirp')

This code fragment will output the following:

Chirp

This approach has the same efficiency as the for loop, since the in operator, used like this, calls the list.__contains__ function, which inherently loops through the list — though, it’s much more readable.

Check if List Contains Element With not in Operator

By contrast, we can use the not in operator, which is the logical opposite of the in operator. It returns True if the element is not present in a sequence.

Let’s rewrite the previous code example to utilize the not in operator:

if 'Bird' not in animals: print('Chirp')

Running this code won’t produce anything, since the Bird is present in our list.

But if we try it out with a Wolf:

if 'Wolf' not in animals: print('Howl')

This code results in:

Howl

Check if List Contains Element With Lambda

Another way you can check if an element is present is to filter out everything other than that element, just like sifting through sand and checking if there are any shells left in the end. The built-in filter() method accepts a lambda function and a list as its arguments. We can use a lambda function here to check for our 'Bird' string in the animals list.

Then, we wrap the results in a list() since the filter() method returns a filter object, not the results. If we pack the filter object in a list, it’ll contain the elements left after filtering:

retrieved_elements = list(filter(lambda x: 'Bird' in x, animals))
print(retrieved_elements)

This code results in:

['Bird']

Now, this approach isn’t the most efficient. It’s fairly slower than the previous three approaches we’ve used. The filter() method itself is equivalent to the generator function:

(item for item in iterable if function(item))

The slowed down performance of this code, amongst other things, comes from the fact that we’re converting the results into a list in the end, as well as executing a function on the item on each iteration.

Check if List Contains Element Using any()

Another great built-in approach is to use the any() function, which is just a helper function that checks if there are any (at least 1) instances of an element in a list. It returns True or False based on the presence or lack thereof of an element:

if any(element in 'Bird' for element in animals):
    print('Chirp')

Since this results in True, our print() statement is called:

Chirp

This approach is also an efficient way to check for the presence of an element. It’s as efficient as the first three.

Check if List Contains Element Using count()

Finally, we can use the count() function to check if an element is present or not:

list.count(element)

This function returns the occurrence of the given element in a sequence. If it’s greater than 0, we can be assured a given item is in the list.

Let’s check the results of the count() function:

if animals.count('Bird') > 0:
    print("Chirp")

The count() function inherently loops the list to check for the number of occurrences, and this code results in:

Chirp

Conclusion

In this tutorial, we’ve gone over several ways to check if an element is present in a list or not. We’ve used the for loop, in and not in operators, as well as the filter(), any() and count() methods.

In this tutorial, you’ll learn how to use Python to check if a list contains an item. Put differently, you’ll learn if an item exists in a Python list. Being able to determine if a Python list contains a particular item is an important skill when you’re putting together conditional expressions. For example, if you’re developing a web application, you may want to see if a user has already selected a number of values. Otherwise, if you’re developing a game, you may want to see if a user has different items in their inventory.

By the end of having read this tutorial, you’ll have learned how to check for membership in a list. You’ll learn how to do this using the in keyword, as well as checking if an item doesn’t exist in a Python list using the not in keywords. You’ll also learned how to check if a list contain an item using the Python any() function, as well as the count() function. Finally, you’ll learn some naive implementations of checking membership in a list, such as for-loops and list comprehensions.

The Quick Answer: Use in To Check if a Python List Contains an Item

One of the easiest and most Pythonic ways to check for membership in a Python list is to use the in key. Technically, the in keyword serves two purposes:

1. To check for membership in a list, and
2. To loop over a items in a for loop

In this case, we’ll use the in keyword to check if an item exists in a list. This provides a readable and almost plain-English way to check for membership. Let’s see what this looks like:

# Check if a Python List Contains an Item
items = ['datagy', 'apples', 'bananas']

if 'datagy' in items:
    print('Item exists!')

# Returns: Item exists

We can that by writing if 'item' in items, we’re able to evaluate if something exists in our list. This is a really intuitive way to check if items exist or not.

In the next section, you’ll learn how to use Python to check if an item doesn’t exist.

Need to replace an item in a list? Check out my tutorial on this topic here: Python: Replace Item in List (6 Different Ways)

Check if a Python List Doesn’t Contain an Item Using not in

In this section, you’ll learn to check if a list doesn’t contain an item. We can do this by negating the in keyword, using the not keyword. Similar to the example above, this reads like relatively plain English. Let’s see how we can use the not in keyword to see if an item isn’t a list:

# Check if a Python List Doesn't Contain an Item
items = ['datagy', 'apples', 'bananas']

if 'oranges' not in items:
    print("Item doesn't exists!")

# Returns: Item doesn't exist!

We can see that the not in keyword allows us to determine if an item doesn’t exist. It returns the opposite truthiness of the in keyword. Because of this, it allows us to write cleaner code.

In the next section, you’ll learn to check for membership in a Python list using the .count() method.

Need to remove an item for a list? Check out my tutorial to learn how to here: Remove an Item from a Python List (pop, remove, del, clear)

Check if a Python List Contains an Item Using count

Python lists come with a number of different helpful methods. One of these methods is the .count() method, which counts the number of times an item appears in a list. Because of this, we can see if an item exists in a list if the count of that item is anything greater than 0. If the count is 0, then the item doesn’t exist in our list.

Let’s see what this looks like:

# Check if a Python List Contains an Item using .count()
items = ['datagy', 'apples', 'bananas']

if items.count('datagy') > 0:
    print('Item exists!')

# Returns: Item exists!

If any item exists, the count will always be greater than 0. If it doesn’t, the count will always be 0.

We can combine this if statement into a single line as well. Let’s see what this looks like:

# Check if a Python List Contains an Item using .count()
items = ['datagy', 'apples', 'bananas']

print('Exists') if items.count('datagy') else print("Doesn't exist")

# Returns: Exists

The expression here works like the Python ternary operator. If you want to learn more about how the Python ternary operator works, check out my in-depth guide on the ternary operator here.

In the next section, you’ll learn how to use the any() function to check for membership in a Python list.

Want to learn how to shuffle a list? Check out my tutorial here: Python: Shuffle a List (Randomize Python List Elements)

Check if a Python List Contains an Item Using any

The Python any function scans an iterable and returns True if any of the items in the iterable are True. So, how can we use the any function to check for membership in a Python list? We can place a comprehension inside the any function to check for membership. If any item is returned, the any function will return True.

Let’s see what this looks like and then dive into how this works:

# Check if a Python List Contains an Item using any()
items = ['datagy', 'apples', 'bananas']

print(any(item=='datagy' for item in items))

# Returns: True

The way that this works is that the comprehension will loop over each item in the list and check if the item is equal to the one we want to check for. If it is, the comprehension returns True for that item. Otherwise, it’ll return False. Because of this, if a True value exists, the any function will return True.

In the next section, you’ll learn how to use a for loop to check if an item exists in a list.

Want to learn how to check the length of a Python list? Learn all you need to know with this tutorial that covers five different ways to check the length: Python List Length or Size: 5 Ways to Get Length of List

Check if a Python List Contains an Item Using a For Loop

In this final section, you’ll learn how to use a for loop to check for membership in a list. We can loop over each item in our list and see if the item matches we want to check. Once the item is found, the for loop sets a value to True and the for loop breaks.

Let’s see what this looks like in Python:

# Check if a Python List Contains an Item using a for loop
items = ['datagy', 'apples', 'bananas']
exists = False
for item in items:
    if item == 'datagy':
        exists = True
        break

print(exists)

# Returns: True

Let’s break down what we did here:

1. We created our list and a variable, exists, which is set to False by default
2. We loop over every item in the list and see if it equal to the value we want to check membership for
3. If the item is equal to the one we want to check for, then we set exists to True and break the for loop

Need to remove duplicate items from a Python list? This tutorial will teach you seven different ways to do this: Python: Remove Duplicates From a List (7 Ways)

Conclusion

In this tutorial, you learned how to check for membership in a Python list, meaning checking whether an item exists. You learned how to do this using the in keyword. You then learned how to check whether an item doesn’t exist, using the not in keyword. You then learned other methods to check for membership, using the any function, the .count method, and a Python for loop.

To learn more about the Python in keyword, check out the official documentation here. The official documentation for the any function can be found here and for the .count method, it can be found here.