Python Performance Optimization Tips

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

1. Use local variables

Prefer local variables over global ones: they are easier to maintain, improve performance, and save memory. Replacing module namespace variables with local ones (e.g., ls = os.linesep ) speeds up lookup and makes code more readable.

2. Reduce function call count

When checking an object's type, isinstance() is the most efficient, followed by identity comparison with id() , and finally comparing type() . Example:

<code># 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)   # calls function once</code>

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

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

Import specific objects directly (e.g., from X import Y ) instead of importing the whole module and accessing X.Y , reducing one lookup.

3. Use mappings instead of conditional searches

Dictionary lookups are much faster than chained if / elif statements. Example:

<code># dict lookup, better performance
d = {1:10, 2:20, ...}
b = d[a]</code>

4. Iterate sequence elements directly

Iterating over the elements of a sequence (list, tuple, string, etc.) is faster than iterating over indices.

<code>a = [1,2,3]
for item in a:
    print(item)
# vs
for i in range(len(a)):
    print(a[i])</code>

5. Prefer generator expressions over list comprehensions

List comprehensions create the entire list in memory, which can be costly for large data. Generator expressions produce items lazily, saving memory.

<code># 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())</code>

6. Compile before executing

When using eval() or exec() , compile the code string with compile() first to avoid repeated compilation. The same applies to regular expressions: compile the pattern with re.compile() before matching.

7. Module programming habits

Place top‑level code inside functions and call them from a main() function. Use the if __name__ == '__main__' guard to run tests only when the module is executed directly.

For more resources, follow the public account and scan the QR code to receive free Python learning materials.