高度なPythonデータ構造:リストと辞書を万能薬にするのをやめよう

# ❌ ANTI-PATTERN: List as a FIFO queue (Catastrophic O(n) performance)
queue = []
for i in range(100_000):
    queue.append(i)

while queue:
    item = queue.pop(0) # Forces 100,000 pointer memory shifts!

# ✅ OPTIMAL: O(1) appends and pops from both ends
from collections import deque

queue = deque()
for i in range(100_000):
    queue.append(i)

while queue:
    item = queue.popleft() # Instantaneous O(1) pointer adjustment

# Automatic rolling buffer of the last 5 events
recent_events = deque(maxlen=5)

for event_id in range(10):
    recent_events.append(f"event_{event_id}")

print(list(recent_events))
# Outputs: ['event_5', 'event_6', 'event_7', 'event_8', 'event_9']

# ❌ The manual, verbose approach
counts = {}
for word in log_stream:
    if word in counts:
        counts[word] += 1
    else:
        counts[word] = 1

from collections import Counter

# Instant O(n) frequency tabulation
word_counts = Counter(['apple', 'banana', 'apple', 'cherry', 'apple', 'banana'])

# Retrieve top 2 most common items instantly
print(word_counts.most_common(2))
# Outputs: [('apple', 3), ('banana', 2)]

# Mathematical set operations between Counters
batch_a = Counter(error=5, warning=2)
batch_b = Counter(error=3, warning=4, critical=1)

combined = batch_a + batch_b
print(combined)
# Outputs: Counter({'error': 8, 'warning': 6, 'critical': 1})

# ❌ Repetitive dictionary checks
grouped_orders = {}
for order in orders:
    customer_id = order['customer_id']
    if customer_id not in grouped_orders:
        grouped_orders[customer_id] = []
    grouped_orders[customer_id].append(order)

# ✅ Clean and fast grouping
from collections import defaultdict

grouped_orders = defaultdict(list)
for order in orders:
    # Automatically creates an empty list on first access!
    grouped_orders[order['customer_id']].append(order)

import heapq

class TaskScheduler:
    def __init__(self):
        self._heap = []

    def push_task(self, priority: int, task_name: str):
        # Min-heap orders lowest priority number first (e.g. 1 = critical)
        heapq.heappush(self._heap, (priority, task_name))

    def pop_next_task(self) -> str:
        priority, task_name = heapq.heappop(self._heap)
        return task_name

# Finding Top-K items in O(n log k) instead of O(n log n)
large_dataset = [15, 3, 99, 42, 8, 104, 2, 77, 63]
top_3_largest = heapq.nlargest(3, large_dataset)
print(top_3_largest) # [104, 99, 77]

from dataclasses import dataclass
import sys

# Standard dataclass (Allocates __dict__ for every instance)
@dataclass
class StandardRecord:
    id: int
    name: str
    amount: float

# Slotted dataclass (Zero __dict__ overhead)
@dataclass(slots=True)
class OptimizedRecord:
    id: int
    name: str
    amount: float

std_obj = StandardRecord(1, "Account_A", 150.0)
opt_obj = OptimizedRecord(1, "Account_A", 150.0)

# Memory consumption comparison
print("Standard object size:", sys.getsizeof(std_obj) + sys.getsizeof(std_obj.__dict__))
# ~152 bytes per instance
print("Slotted object size: ", sys.getsizeof(opt_obj))
# ~56 bytes per instance (63% memory reduction!)