Boost Python Performance with 7 Proven Optimization Tricks

Master a set of practical techniques to improve Python program performance and avoid unnecessary resource waste.

1. Use Local Variables

Prefer local variables over globals to speed up lookups, reduce memory usage, and improve readability. For example, assign ls = os.linesep instead of repeatedly accessing os.linesep.

2. Reduce Function Call Overhead

When checking an object's type, isinstance() is the most efficient, followed by identity comparison with id(), while type() is the slowest.

# Determine if num is an integer
type(num) == type(0)          # three function calls
type(num) is type(0)          # identity comparison
isinstance(num, (int))        # single function call

Avoid placing expensive operations like len(a) directly in loop conditions; compute them once before the loop.

# Inefficient loop
while i < len(a):
    statement
# Efficient loop
m = len(a)
while i < m:
    statement

Import only the needed objects: use from X import Y instead of import X; X.Y to save a lookup.

3. Use Mapping Instead of Conditional Chains

Dictionary lookups are far faster than multiple if/elif statements.

# Conditional chain (slow)
if a == 1:
    b = 10
elif a == 2:
    b = 20
# Dictionary lookup (fast)
d = {1: 10, 2: 20, ...}
b = d[a]

4. Iterate Directly Over Sequence Elements

Iterating over items is quicker than iterating over indices.

a = [1, 2, 3]
# Direct iteration
for item in a:
    print(item)
# Index iteration (slower)
for i in range(len(a)):
    print(a[i])

5. Prefer Generator Expressions Over List Comprehensions

Generator expressions produce items on demand, reducing memory consumption for large datasets.

# Generator expression (memory‑friendly)
l = sum(len(word) for line in f for word in line.split())
# List comprehension (creates full list)
l = sum(len(word) for line in f for word in line.split())

6. Compile Before Executing

When using eval() or exec(), compile the code string once with compile() and reuse the code object. The same applies to regular expressions: compile the pattern with re.compile() before matching.

7. Adopt Good Module Practices

Place executable code inside functions and guard test code with if __name__ == '__main__': to prevent unwanted execution on import.