Python Search Algorithm Example (Linear Search)

Linear search is one of the simplest ways to find a value in Python.

It works by checking items one by one from left to right until it finds a match. This makes it a great beginner example because it uses basic ideas like loops, comparisons, and return values.

Quick example #

def linear_search(items, target):
    for index, value in enumerate(items):
        if value == target:
            return index
    return -1

numbers = [4, 7, 1, 9, 3]
result = linear_search(numbers, 9)
print(result)

Output:

3

This function returns the index of the target if found. It returns -1 if the target is not in the list.

What this example teaches #

• Linear search checks each item from left to right
• It stops when it finds a match
• It works well for small lists or simple beginner programs
• It does not require the list to be sorted

How linear search works step by step #

• Start at the first item in the list
• Compare the current item to the target value
• If they match, return the position
• If they do not match, move to the next item
• If the loop ends, the target was not found

This pattern is a good way to practice Python for loops and Python if statements.

Example: find a number in a list #

A simple way to write linear search is to put it in a function. That lets you reuse the same logic with different lists and target values.

def linear_search(items, target):
    for index, value in enumerate(items):
        if value == target:
            return index
    return -1

numbers = [4, 7, 1, 9, 3]

print(linear_search(numbers, 9))
print(linear_search(numbers, 3))
print(linear_search(numbers, 8))

Output:

3
4
-1

How this code works #

• enumerate(items) gives both the index and the value
• if value == target: checks whether the current item matches
• return index stops the function as soon as the target is found
• return -1 runs only if the loop finishes without finding a match

If enumerate() is new to you, see Python enumerate() explained.

Example: find text in a list of strings #

Linear search works with strings too.

def linear_search(items, target):
    for index, value in enumerate(items):
        if value == target:
            return index
    return -1

words = ["apple", "banana", "grape", "orange"]

print(linear_search(words, "grape"))
print(linear_search(words, "pear"))

Output:

2
-1

The comparison still uses ==.

Be careful with uppercase and lowercase letters. For example, "Apple" and "apple" are not equal.

words = ["Apple", "Banana", "Grape"]

print(linear_search(words, "apple"))

Output:

-1

If you want case-insensitive matching, you can convert both values to lowercase first:

def linear_search_case_insensitive(items, target):
    target = target.lower()

    for index, value in enumerate(items):
        if value.lower() == target:
            return index
    return -1

words = ["Apple", "Banana", "Grape"]
print(linear_search_case_insensitive(words, "apple"))

Output:

0

How to understand the result #

The function in this example returns an index.

• A returned index means the item was found
• -1 is a common “not found” value in simple examples
• Some programs may return None instead

For example:

numbers = [10, 20, 30]

print(linear_search(numbers, 20))
print(linear_search(numbers, 99))

Output:

1
-1

Here:

• 1 means 20 is at index 1
• -1 means 99 was not found

If you want more practice finding values in lists, see how to find an item in a list in Python.

When to use linear search #

Linear search is useful when:

• You have a small list
• You are learning loops and conditionals
• Your data is not sorted
• You want a simple, easy-to-read solution

It is usually not the best choice for very large lists because it may need to check every item.

For beginners, though, it is a very helpful example because it shows how programs examine data step by step.

Common beginner mistakes #

Here are some common problems when writing linear search.

Returning -1 too early #

This is a very common bug:

def linear_search(items, target):
    for index, value in enumerate(items):
        if value == target:
            return index
        return -1

This returns -1 after checking only the first item.

The fix is to put return -1 after the loop:

def linear_search(items, target):
    for index, value in enumerate(items):
        if value == target:
            return index
    return -1

Confusing the index with the value #

This function returns the position, not the item itself.

In this list:

numbers = [4, 7, 1, 9, 3]

If you search for 9, the function returns 3 because 9 is at index 3.

Using = instead of == #

This is wrong:

if value = target:

Use == for comparison:

if value == target:

Forgetting the “not found” case #

If the target is not in the list, the function still needs to return something.

That is why this line matters:

return -1

Searching for the wrong data type #

These are not the same:

• "5" → a string
• 5 → an integer

Example:

numbers = [1, 2, 3, 4, 5]

print(linear_search(numbers, "5"))
print(linear_search(numbers, 5))

Output:

-1
4

FAQ #

What does linear search return in Python? #

In this example, it returns the index of the matching item. If the item is not found, it returns -1.

Does linear search require a sorted list? #

No. It checks items one by one, so the list does not need to be sorted.

Why use enumerate() in linear search? #

enumerate() gives both the index and the value, which makes the loop easier to read.

Can linear search be used with strings? #

Yes. You can search through a list of strings the same way you search through numbers.

Is linear search fast? #

It is simple but not very fast for large lists because it may need to check every item.

See also #

• Python for loops explained
• Python if statements explained
• Python enumerate() explained
• How to find an item in a list in Python
• Python list processing example