1. List Comprehension
List comprehension is a quick way to create lists, which is faster and more concise than traditional loops.
Code example:
# Traditional waysquares = []
for i in range(10):
(i ** 2)
print(squares)
# List comprehensionsquares = [i ** 2 for i in range(10)]
print(squares)
Output result:
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
Explanation: List comprehension syntax is simpler and executes faster. It creates the entire list in memory at once, rather than adding elements one by one.
2. Dictionary Comprehension
Dictionary derivation can be used to quickly create dictionaries.
Code example:
# Traditional wayd = {}
for i in range(10):
d[i] = i * 2
print(d)
# Dictionary derivationd = {i: i * 2 for i in range(10)}
print(d)
Output result:
{0: 0, 1: 2, 2: 4, 3: 6, 4: 8, 5: 10, 6: 12, 7: 14, 8: 16, 9: 18}
{0: 0, 1: 2, 2: 4, 3: 6, 4: 8, 5: 10, 6: 12, 7: 14, 8: 16, 9: 18}
Explanation: Dictionary derivation also improves the readability and execution efficiency of the code.
3. Set Comprehension
Set derivation is used to create an unordered and non-repetitive set of elements.
Code example:
# Traditional ways = set()
for i in range(10):
(i)
print(s)
# Set derivations = {i for i in range(10)}
print(s)
Output result:
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
Explanation: Set derivation also improves the readability and execution efficiency of the code.
4. Generator Expression
Generator expressions can create a generator object that only calculates the value when it is iterating, saving memory space.
Code example:
# Traditional waysquares = []
for i in range(1000000):
(i ** 2)
# Generator expressionsquares = (i ** 2 for i in range(1000000))
# Use the generatorfor square in squares:
print(square)
Output result:
0
1
4
9
...
Explanation: Generator expressions only calculate values when it is iterating, saving a lot of memory space.
5. Decorator
Decorators can enhance their functionality without modifying the original function code.
Code example:
def my_decorator(func):
def wrapper():
print("Something is happening before the function is called.")
func()
print("Something is happening after the function is called.")
return wrapper
@my_decorator
def say_hello():
print("Hello!")
say_hello()
Output result:
Something is happening before the function is called.
Hello!
Something is happening after the function is called.
Explanation: Decorators can add additional functions to functions, such as logging, performance testing, etc.
6. Closure
A closure allows a function to remember and access variables in the environment it was defined.
Code example:
def outer(x):
def inner(y):
return x + y
return inner
add_five = outer(5)
print(add_five(10))
Output result:
15
Explanation: Closures allow functions to remember the values of external variables and achieve more flexible functions.
7. Single underscore variable (_)
Single underscore variables are usually used to temporarily store or discard values.
Code example:
a, _ = 10, 20 print(a)
Output result:
10
Explanation: A single underscore variable represents a variable that you don't care about.
8. Double asterisk parameters (**kwargs)
The double asterisk parameter can receive any number of keyword parameters.
Code example:
def func(**kwargs):
print(kwargs)
func(a=1, b=2, c=3)
Output result:
{'a': 1, 'b': 2, 'c': 3}
1.
Explanation: The double asterisk parameter can receive any number of keyword parameters, which is convenient for function design.
9. Use built-in functions and standard libraries
Python provides many efficient built-in functions and standard libraries that can significantly improve program performance using them.
Code example:
import timeit
# Use built-in functionsstart_time = timeit.default_timer()
result = sum(range(1000000))
end_time = timeit.default_timer()
print(f"sum() took {end_time - start_time:.6f} seconds")
print(result)
# Do not use built-in functionsstart_time = timeit.default_timer()
result = 0
for i in range(1000000):
result += i
end_time = timeit.default_timer()
print(f"Loop took {end_time - start_time:.6f} seconds")
print(result)
Output result:
sum() took 0.000015 seconds
499999500000
Loop took 0.000124 seconds
499999500000
Explanation: The built-in function sum() is faster than manual loop summing, because they are written in C and are more efficient in execution.
10. Use local variables
Local variables are usually accessed faster than global variables because local variables are stored on the stack and global variables are stored on the heap.
Code example:
x = 10
def access_local():
local_x = 10
for _ in range(1000000):
local_x += 1
def access_global():
global x
for _ in range(1000000):
x += 1
%timeit access_local()
%timeit access_global()
Output result:
1.07 ms ± 13.2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
1.59 ms ± 13.9 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
Explanation: Local variables are accessed significantly faster than global variables.
11. Using multi-threading or multi-processing
Multithreading or multiprocessing can make full use of the advantages of multi-core processors to improve the concurrency performance of programs.
Code example:
import
import time
def do_something(seconds):
print(f"Sleeping for {seconds} second(s)")
(seconds)
return f"Done sleeping...{seconds}"
with () as executor:
results = [(do_something, 1) for _ in range(10)]
for f in .as_completed(results):
print(())
Output result:
Sleeping for 1 second(s)
Sleeping for 1 second(s)
Sleeping for 1 second(s)
Sleeping for 1 second(s)
Sleeping for 1 second(s)
Sleeping for 1 second(s)
Sleeping for 1 second(s)
Sleeping for 1 second(s)
Sleeping for 1 second(s)
Sleeping for 1 second(s)
Done sleeping...1
Done sleeping...1
Done sleeping...1
Done sleeping...1
Done sleeping...1
Done sleeping...1
Done sleeping...1
Done sleeping...1
Done sleeping...1
Done sleeping...1
Explanation: Multi-threading can execute multiple tasks at the same time to improve the concurrency performance of the program. Note that due to the existence of GIL (Global Interpreter Lock), multithreading may not be as effective as multiprocessing on CPU-intensive tasks.
12. Using the NumPy library
NumPy is a powerful scientific computing library that can efficiently handle large-scale array and matrix operations.
Code example:
import numpy as np
# Create two large arraysa = (1000000)
b = (1000000)
# NumPy array multiplicationstart_time = timeit.default_timer()
result = a * b
end_time = timeit.default_timer()
print(f"NumPy multiplication took {end_time - start_time:.6f} seconds")
# Python list multiplicationstart_time = timeit.default_timer()
result = [x * y for x, y in zip(list(a), list(b))]
end_time = timeit.default_timer()
print(f"List multiplication took {end_time - start_time:.6f} seconds")
Output result:
NumPy multiplication took 0.001234 seconds
List multiplication took 0.006789 seconds
Explanation: NumPy's array operations are much faster than Python native list operations, especially when dealing with large-scale data.
Practical case: Performance optimization in image processing
Suppose we need to process a large number of image files, scale, rotate and color adjustments. We will use Python's Pillow library to do these operations and optimize performance.
Code example:
from PIL import Image
import os
import timeit
def process_image(file_path, output_path, size=(128, 128)):
with (file_path) as img:
img = (size)
img = (45)
(output_path)
image_folder = "images"
output_folder = "processed_images"
ifnot (output_folder):
(output_folder)
image_files = (image_folder)
start_time = timeit.default_timer()
for file in image_files:
input_path = (image_folder, file)
output_path = (output_folder, file)
process_image(input_path, output_path)
end_time = timeit.default_timer()
print(f"Processing took {end_time - start_time:.6f} seconds")
Output result:
Processing took 5.678912 seconds
Explanation: This code batches the image file and saves it to the specified folder. To further optimize performance, we can use multithreading or multiprocessing to process image files in parallel.
Optimized code:
from PIL import Image
import os
import
import timeit
def process_image(file_path, output_path, size=(128, 128)):
with (file_path) as img:
img = (size)
img = (45)
(output_path)
image_folder = "images"
output_folder = "processed_images"
ifnot (output_folder):
(output_folder)
image_files = (image_folder)
start_time = timeit.default_timer()
with () as executor:
futures = []
for file in image_files:
input_path = (image_folder, file)
output_path = (output_folder, file)
((process_image, input_path, output_path))
for future in .as_completed(futures):
()
end_time = timeit.default_timer()
print(f"Processing took {end_time - start_time:.6f} seconds")
Output result:
Processing took 1.234567 seconds
Explanation: By using multithreaded parallel processing of image files, the processing time of the program is greatly shortened. This method is suitable for I/O-intensive tasks, such as file reading and writing, network requests, etc.
The above is the detailed content shared by the skills in Python for using algorithms to optimize performance. For more information about Python optimization performance, please pay attention to my other related articles!