Optimization Tips for Python Code

Optimization Tips for Python Code focuses on improving the performance of Python programs by refining common coding patterns. It covers strategies such as using built-in functions, minimizing redundant operations, Using local variables and choosing the right data structures to speed up execution and enhance efficiency.

Use builtin functions and libraries

This code compares the performance of two approaches for converting a string to uppercase: using a for loop and map(). It measures and compares the execution time of each method to highlight the efficiency of the built-in map() function

import time 

# Slower (Without map())
start = time.perf_counter()  
s = 'geeks'
U = [] 
for c in s: 
    U.append(c.upper()) 
print(U) 
elapsed = time.perf_counter() 
e1 = elapsed - start 
print("Time spent in function is: ", e1) 

# Faster (Uses builtin function map())
s = 'geeks'
start = time.perf_counter()  
U = map(str.upper, s)  
print(U) 
elapsed = time.perf_counter() 
e2 = elapsed - start 
print("Time spent in builtin function is: ", e2)

['G', 'E', 'E', 'K', 'S']
Time spent in function is:  1.3074000207780045e-05
<map object at 0x7f1a365a5ba0>
Time spent in builtin function is:  9.513000122751691e-06

Explanation:

• for loop explicitly iterates and appends, making it slower, while map() applies str.upper efficiently without manual iteration.
• map() returns an iterator, so its execution isn't timed properly. Using list(U) would ensure correct measurement.

Use keys for sorts

We should use the key argument to the built-in sort instead which is a faster way to sort.

a = [1, -3, 6, 11, 5]
a.sort()
print (a)

s = 'geeks'
# use sorted() if you don't want to sort in-place:
s = sorted(s)
print (s)

[-3, 1, 5, 6, 11]
['e', 'e', 'g', 'k', 's']

Explanation:

• a.sort() modifies the original list in-place, while sorted(s) returns a new list of sorted characters without changing the original string.
• List is sorted numerically whereas string is sorted lexicographically producing a list of characters in alphabetical order.

Optimizing loops

Optimizing loops involves minimizing redundant calculations, using built-in functions like map() and zip(), and leveraging list comprehensions for efficiency. Avoiding excessive memory operations and using generators can further enhance performance.

n = [1, 2, 3, 4, 5]
s = []
for num in n:
    s.append(num ** 2)  # Explicit looping and appending
print("Inefficient:", s)

# Optimized Approach
s = [num ** 2 for num in n]  # Faster and more concise
print("Optimized:", s)

Inefficient: [1, 4, 9, 16, 25]
Optimized: [1, 4, 9, 16, 25]

Explanation:

• First method uses explicit looping with append() while the second is more concise and efficient.
• List comprehension reduces overhead, making execution faster and code cleaner.

Use local variable if possible

Using local variables improves performance by reducing the overhead of global lookups. It also makes the code more readable and minimizes potential bugs from modifying global states.

# run faster
class Test:
    def func(self,x):
        print (x+x)

# Declaring variable that assigns class method object
Obj = Test()
mytest = Obj.func # Declaring local variable
n = 2
for i in range(n):
    mytest(i) # faster than Obj.func(i)

0
2

Explanation:

• Storing Obj.func in the mytest local variable avoids repeated attribute lookup, making method calls faster.
• Using the local variable mytest(i) instead of Obj.func(i) reduces the time spent searching for the method in the object, improving execution speed.