7 Proven Python Tricks to Boost Performance and Save Resources

Master some techniques to improve Python program performance and avoid unnecessary resource waste.

1. Use Local Variables

Prefer local variables over globals: easier maintenance, better performance, and memory savings.

Replace module namespace variables with locals, e.g., ls = os.linesep. Local variable lookup is faster and shorter identifiers improve readability.

2. Reduce Function Call Frequency

When checking object types, isinstance() is optimal, followed by identity comparison with id(), and finally type() comparison.

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

Avoid placing repeated operations in loop conditions; compute them once before the loop.

# Recalculate len(a) each iteration (inefficient)
while i < len(a):
    statement

# Compute length once (efficient)
m = len(a)
while i < m:
    statement

Import specific objects directly: from X import Y instead of import X; X.Y to save a lookup.

3. Use Mapping Instead of Conditional Chains

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

# if-elif chain (slow)
if a == 1:
    b = 10
elif a == 2:
    b = 20
# ...

# dict lookup (fast)
d = {1: 10, 2: 20, ...}
b = d[a]

4. Iterate Directly Over Sequence Elements

Iterating over items is faster than iterating over indices.

a = [1, 2, 3]
# iterate items
for item in a:
    print(item)

# iterate indices (slower)
for i in range(len(a)):
    print(a[i])

5. Prefer Generator Expressions Over List Comprehensions

List comprehensions build the whole list in memory, while generator expressions produce items lazily, reducing memory usage.

# generator expression
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 Execution

When using eval() or exec(), compile the code string first with compile() to avoid repeated compilation.

Similarly, compile regular expression patterns with re.compile() before matching.

7. Module Programming Practices

Place executable code inside functions; only top‑level statements run on import. Wrap script logic in a main() function and call it under if __name__ == '__main__': to keep imports lightweight and enable testing.