Python パフォーマンス最適化

CPU プロファイリング、メモリ最適化、実装のベストプラクティスを含む、Python コードのプロファイリング、分析、最適化をして パフォーマンスを向上させるための総合ガイド。

このスキルを使う場合

• Python アプリケーションのパフォーマンス ボトルネックの特定
• アプリケーションのレイテンシとレスポンス時間の削減
• CPU 集約的な操作の最適化
• メモリ消費とメモリリークの削減
• データベース クエリ パフォーマンスの向上
• I/O 操作の最適化
• データ処理パイプラインの高速化
• 高性能アルゴリズムの実装
• 本番環境アプリケーションのプロファイリング

コアコンセプト

1. プロファイリング の種類

• CPU プロファイリング: 時間がかかる関数を特定
• メモリ プロファイリング: メモリ割り当てとリークの追跡
• 行プロファイリング: 行単位の細かさでプロファイリング
• 呼び出しグラフ: 関数呼び出しの関係を可視化

2. パフォーマンス メトリクス

• 実行時間: 操作にかかる時間
• メモリ使用量: ピークおよび平均メモリ消費量
• CPU 使用率: プロセッサ使用パターン
• I/O 待機: I/O 操作に費やされた時間

3. 最適化戦略

• アルゴリズム的: より良いアルゴリズムとデータ構造
• 実装的: より効率的なコードパターン
• 並列化: マルチスレッド/マルチプロセッシング
• キャッシング: 冗長な計算の回避
• ネイティブ拡張: クリティカルパスに C/Rust を使用

クイックスタート

基本的なタイミング

import time

def measure_time():
    """Simple timing measurement."""
    start = time.time()

    # Your code here
    result = sum(range(1000000))

    elapsed = time.time() - start
    print(f"Execution time: {elapsed:.4f} seconds")
    return result

# Better: use timeit for accurate measurements
import timeit

execution_time = timeit.timeit(
    "sum(range(1000000))",
    number=100
)
print(f"Average time: {execution_time/100:.6f} seconds")

プロファイリング ツール

パターン 1: cProfile - CPU プロファイリング

import cProfile
import pstats
from pstats import SortKey

def slow_function():
    """Function to profile."""
    total = 0
    for i in range(1000000):
        total += i
    return total

def another_function():
    """Another function."""
    return [i**2 for i in range(100000)]

def main():
    """Main function to profile."""
    result1 = slow_function()
    result2 = another_function()
    return result1, result2

# Profile the code
if __name__ == "__main__":
    profiler = cProfile.Profile()
    profiler.enable()

    main()

    profiler.disable()

    # Print stats
    stats = pstats.Stats(profiler)
    stats.sort_stats(SortKey.CUMULATIVE)
    stats.print_stats(10)  # Top 10 functions

    # Save to file for later analysis
    stats.dump_stats("profile_output.prof")

コマンドライン プロファイリング:

# Profile a script
python -m cProfile -o output.prof script.py

# View results
python -m pstats output.prof
# In pstats:
# sort cumtime
# stats 10

パターン 2: line_profiler - 行単位プロファイリング

# Install: pip install line-profiler

# Add @profile decorator (line_profiler provides this)
@profile
def process_data(data):
    """Process data with line profiling."""
    result = []
    for item in data:
        processed = item * 2
        result.append(processed)
    return result

# Run with:
# kernprof -l -v script.py

手動行プロファイリング:

from line_profiler import LineProfiler

def process_data(data):
    """Function to profile."""
    result = []
    for item in data:
        processed = item * 2
        result.append(processed)
    return result

if __name__ == "__main__":
    lp = LineProfiler()
    lp.add_function(process_data)

    data = list(range(100000))

    lp_wrapper = lp(process_data)
    lp_wrapper(data)

    lp.print_stats()

パターン 3: memory_profiler - メモリ使用量

# Install: pip install memory-profiler

from memory_profiler import profile

@profile
def memory_intensive():
    """Function that uses lots of memory."""
    # Create large list
    big_list = [i for i in range(1000000)]

    # Create large dict
    big_dict = {i: i**2 for i in range(100000)}

    # Process data
    result = sum(big_list)

    return result

if __name__ == "__main__":
    memory_intensive()

# Run with:
# python -m memory_profiler script.py

パターン 4: py-spy - 本番環境プロファイリング

# Install: pip install py-spy

# Profile a running Python process
py-spy top --pid 12345

# Generate flamegraph
py-spy record -o profile.svg --pid 12345

# Profile a script
py-spy record -o profile.svg -- python script.py

# Dump current call stack
py-spy dump --pid 12345

最適化パターン

パターン 5: リスト内包表記 vs ループ

import timeit

# Slow: Traditional loop
def slow_squares(n):
    """Create list of squares using loop."""
    result = []
    for i in range(n):
        result.append(i**2)
    return result

# Fast: List comprehension
def fast_squares(n):
    """Create list of squares using comprehension."""
    return [i**2 for i in range(n)]

# Benchmark
n = 100000

slow_time = timeit.timeit(lambda: slow_squares(n), number=100)
fast_time = timeit.timeit(lambda: fast_squares(n), number=100)

print(f"Loop: {slow_time:.4f}s")
print(f"Comprehension: {fast_time:.4f}s")
print(f"Speedup: {slow_time/fast_time:.2f}x")

# Even faster for simple operations: map
def faster_squares(n):
    """Use map for even better performance."""
    return list(map(lambda x: x**2, range(n)))

パターン 6: メモリ効率化のためのジェネレータ式

import sys

def list_approach():
    """Memory-intensive list."""
    data = [i**2 for i in range(1000000)]
    return sum(data)

def generator_approach():
    """Memory-efficient generator."""
    data = (i**2 for i in range(1000000))
    return sum(data)

# Memory comparison
list_data = [i for i in range(1000000)]
gen_data = (i for i in range(1000000))

print(f"List size: {sys.getsizeof(list_data)} bytes")
print(f"Generator size: {sys.getsizeof(gen_data)} bytes")

# Generators use constant memory regardless of size

パターン 7: 文字列連結

import timeit

def slow_concat(items):
    """Slow string concatenation."""
    result = ""
    for item in items:
        result += str(item)
    return result

def fast_concat(items):
    """Fast string concatenation with join."""
    return "".join(str(item) for item in items)

def faster_concat(items):
    """Even faster with list."""
    parts = [str(item) for item in items]
    return "".join(parts)

items = list(range(10000))

# Benchmark
slow = timeit.timeit(lambda: slow_concat(items), number=100)
fast = timeit.timeit(lambda: fast_concat(items), number=100)
faster = timeit.timeit(lambda: faster_concat(items), number=100)

print(f"Concatenation (+): {slow:.4f}s")
print(f"Join (generator): {fast:.4f}s")
print(f"Join (list): {faster:.4f}s")

パターン 8: 辞書検索 vs リスト検索

import timeit

# Create test data
size = 10000
items = list(range(size))
lookup_dict = {i: i for i in range(size)}

def list_search(items, target):
    """O(n) search in list."""
    return target in items

def dict_search(lookup_dict, target):
    """O(1) search in dict."""
    return target in lookup_dict

target = size - 1  # Worst case for list

# Benchmark
list_time = timeit.timeit(
    lambda: list_search(items, target),
    number=1000
)
dict_time = timeit.timeit(
    lambda: dict_search(lookup_dict, target),
    number=1000
)

print(f"List search: {list_time:.6f}s")
print(f"Dict search: {dict_time:.6f}s")
print(f"Speedup: {list_time/dict_time:.0f}x")

パターン 9: ローカル変数へのアクセス

import timeit

# Global variable (slow)
GLOBAL_VALUE = 100

def use_global():
    """Access global variable."""
    total = 0
    for i in range(10000):
        total += GLOBAL_VALUE
    return total

def use_local():
    """Use local variable."""
    local_value = 100
    total = 0
    for i in range(10000):
        total += local_value
    return total

# Local is faster
global_time = timeit.timeit(use_global, number=1000)
local_time = timeit.timeit(use_local, number=1000)

print(f"Global access: {global_time:.4f}s")
print(f"Local access: {local_time:.4f}s")
print(f"Speedup: {global_time/local_time:.2f}x")

パターン 10: 関数呼び出しのオーバーヘッド

import timeit

def calculate_inline():
    """Inline calculation."""
    total = 0
    for i in range(10000):
        total += i * 2 + 1
    return total

def helper_function(x):
    """Helper function."""
    return x * 2 + 1

def calculate_with_function():
    """Calculation with function calls."""
    total = 0
    for i in range(10000):
        total += helper_function(i)
    return total

# Inline is faster due to no call overhead
inline_time = timeit.timeit(calculate_inline, number=1000)
function_time = timeit.timeit(calculate_with_function, number=1000)

print(f"Inline: {inline_time:.4f}s")
print(f"Function calls: {function_time:.4f}s")

NumPy ベクトル化、キャッシング、メモリ管理、並列化、非同期 I/O、データベース最適化、ベンチマークツールを含む高度な最適化技法については、references/advanced-patterns.md を参照してください。

ベストプラクティス

1. 最適化の前にプロファイリング - 実際のボトルネックを見つけるために測定する
2. ホットパスに焦点を当てる - 最も頻繁に実行されるコードを最適化
3. 適切なデータ構造を使用 - 検索には辞書、メンバーシップにはセット
4. 時期尚早の最適化を避ける - 明確性を優先し、その後に最適化
5. 組み込み関数を使用 - これらは C で実装されている
6. 高い計算コストのある計算をキャッシング - lru_cache を使用
7. I/O 操作をバッチ処理 - システムコールを削減
8. 大規模データセットにはジェネレータを使用
9. 数値操作には NumPy を検討
10. 本番環境コードをプロファイリング - ライブシステムには py-spy を使用

よくある落とし穴

• プロファイリングなしで最適化
• 不要にグローバル変数を使用
• 適切なデータ構造を使わない
• 不要なデータコピーを作成
• データベース接続プーリングを使わない
• アルゴリズムの複雑度を無視
• 稀なコードパスの過度な最適化
• メモリ使用量を考慮しない