10 Logical Error Examples in Python

Logical Error Examples in Python are incorrect loop condition, Misplaced variable initialization, Misusing logical operators, Incorrect order of operations and many more that we will discuss below in detail.

Logical errors in Python are mistakes in the logic of your code. These errors do not stop your program from running, but they give wrong results.

Examples of Logical Error In Python

The following are common logical error examples in Python:

1. Incorrect Loop Condition

A loop condition decides how many times a loop runs. If the condition is wrong, the loop may run too many or too few times.

For example, if you want to print numbers from 1 to 5, you might write:

for i in range(6):  
    print(i)  

Here, the loop starts from 0 and ends at 5 because range(6) it includes 0 to 5. This is a logical error because the intention was to print numbers 1 to 5, not 0 to 5.

To fix this, you should use range(1, 6) instead. This way, the loop will start from 1 and end at 5, giving the correct output.

2. Misplaced Variable Initialization

A variable should be initialized (started) in the right place. If you initialize it inside a loop, it resets every time the loop runs.

For example, if you want to calculate the sum of numbers from 1 to 5, you might write:

total = 0  
for i in range(1, 6):  
    total = 0  # Logical error: Resets 'total' to 0 in each iteration  
    total += i  
print(total)  # Output: 5 (incorrect)  

Here, the variable total is set to 0 inside the loop. So, it resets every iteration, and the final result is incorrect.

To fix this, you should initialize total outside the loop. This way, the value of total will keep increasing with each iteration, giving the correct sum.

3. Incorrect Comparison Operator

In Python, = is used for assignment and == is used for comparison. Using the wrong operator can cause logical errors.

For example, if you want to check if a number is 10, you might write:

num = 5  
if num = 10:  # Logical error: Uses assignment instead of comparison  
    print("Number is 10")  

Here, the code uses = instead of ==. This will give a syntax error because = is used to assign a value, not to compare.

To fix this, you should use == for comparison. The correct code will be:

if num == 10:  
    print("Number is 10")  

4. Off-by-One Error

This error happens when a loop or index goes one step too far or not far enough. For example, if you want to print the first 3 elements of a list, you might write:

my_list = [10, 20, 30, 40]  
for i in range(4):  # Logical error: Prints 4 elements instead of 3  
    print(my_list[i])  

Here, the loop runs 4 times because range(4) includes 0 to 3. This means it prints all 4 elements of the list, which is not what you intended. To fix this, you should use range(3) to print only the first 3 elements.

5. Incorrect Order of Operations

Mathematical operations follow a specific order. If you write them incorrectly, the result will be wrong.

For example, if you want to calculate the average of 3 numbers, you might write:

a, b, c = 10, 20, 30  
average = a + b + c / 3  # Logical error: Division happens before addition  
print(average)  # Incorrect output: 40.0  

Here, division (/) happens before addition (+). So, the calculation is wrong. To fix this, you should use parentheses to ensure addition happens first:

average = (a + b + c) / 3  

This will give the correct average.

6. Misusing Logical Operators

Using and instead of or (or vice versa) changes the logic of your code. For example, if you want to check if a number is either 5 or 10, you might write:

num = 7  
if num == 5 and num == 10:  # Logical error: Uses 'and' instead of 'or'  
    print("Number is either 5 or 10")  

Here, the condition num == 5 and num == 10 is never true because a number cannot be both 5 and 10 at the same time. To fix this, you should use or:

if num == 5 or num == 10:  
    print("Number is either 5 or 10")  

This will correctly check if the number is either 5 or 10.

7. Incorrect String Comparison

Python is case-sensitive. Comparing strings without considering case can lead to errors. For example, if you want to check if the input is “yes”, you might write:

user_input = "Yes"  
if user_input == "yes":  # Logical error: Case-sensitive comparison  
    print("User said yes")  

Here, the code checks for "yes" but the input is "Yes". The comparison fails because of case sensitivity. To fix this, you should convert the input to lowercase before comparing:

if user_input.lower() == "yes":  
    print("User said yes")  

This will correctly handle different cases of input.

8. Misunderstanding List Indexing

List indexes start from 0. Using the wrong index can cause errors or wrong results. For example, if you want to access the last element of a list, you might write:

my_list = [10, 20, 30, 40]  
last_element = my_list[4]  # Logical error: Index 4 is out of range  
print(last_element)  

Here, the list has 4 elements, so the last index is 3, not 4. To fix this, you should use my_list[3] or my_list[-1] to access the last element.

9. Incorrect Use of Return Statements

A return statement stops the function. If you place it too early, the function may not work correctly.

For example, if you want to check if a number is even, you might write:

def is_even(num):  
    if num % 2 == 0:  
        return True  # Logical error: Returns too early, no handling for odd numbers  
    print("Number is odd")  # This line is never reached  

Here, the function returns True for even numbers but does nothing for odd numbers. To fix this, you should add an else statement or remove the return statement inside the if block.

10. Misusing Mutable Default Arguments

Using mutable objects (like lists) as default arguments in functions can cause unexpected behavior.

For example, if you want to append items to a list, you might write:

def add_item(item, my_list=[]):  # Logical error: Default list is mutable  
    my_list.append(item)  
    return my_list  
print(add_item(1))  # Output: [1]  
print(add_item(2))  # Output: [1, 2] (unexpected)  

Here, the default list my_list is shared across function calls. It keeps growing with each call. To fix this, you should use None as the default argument and initialize the list inside the function:

def add_item(item, my_list=None):  
    if my_list is None:  
        my_list = []  
    my_list.append(item)  
    return my_list  

This will ensure that a new list is created for each function call.