Python is an extremely beginner-friendly programming language for various reasons, such as having a clean syntax and being readable. Nevertheless, even with its simplicity, new programmers regularly make common errors and thus suffer from bugs, inefficient code, and developing bad habits that become hard to break.
In this article, we will look at the most common mistakes that beginners make in Python and why they happen. Besides that, we will also provide practical examples to avoid making those mistakes.
1. Misinterpreting Mutable Default Arguments
One of the most difficult-to-spot mistakes in Python is having mutable objects (such as lists or dictionaries) as default values in function parameters.
def add_item(item, lst=[]):
lst.append(item)
return lst
print(add_item(1)) # [1]
print(add_item(2)) # [1, 2] ← Unexpected!
print(add_item(3)) # [1, 2, 3]What is the problem? Default parameters are only evaluated at the time the function is defined, thus the list object is the same for all calls to the function.
How to fix:
def add_item(item, lst=None):
if lst is None:
lst = []
lst.append(item)
return lst
print(add_item(1)) # [1]
print(add_item(2)) # [2]
print(add_item(3)) # [3]2. Using = Instead of == for Comparison
Inexperienced programmers often use the assignment operator (=) instead of the equality operator (==).
#Wrong if x = 5: # This raises a SyntaxError in an if statement print("x is 5") # Also wrong in conditions while x = 5: print(x)
Usually Python detects the error and throws a SyntaxError, but it is not always so easy to notice it, especially in long expressions.
How to fix:
if x == 5:
print("x is 5")3. Changing a List While Looping over It
Changing the number of a list during the loop will lead to an error.
numbers = [1, 2, 3, 4, 5]
for num in numbers:
if num % 2 == 0:
numbers.remove(num)
print(numbers) # [1, 3, 5] ← Missed 4! Index shifting causes issuesWhat happens: Removing an element causes the rest of the elements to be shifted, so the loop misses one element each time.
How to do it:
# Option 1: Loop through a copy
numbers = [1, 2, 3, 4, 5]
for num in numbers[:]:
if num % 2 == 0:
numbers.remove(num)
print(numbers) # [1, 3, 5]
# Option 2: List comprehension (preferred)
numbers = [1, 2, 3, 4, 5]
numbers = [num for num in numbers if num % 2 != 0]
print(numbers) # [1, 3, 5]4. Incorrect Use of global and nonlocal Keywords
Beginners usually get confused with variable scoping rules.
count = 0
def increment():
count += 1 # UnboundLocalError!
increment()Correct with global:
count = 0
def increment():
global count
count += 1
increment()
print(count) # 1When changing a variable declared in the outer function, use `nonlocal`:
def outer():
count = 0
def inner():
nonlocal count
count += 1
inner()
return count
print(outer()) # 15. Misconception about == and is
`==` is used to compare if values are the same, while `is` is used to check if two variables reference the very same object (location in memory).
python
a = [1, 2, 3]
b = [1, 2, 3]
print(a == b) # True (same values)
print(a is b) # False (different objects)
c = a
print(c is a) # True (same object)It can be challenging to grasp with integers and small strings (a bit stored in an optimization called interning):
x = 256
y = 256
print(x is y) # True (usually)
x = 257
y = 257
print(x is y) # False (usually) - implementation detail!Whenever you are comparing values, use `==`, and only if you really need to check identity should you use `is`.
6. Late Binding Closures in Loops
When you create several functions inside a loop, this is a classic mistake that can be made.
funcs = []
for i in range(3):
funcs.append(lambda: i)
print(funcs[0]()) # 2
print(funcs[1]()) # 2
print(funcs[2]()) # 2Reason: The variable `i` is resolved when the lambda is actually executed not when it is created. At that point, `i=2`.
Solution:
python
funcs = []
for i in range(3):
funcs.append(lambda x=i: x) # Default argument stores the current value
print(funcs[0]()) # 0
print(funcs[1]()) # 1
print(funcs[2]()) # 27. Improper Exception Handling
Ignoring exceptions and failing to log or handle them properly is bad programming practice.
try:
;result = 10 / 0
except:
pass # Silent failure – horrible for debugging!Better:
try:
result = 10 / 0
except ZeroDivisionError as e:
print(f"Cannot divide by zero: {e}")
result = NoneDo not use bare `except` unless you absolutely have to, and always favor specific exceptions.
8. Using from module import *
This brings all public names of the modules to the local namespace. It will cause confusion and make your work harder.
from math import *
from numpy import *
print(sin(pi)) # Which sin? Which pi?9. Incorrect String Concatenation in Loops
When you use `+` for string concatenation inside a loop, it results in O(n²) performance.
result = ""
for i in range(10000):
result += str(i) # Very slow for large nFix: Use `join()`.
parts = []
for i in range(10000):
parts.append(str(i))
result = "".join(parts) # Much faster
# Or list comprehension
result = "".join(str(i) for i in range(10000))10. Not Using Virtual Environments
Executing `pip install` globally might result in package version conflicts.
You should always set up a virtual environment:
python -m venv myenv
source myenv/bin/activate # On Windows: myenv\Scripts\activate
pip install requestsIn fact, utilities such as `poetry` or `pipenv` facilitate this even more.
Conclusion
Learning Python is really a great experience, but it will be very helpful if you know what common mistakes to avoid so that you won’t waste hours on debugging and you will be able to write clean and Pythonic code from your very first attempts. The main thing is to get the root of these errors, not just their ways of fixing. Regular training, reading instructions for errors accurately, using linters (flake8, pylint), and type checkers (mypy) are the things you should not be afraid of.
Avoiding such slips as a beginner will result in making your programming intuition stronger and thus you will be able to write a more reliable Python code. Happy coding!