1. The Dreaded IndentationError

In Python, indentation isn’t just for show—it’s part of the syntax. Unlike other languages that use braces {} to define blocks of code, Python uses whitespace. This is one of the most common python syntax errors for newcomers.

The Mistake:
Mixing tabs and spaces, or having inconsistent indentation levels within the same code block.

# Bad Example: Inconsistent indentation
def greet(name):
    print("Hello,")
  print(name)  # This line has a different indentation level

# This will raise an IndentationError

The Fix:
Choose either tabs or spaces (PEP 8, the official style guide, recommends 4 spaces) and stick with them consistently. Configure your code editor to automatically insert spaces when you press the Tab key.

# Good Example: Consistent indentation (4 spaces)
def greet(name):
    print("Hello,")
    print(name)  # Indented correctly

greet("Alice")

2. Misunderstanding Mutable Default Arguments

This is a classic gotcha that confuses even intermediate Python developers. When you use a mutable object (like a list or dictionary) as a default argument in a function, it is created once when the function is defined, not each time the function is called.

The Mistake:
Expecting a new, empty list to be created for every function call.

# Bad Example: Using a mutable default argument
def add_item(item, my_list=[]):
    my_list.append(item)
    return my_list

print(add_item(1))  # Output: [1]
print(add_item(2))  # Output: [1, 2]  <-- Surprise! The list persists.
print(add_item(3))  # Output: [1, 2, 3]

The Fix:
Use None as the default value and create a new mutable object inside the function body.

# Good Example: Using None and creating a new list each time
def add_item(item, my_list=None):
    if my_list is None:
        my_list = []
    my_list.append(item)
    return my_list

print(add_item(1))  # Output: [1]
print(add_item(2))  # Output: [2]  <-- A fresh list is used.
print(add_item(3))  # Output: [3]

3. Modifying a List While Iterating Over It

This is a subtle but common python logical error. Trying to remove items from a list while looping through it can lead to unexpected behavior because the list’s indices shift.

The Mistake:
Attempting to filter a list in-place by removing elements during iteration.

# Bad Example: Removing elements while iterating
numbers = [1, 2, 3, 4, 5, 6]
for num in numbers:
    if num % 2 == 0:  # If number is even
        numbers.remove(num)

print(numbers)  # Output: [1, 3, 5, 6] ? The '6' remains because the loop skipped it.

The Fix:
Create a new list using a list comprehension or iterate over a copy of the original list.

# Good Example 1: Using a list comprehension (Pythonic way)
numbers = [1, 2, 3, 4, 5, 6]
numbers = [num for num in numbers if num % 2 != 0]
print(numbers)  # Output: [1, 3, 5]

# Good Example 2: Iterating over a copy
numbers = [1, 2, 3, 4, 5, 6]
for num in numbers[:]:  # The slice [:] creates a copy
    if num % 2 == 0:
        numbers.remove(num)
print(numbers)  # Output: [1, 3, 5]

For more on efficient data handling, our Complete Data Structures & Algorithms Series dives deep into lists and their operations.

4. NameError and Scope Confusion

Variables have scope—the part of a program where they are accessible. Trying to use a variable outside of its scope, or before it’s defined, results in a NameError.

The Mistake:
Assuming that variables created inside a function are accessible globally, or forgetting to declare a variable.

# Bad Example: Accessing a local variable globally
def my_func():
    local_var = "I'm inside the function"

my_func()
# print(local_var)  # This would raise a NameError

# Bad Example: Forgetting to define a variable
print(undefined_variable)  # NameError: name 'undefined_variable' is not defined

The Fix:
Understand the difference between local and global scope. If you need to modify a global variable from within a function, use the global keyword (though it’s often better to pass arguments and return values).

# Good Example: Returning a value from a function
def my_func():
    local_var = "I'm inside the function"
    return local_var

result = my_func()
print(result)  # Output: I'm inside the function

5. Incorrect Use of the = Operator vs. ==

This is a universal programming mistake. Using the assignment operator = when you mean the equality comparison operator == is a frequent source of bugs.

The Mistake:
Using = in an if statement.

# Bad Example: Assignment instead of comparison
x = 5
if x = 10:  # SyntaxError: invalid syntax. In some languages this is a logic error.
    print("This is not a comparison!")

The Fix:
Always use == for comparisons. To avoid accidentally typing = in a conditional, some developers write the constant on the left (if 10 == x:), though this is less common in Python.
 

# Good Example: Using the correct comparison operator
x = 5
if x == 10:
    print("x is ten")
else:
    print("x is not ten")

6. Forgetting to Call init as the Parent Constructor

In object-oriented programming, when you create a child class, you often need to initialize the parent class as well. Forgetting to do this can leave the parent class in an uninitialized state.

The Mistake:
Overriding the init method in a child class without calling the parent’s init.

# Bad Example: Not calling the parent constructor
class Vehicle:
    def __init__(self, brand):
        self.brand = brand

class Car(Vehicle):
    def __init__(self, brand, model):
        self.model = model  # Parent's __init__ is not called!

my_car = Car("Toyota", "Camry")
# print(my_car.brand)  # AttributeError: 'Car' object has no attribute 'brand'

The Fix:
Use super() to call the parent class’s init method.

# Good Example: Calling the parent constructor with super()
class Vehicle:
    def __init__(self, brand):
        self.brand = brand

class Car(Vehicle):
    def __init__(self, brand, model):
        super().__init__(brand)  # This calls Vehicle.__init__
        self.model = model

my_car = Car("Toyota", "Camry")
print(my_car.brand)  # Output: Toyota
print(my_car.model)  # Output: Camry

7. Misusing is for Value Comparison

The is operator in Python checks for identity, not equality. It checks if two variables point to the same object in memory. For comparing values, you should use ==.

The Mistake:
Using is to check if a number is equal to another number, or if a string is equal to another string.

# Bad Example: Using 'is' for value comparison
a = 1000
b = 1000
print(a is b)  # Output: False (usually). They are different objects in memory.
print(a == b)  # Output: True

# This can be especially confusing with small integers due to interning, but don't rely on it.
c = 5
d = 5
print(c is d)  # Output: True (due to small integer caching, but it's an implementation detail!)

The Fix:
Use == to compare values. Reserve is for comparing with None, True, or False, where identity is the correct check.

# Good Example: Using '==' for values and 'is' for singletons
a = 1000
b = 1000
if a == b:
    print("a and b have the same value.")

my_var = None
if my_var is None:  # This is the Pythonic way to check for None
    print("my_var is None")

8. Index Errors: Forgetting That Lists Start at 0

This is a rite of passage for all programmers. Trying to access an index that doesn’t exist in a sequence (like a list or string) will raise an IndexError.

The Mistake:
In a list of n items, trying to access the nth element with index n.

# Bad Example: Off-by-one error
my_list = [10, 20, 30, 40]
print(my_list[4])  # IndexError: list index out of range (only indices 0, 1, 2, 3 exist)

The Fix:
Remember that valid indices range from 0 to len(list) - 1. Use negative indices to access elements from the end (-1 for the last item).

# Good Example: Accessing indices correctly
my_list = [10, 20, 30, 40]
print(my_list[0])   # Output: 10 (first item)
print(my_list[3])   # Output: 40 (last item)
print(my_list[-1])  # Output: 40 (last item, Pythonic way)
print(my_list[-2])  # Output: 30

9. Exception Handling That’s Too Broad

Catching every exception with a bare except: clause can hide critical errors and make debugging a nightmare. It’s like putting a bandage on a leak without finding the source.

The Mistake:
Using a bare except that catches KeyboardInterrupt, SystemExit, and all other exceptions.

# Bad Example: Catching everything
try:
    user_input = input("Enter a number: ")
    number = int(user_input)
    result = 10 / number
except:  # Bare except - hides everything, even Ctrl+C
    print("Something went wrong.")  # Was it a ValueError? ZeroDivisionError? KeyboardInterrupt?

The Fix:
Catch specific exceptions. This allows you to handle expected errors gracefully while letting unexpected ones propagate for proper debugging.

# Good Example: Catching specific exceptions
try:
    user_input = input("Enter a number: ")
    number = int(user_input)
    result = 10 / number
except ValueError:
    print("That's not a valid number!")
except ZeroDivisionError:
    print("You can't divide by zero!")
except KeyboardInterrupt:
    print("\nProgram interrupted by user.")
    # Re-raise or handle as needed

For a deeper dive into handling errors, our Python Exception Hierarchy Explained is a must-read.

10. Forgetting to Close Files

When you open a file, the operating system allocates resources. If you forget to close the file, you can run into resource leaks, especially in long-running applications. This can lead to errors like “too many open files.”

The Mistake:
Opening a file with open() but never calling .close().

# Bad Example: Opening a file and not closing it
file = open("my_file.txt", "w")
file.write("Hello, World!")
# The file remains open, potentially causing a resource leak.

The Fix:
Use the with statement. This creates a context manager that automatically closes the file, even if an exception occurs. This is the Pythonic and recommended way.

# Good Example: Using the 'with' statement (context manager)
with open("my_file.txt", "w") as file:
    file.write("Hello, World!")
# The file is automatically closed when the 'with' block ends.

11. Confusing Mutable and Immutable Types

This is a core concept in Python. Some objects (like integers, strings, and tuples) are immutable—they cannot be changed after creation. Others (like lists, dictionaries, and sets) are mutable—they can be modified. Treating an immutable object as mutable can lead to subtle bugs or performance issues.

The Mistake:
Trying to change a string in place, or thinking a tuple can be modified.

// Add your python code here# Bad Example: Trying to modify a string (immutable)
my_string = "hello"
# my_string[0] = "H"  # TypeError: 'str' object does not support item assignment

# Bad Example: Modifying a variable in a function and expecting the original to change
def append_to_list(item, target=[]):
    target.append(item)
    return target

original_list = [1, 2, 3]
new_list = append_to_list(4, original_list)
print(original_list)  # Output: [1, 2, 3, 4] - The original list was mutated!

The Fix:
For strings, create a new string. For mutable objects, be aware that passing them to a function can modify the original. If you want to avoid this, pass a copy.

# Good Example: Working with immutables and mutables correctly
my_string = "hello"
my_string = "H" + my_string[1:]  # Create a new string
print(my_string)  # Output: Hello

# To avoid mutating the original, pass a copy
original_list = [1, 2, 3]
new_list = append_to_list(4, original_list[:])  # Using a slice to create a copy
print(original_list)  # Output: [1, 2, 3] - Original is unchanged.
print(new_list)       # Output: [1, 2, 3, 4]

Understanding these concepts is crucial for algorithmic efficiency, as discussed in our guide on Mastering Optimization Techniques for Algorithmic Problems.

12. Reinventing the Wheel (Not Using Built-in Functions)

Python comes with “batteries included”—a rich standard library with powerful, optimized functions for common tasks. Writing your own slower, buggier version from scratch is a common mistake.

The Mistake:
Manually writing loops to do things that built-in functions can do faster and more cleanly.

# Bad Example: Manually summing a list
numbers = [1, 2, 3, 4, 5]
total = 0
for num in numbers:
    total += num
print(total)

# Bad Example: Manually finding the maximum
max_num = numbers[0]
for num in numbers:
    if num > max_num:
        max_num = num
print(max_num)

The Fix:
Learn and use Python’s built-in functions.

# Good Example: Using built-in functions
numbers = [1, 2, 3, 4, 5]
total = sum(numbers)
max_num = max(numbers)
print(total)    # Output: 15
print(max_num)  # Output: 5

Other useful built-ins include min(), any(), all(), len(), and sorted(). Leveraging these not only reduces code but also improves performance, as many are implemented in C.

Frequently Asked Questions