Python is often critiqued for being slow compared to languages like C++ or Rust. However, with some simple strategies, you can significantly boost your script's performance. Here are some hacks to make your Python scripts up to 3x faster or more:
1. Use Built-In Functions
Built-in functions in Python (e.g., sum, len, max) are implemented in C, making them much faster than custom loops.
Example:
# Instead of:
total = 0
for num in numbers:
total += num
# Use:
total = sum(numbers)
2. Replace Loops with List Comprehensions
List comprehensions are faster and more concise than standard for loops.
Example:
# Instead of:
squares = []
for num in range(10):
squares.append(num ** 2)
# Use:
squares = [num ** 2 for num in range(10)]
3. Use NumPy for Numerical Operations
NumPy is optimized for numerical computations and uses low-level C libraries under the hood.
Example:
import numpy as np
# Replace:
squares = [x ** 2 for x in range(10_000)]
# With:
array = np.arange(10_000)
squares = array ** 2
4. Profile and Optimize with cProfile
Use the cProfile module to find bottlenecks in your code and focus your optimizations where they matter most.
Example:
python -m cProfile your_script.py
5. Use Multiprocessing or Threading
For CPU-bound tasks, leverage the multiprocessing module to utilize multiple cores. For I/O-bound tasks, try concurrent.futures or asyncio.
Example:
from concurrent.futures import ThreadPoolExecutor
def task(n):
return n ** 2
with ThreadPoolExecutor() as executor:
results = executor.map(task, range(10))
6. Avoid Global Variables
Global variables slow down your code due to the way Python handles variable scope. Instead, pass variables as arguments to functions.
7. Compile with Cython or PyPy
Use Cython to convert Python code into C or try PyPy, a JIT-compiled alternative to CPython.
Example with Cython:
cythonize -i your_script.pyx
8. Use Generators for Large Data
Generators yield items lazily, saving memory and reducing computation time for large datasets.
Example:
# Instead of:
data = [x ** 2 for x in range(10_000)]
# Use:
data = (x ** 2 for x in range(10_000))
9. Avoid Unnecessary Object Creation
Reusing objects instead of creating new ones in loops can save time, especially for small, frequently instantiated objects.
10. Leverage Type Hinting and Static Analysis
Adding type hints and using tools like mypy or pydantic can help you write more optimized and cleaner code.
Example:
def add(a: int, b: int) -> int:
return a + b
Conclusion
By combining these hacks, you can squeeze maximum performance out of Python while still enjoying its simplicity and readability.