# 例: メールアドレスの簡易パターン
pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
 
# 分解して読む:
# ^                    -- 文字列の先頭
# [a-zA-Z0-9._%+-]+   -- ローカルパート(1文字以上の英数字と記号)
# @                    -- リテラル '@'
# [a-zA-Z0-9.-]+      -- ドメイン名(1文字以上の英数字とハイフン、ドット)
# \.                   -- リテラル '.'
# [a-zA-Z]{2,}        -- TLD(2文字以上のアルファベット)
# $                    -- 文字列の末尾

# 例: 日本の電話番号パターン
pattern = r'^0\d{1,4}-\d{1,4}-\d{4}$'
 
# 分解:
# ^           -- 先頭
# 0           -- リテラル '0' (市外局番の先頭)
# \d{1,4}     -- 1〜4桁の数字
# -           -- リテラル '-'
# \d{1,4}     -- 1〜4桁の数字(市内局番)
# -           -- リテラル '-'
# \d{4}       -- 4桁の数字(加入者番号)
# $           -- 末尾

# Thompson構成法の概念的な実装例
# 正規表現の基本操作に対応するNFA構築
 
class NFAState:
    """NFA の状態"""
    def __init__(self):
        self.transitions = {}  # 文字 -> [次の状態]
        self.epsilon = []      # ε遷移先
        self.is_accept = False
 
class NFAFragment:
    """NFA の断片（構築中の部分NFA）"""
    def __init__(self, start, accept):
        self.start = start
        self.accept = accept
 
def literal(char):
    """リテラル文字 'a' に対する NFA"""
    start = NFAState()
    accept = NFAState()
    accept.is_accept = True
    start.transitions[char] = [accept]
    return NFAFragment(start, accept)
 
def concatenation(frag1, frag2):
    """連結 ab に対する NFA"""
    frag1.accept.is_accept = False
    frag1.accept.epsilon.append(frag2.start)
    return NFAFragment(frag1.start, frag2.accept)
 
def alternation(frag1, frag2):
    """選択 a|b に対する NFA"""
    start = NFAState()
    accept = NFAState()
    accept.is_accept = True
    start.epsilon.extend([frag1.start, frag2.start])
    frag1.accept.is_accept = False
    frag2.accept.is_accept = False
    frag1.accept.epsilon.append(accept)
    frag2.accept.epsilon.append(accept)
    return NFAFragment(start, accept)
 
def kleene_star(frag):
    """Kleene閉包 a* に対する NFA"""
    start = NFAState()
    accept = NFAState()
    accept.is_accept = True
    start.epsilon.extend([frag.start, accept])
    frag.accept.is_accept = False
    frag.accept.epsilon.extend([frag.start, accept])
    return NFAFragment(start, accept)

# NFA (Nondeterministic Finite Automaton) の動作シミュレーション
import re
 
pattern = r'a(b|c)d'
text = "acd"
 
# 内部的な動作:
# 1. 状態 S0: 'a' を読む → マッチ → S1 へ遷移
# 2. 状態 S1: 'c' を読む → 'b' を試行 → 失敗
#                        → バックトラックして 'c' を試行 → マッチ → S2 へ
# 3. 状態 S2: 'd' を読む → マッチ → 受理状態
 
result = re.match(pattern, text)
print(result.group())   # => "acd"
print(result.group(1))  # => "c"

# DFA (Deterministic Finite Automaton) は事前に全状態を展開する
# パターン: a(b|c)d
 
# 状態遷移テーブル:
# 現在状態 | 入力 'a' | 入力 'b' | 入力 'c' | 入力 'd'
# ---------|----------|----------|----------|--------
# S0       | S1       | -        | -        | -
# S1       | -        | S2       | S2       | -
# S2       | -        | -        | -        | S3(受理)
 
# DFA ではバックトラックが発生しない
# 各文字につき状態遷移は1回のみ → O(n)
 
# Rust の regex クレートは DFA ベース
# RE2 も DFA ベース

# 1. テキスト検索 (grep)
grep -E 'ERROR|WARN' /var/log/syslog
 
# 2. テキスト置換 (sed)
sed 's/2025/2026/g' document.txt
 
# 3. データ抽出 (Python)
python3 -c "
import re
log = '2026-02-11 10:30:45 [ERROR] Connection timeout (192.168.1.1)'
m = re.search(r'(\d{4}-\d{2}-\d{2}) .* \[(\w+)\] (.+)', log)
print(f'日付: {m.group(1)}, レベル: {m.group(2)}, メッセージ: {m.group(3)}')
"
 
# 4. 入力検証 (JavaScript)
node -e "
const emailPattern = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
console.log(emailPattern.test('user@example.com'));  // true
console.log(emailPattern.test('invalid@'));           // false
"
 
# 5. 構文ハイライト -- エディタがキーワードを着色する仕組み
# パターン例: \b(if|else|for|while|return)\b → キーワードとして着色
 
# 6. ファイル名マッチング (find + grep)
find /var/log -name "*.log" -exec grep -l 'CRITICAL' {} \;
 
# 7. CSV データの変換 (awk)
awk -F',' '/^2026/ {print $1, $3}' data.csv
 
# 8. コード内の TODO コメント抽出
grep -rn 'TODO\|FIXME\|HACK\|XXX' --include='*.py' src/

import re
from collections import Counter, defaultdict
from datetime import datetime
 
# Apache アクセスログの解析
log_pattern = re.compile(
    r'(?P<ip>\d+\.\d+\.\d+\.\d+)'       # IPアドレス
    r' - - '
    r'\[(?P<timestamp>[^\]]+)\]'           # タイムスタンプ
    r' "(?P<method>\w+)'                   # HTTPメソッド
    r' (?P<path>[^\s]+)'                   # リクエストパス
    r' HTTP/[\d.]+"'                       # HTTPバージョン
    r' (?P<status>\d{3})'                  # ステータスコード
    r' (?P<size>\d+|-)'                    # レスポンスサイズ
    r'(?: "(?P<referer>[^"]*)")?'          # リファラー(オプション)
    r'(?: "(?P<useragent>[^"]*)")?'        # ユーザーエージェント(オプション)
)
 
def analyze_access_log(log_file: str):
    """アクセスログを解析して統計情報を出力"""
    status_counter = Counter()
    path_counter = Counter()
    ip_counter = Counter()
    hourly_access = defaultdict(int)
    error_logs = []
 
    with open(log_file) as f:
        for line in f:
            m = log_pattern.match(line)
            if not m:
                continue
 
            data = m.groupdict()
            status = int(data['status'])
            path = data['path']
            ip = data['ip']
 
            status_counter[status] += 1
            path_counter[path] += 1
            ip_counter[ip] += 1
 
            # 時間帯別集計
            try:
                dt = datetime.strptime(
                    data['timestamp'],
                    '%d/%b/%Y:%H:%M:%S %z'
                )
                hourly_access[dt.hour] += 1
            except ValueError:
                pass
 
            # エラーログの収集
            if status >= 400:
                error_logs.append({
                    'ip': ip,
                    'path': path,
                    'status': status,
                    'timestamp': data['timestamp']
                })
 
    return {
        'total_requests': sum(status_counter.values()),
        'status_distribution': dict(status_counter),
        'top_paths': path_counter.most_common(10),
        'top_ips': ip_counter.most_common(10),
        'hourly_distribution': dict(hourly_access),
        'error_count': len(error_logs),
        'recent_errors': error_logs[-10:]
    }

import re
 
def clean_text(text: str) -> str:
    """テキストデータのクレンジング"""
    # 連続する空白を1つに統一
    text = re.sub(r'\s+', ' ', text)
 
    # 全角英数字を半角に変換
    text = re.sub(r'[Ａ-Ｚａ-ｚ０-９]',
                  lambda m: chr(ord(m.group()) - 0xFEE0), text)
 
    # HTMLタグの除去
    text = re.sub(r'<[^>]+>', '', text)
 
    # 制御文字の除去（改行・タブは保持）
    text = re.sub(r'[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]', '', text)
 
    # 先頭・末尾の空白を除去
    text = text.strip()
 
    return text
 
def normalize_phone_number(phone: str) -> str:
    """電話番号の正規化"""
    # 数字以外を除去
    digits = re.sub(r'\D', '', phone)
 
    # 国際電話番号の処理
    if digits.startswith('81') and len(digits) >= 11:
        digits = '0' + digits[2:]
 
    # フォーマット(固定電話)
    if len(digits) == 10:
        m = re.match(r'(\d{2,4})(\d{2,4})(\d{4})', digits)
        if m:
            return f'{m.group(1)}-{m.group(2)}-{m.group(3)}'
 
    # フォーマット(携帯電話)
    if len(digits) == 11:
        m = re.match(r'(\d{3})(\d{4})(\d{4})', digits)
        if m:
            return f'{m.group(1)}-{m.group(2)}-{m.group(3)}'
 
    return phone  # 変換不能な場合はそのまま返す
 
def extract_urls(text: str) -> list:
    """テキストからURLを抽出"""
    url_pattern = re.compile(
        r'https?://'                    # スキーム
        r'(?:[a-zA-Z0-9]'              # ドメインの先頭文字
        r'(?:[a-zA-Z0-9-]{0,61}'       # ドメイン名本体
        r'[a-zA-Z0-9])?\.)'            # ドメインの末尾
        r'+[a-zA-Z]{2,}'               # TLD
        r'(?::\d{1,5})?'               # ポート(オプション)
        r'(?:/[^\s]*)?'                # パス(オプション)
    )
    return url_pattern.findall(text)
 
def mask_personal_info(text: str) -> str:
    """個人情報のマスキング"""
    # メールアドレス
    text = re.sub(
        r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}',
        '***@***.***',
        text
    )
 
    # 電話番号(日本)
    text = re.sub(
        r'0\d{1,4}[-\s]?\d{1,4}[-\s]?\d{4}',
        '***-****-****',
        text
    )
 
    # クレジットカード番号
    text = re.sub(
        r'\b\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}\b',
        '****-****-****-****',
        text
    )
 
    # マイナンバー（12桁の数字）
    text = re.sub(
        r'\b\d{4}[-\s]?\d{4}[-\s]?\d{4}\b',
        '****-****-****',
        text
    )
 
    return text

# Unix パイプラインでの正規表現活用例
 
# 例1: アクセスログからエラーレスポンスのIPアドレスを集計
cat access.log \
  | grep -E '" [45]\d{2} ' \
  | awk '{print $1}' \
  | sort | uniq -c | sort -rn \
  | head -20
 
# 例2: ソースコードから関数定義を抽出
grep -rn 'def \w\+(' --include='*.py' src/ \
  | sed 's/.*def \(\w\+\)(.*/\1/' \
  | sort | uniq -c | sort -rn
 
# 例3: JSON ログからエラーメッセージを抽出
cat app.log \
  | grep -oP '"error":\s*"[^"]*"' \
  | sed 's/"error":\s*"\(.*\)"/\1/' \
  | sort | uniq -c | sort -rn
 
# 例4: Git ログからチケット番号を抽出
git log --oneline \
  | grep -oE '[A-Z]+-[0-9]+' \
  | sort | uniq -c | sort -rn

# 正規表現では原理的に扱えないパターン
 
# 1. ネストした括弧の対応
#    a^n b^n (n個のaの後にn個のb) は正則言語ではない
#    例: ab, aabb, aaabbb は受理、aab, abbb は拒否
#    → 正規表現では記述不可能
 
# 2. 回文の認識
#    例: "abcba", "racecar"
#    → 正規表現では記述不可能
 
# 3. 素数長の文字列
#    長さが素数の文字列だけにマッチ
#    → 正規表現では記述不可能
 
# ただし、実用的な「正規表現」(PCRE等)は
# 理論的な正則言語を超える機能を持つ:
 
import re
 
# .NET のバランシンググループを使えば
# ネストした括弧のマッチが可能（理論的にはCFGの領域）
# (?<open>\()  (?<close-open>\))
 
# Perl/PCRE の再帰パターンでも可能
# \((?:[^()]*|(?R))*\)

# 正規表現が適さないケース
 
# 1. 複雑な文法の解析
# NG: JSON を正規表現でパース
json_text = '{"name": "John", "address": {"city": "Tokyo"}}'
# → JSON パーサーを使うべき
 
# 2. マルチバイト文字の高度な処理
# NG: 漢字の読み仮名を正規表現で推測
# → 形態素解析器(MeCab, Janome等)を使うべき
 
# 3. 文脈依存の解析
# NG: Pythonのインデントベースのブロック構造
# → パーサー(AST)を使うべき
 
# 4. 大規模テキストの構造解析
# NG: 数百MBのXMLファイルを正規表現で処理
# → SAXパーサー等のストリーミング処理を使うべき
 
# 5. 自然言語の意味解析
# NG: 文の主語と述語を正規表現で抽出
# → NLP ライブラリ(spaCy, GiNZA等)を使うべき

# NG: HTML を正規表現で処理しようとする
import re
 
html = '<div class="outer"><div class="inner">text</div></div>'
 
# このパターンはネストした div を正しく処理できない
pattern = r'<div[^>]*>(.*?)</div>'
result = re.findall(pattern, html)
print(result)  # => ['<div class="inner">text']  -- 不正確
 
# OK: HTML パーサーを使う
from html.parser import HTMLParser
# または Beautiful Soup, lxml 等を使用する

# NG: RFC 5322 完全準拠のメールアドレスパターン（実際に存在する）
# 数千文字に及ぶ正規表現 → 保守不能、デバッグ不能
 
email_pattern_bad = r"""(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@..."""
# (省略 -- 実際は数百文字以上)
 
# OK: 実用的なバリデーション + 確認メール送信
import re
 
def validate_email(email: str) -> bool:
    """実用的なメール検証 -- 形式チェック + 確認メール"""
    # 基本形式のみチェック
    if not re.match(r'^[^@\s]+@[^@\s]+\.[^@\s]+$', email):
        return False
    # 本当の検証は確認メールを送信して行う
    return True

# NG: 壊滅的バックトラック(Catastrophic Backtracking)を引き起こすパターン
import re
import time
 
# 危険なパターンの例
dangerous_patterns = [
    r'(a+)+$',           # ネストした量指定子
    r'(a|a)+$',          # 重複する選択肢
    r'(a+b?)+$',         # 組み合わせ爆発
    r'([a-zA-Z]+)*$',    # ネストした量指定子（文字クラス版）
]
 
# 攻撃文字列: 大量の 'a' の後に不一致文字
evil_input = 'a' * 30 + '!'
 
for pattern in dangerous_patterns:
    start = time.time()
    try:
        re.match(pattern, evil_input)
    except Exception:
        pass
    elapsed = time.time() - start
    print(f'Pattern: {pattern:30s} Time: {elapsed:.3f}s')
    # パターンによっては数秒〜数十秒かかる
 
# OK: ReDoS に強いパターンの書き方
safe_patterns = [
    r'a+$',              # ネストを避ける
    r'(?:a+)+$',         # 非キャプチャでも危険は同じ → a+$ に書き換え
    r'[a-zA-Z]+$',       # ネストを避ける
]
 
# OK: タイムアウト付きマッチング (Python 3.11+)
# import signal
# signal.alarm(1)  # 1秒タイムアウト

# NG: 一行に詰め込まれた長大なパターン
pattern_bad = r'^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$'
 
# OK: verbose モードで可読性を確保
import re
 
pattern_good = re.compile(r'''
    ^
    (?:
        (?:
            25[0-5]           # 250-255
            | 2[0-4][0-9]     # 200-249
            | [01]?[0-9][0-9]? # 0-199
        )
        \.                     # ドット区切り
    ){3}                       # 最初の3オクテット
    (?:
        25[0-5]               # 250-255
        | 2[0-4][0-9]         # 200-249
        | [01]?[0-9][0-9]?    # 0-199
    )
    $
''', re.VERBOSE)
 
# テスト
assert pattern_good.match('192.168.1.1')
assert pattern_good.match('255.255.255.255')
assert not pattern_good.match('256.1.1.1')
assert not pattern_good.match('1.2.3.4.5')

import re
 
# NG: ループ内で毎回コンパイル
def search_bad(lines, pattern_str):
    results = []
    for line in lines:
        if re.search(pattern_str, line):  # 毎回コンパイル
            results.append(line)
    return results
 
# OK: 事前にコンパイル
def search_good(lines, pattern_str):
    pattern = re.compile(pattern_str)  # 1回だけコンパイル
    results = []
    for line in lines:
        if pattern.search(line):       # コンパイル済みオブジェクトを再利用
            results.append(line)
    return results
 
# OK: さらに良い方法（リスト内包表記）
def search_best(lines, pattern_str):
    pattern = re.compile(pattern_str)
    return [line for line in lines if pattern.search(line)]
 
# ※ Python の re モジュールは内部的にパターンキャッシュ（最大512個）を
#    持っているため、少数のパターンなら re.search() でも問題ないが、
#    明示的なコンパイルが推奨される

import re
 
# 複雑なパターンは段階的に構築する
 
# 目標: Apache ログの解析パターン
# サンプル: 192.168.1.1 - - [10/Feb/2026:13:55:36 +0900] "GET /index.html HTTP/1.1" 200 2326
 
# ステップ 1: IPアドレス部分
step1 = r'\d+\.\d+\.\d+\.\d+'
assert re.search(step1, '192.168.1.1')
 
# ステップ 2: タイムスタンプ部分
step2 = r'\[([^\]]+)\]'
assert re.search(step2, '[10/Feb/2026:13:55:36 +0900]')
 
# ステップ 3: リクエスト行
step3 = r'"(\w+) ([^\s]+) HTTP/[\d.]+"'
assert re.search(step3, '"GET /index.html HTTP/1.1"')
 
# ステップ 4: ステータスコードとサイズ
step4 = r'(\d{3}) (\d+|-)'
assert re.search(step4, '200 2326')
 
# ステップ 5: 全体を結合
full_pattern = re.compile(
    rf'({step1})'     # IP
    r' - - '          # ident, auth
    rf'{step2}'       # timestamp
    r' '
    rf'{step3}'       # request
    r' '
    rf'{step4}'       # status, size
)
 
log_line = '192.168.1.1 - - [10/Feb/2026:13:55:36 +0900] "GET /index.html HTTP/1.1" 200 2326'
m = full_pattern.match(log_line)
assert m is not None
print(f'IP: {m.group(1)}')
print(f'Timestamp: {m.group(2)}')
print(f'Method: {m.group(3)}')
print(f'Path: {m.group(4)}')
print(f'Status: {m.group(5)}')
print(f'Size: {m.group(6)}')

import re
import pytest
 
class TestPhoneNumberPattern:
    """電話番号パターンのテスト"""
 
    pattern = re.compile(r'^0\d{1,4}-\d{1,4}-\d{4}$')
 
    # 正常系: マッチすべきもの
    @pytest.mark.parametrize("phone", [
        "03-1234-5678",       # 東京
        "06-1234-5678",       # 大阪
        "090-1234-5678",      # 携帯
        "080-1234-5678",      # 携帯
        "0120-123-4567",      # フリーダイヤル
        "0466-12-3456",       # 市外局番4桁
    ])
    def test_valid_phones(self, phone):
        assert self.pattern.match(phone), f"{phone} should match"
 
    # 異常系: マッチすべきでないもの
    @pytest.mark.parametrize("phone", [
        "1234-5678",          # 先頭が0でない
        "03-1234-567",        # 加入者番号が3桁
        "03-1234-56789",      # 加入者番号が5桁
        "abc-defg-hijk",      # 数字でない
        "",                   # 空文字列
        "03 1234 5678",       # ハイフンでなくスペース
    ])
    def test_invalid_phones(self, phone):
        assert not self.pattern.match(phone), f"{phone} should not match"
 
class TestEmailPattern:
    """メールアドレスパターンのテスト"""
 
    pattern = re.compile(
        r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
    )
 
    @pytest.mark.parametrize("email", [
        "user@example.com",
        "user.name@example.co.jp",
        "user+tag@example.org",
        "user123@sub.domain.com",
    ])
    def test_valid_emails(self, email):
        assert self.pattern.match(email)
 
    @pytest.mark.parametrize("email", [
        "user@",
        "@example.com",
        "user@.com",
        "user@com",
        "",
        "user space@example.com",
    ])
    def test_invalid_emails(self, email):
        assert not self.pattern.match(email)

# Python の re.DEBUG フラグでパターンの内部構造を確認
import re
 
# パターンの解析結果を表示
re.compile(r'\d{3}-\d{4}', re.DEBUG)
# 出力:
# MAX_REPEAT 3 3
#   IN
#     CATEGORY CATEGORY_DIGIT
# LITERAL 45 ('-')
# MAX_REPEAT 4 4
#   IN
#     CATEGORY CATEGORY_DIGIT
 
# verbose モードでコメント付きパターン
pattern = re.compile(r"""
    (?P<year>\d{4})     # 年: 4桁の数字
    [-/]                # 区切り: ハイフンまたはスラッシュ
    (?P<month>\d{2})    # 月: 2桁の数字
    [-/]                # 区切り
    (?P<day>\d{2})      # 日: 2桁の数字
""", re.VERBOSE)
 
result = pattern.match('2026-02-15')
if result:
    print(result.groupdict())
    # => {'year': '2026', 'month': '02', 'day': '15'}

# パターンの命名に一貫性を持たせる
 
# 検証パターン: is_* または validate_*
PATTERN_IS_EMAIL = re.compile(r'^[^@\s]+@[^@\s]+\.[^@\s]+$')
PATTERN_IS_URL = re.compile(r'^https?://[^\s]+$')
PATTERN_IS_IPV4 = re.compile(r'^\d{1,3}(\.\d{1,3}){3}$')
 
# 抽出パターン: extract_* または parse_*
PATTERN_EXTRACT_DATE = re.compile(r'(\d{4})-(\d{2})-(\d{2})')
PATTERN_EXTRACT_IP = re.compile(r'\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b')
 
# 置換パターン: replace_* または clean_*
PATTERN_CLEAN_WHITESPACE = re.compile(r'\s+')
PATTERN_CLEAN_HTML_TAGS = re.compile(r'<[^>]+>')

# 演習1: 基本実装のテンプレート
class Exercise1:
    """基本的な実装パターンの演習"""
 
    def __init__(self):
        self.data = []
 
    def validate_input(self, value):
        """入力値の検証"""
        if value is None:
            raise ValueError("入力値がNoneです")
        return True
 
    def process(self, value):
        """データ処理のメインロジック"""
        self.validate_input(value)
        self.data.append(value)
        return self.data
 
    def get_results(self):
        """処理結果の取得"""
        return {
            'count': len(self.data),
            'data': self.data
        }
 
# テスト
def test_exercise1():
    ex = Exercise1()
    assert ex.process(1) == [1]
    assert ex.process(2) == [1, 2]
    assert ex.get_results()['count'] == 2
 
    try:
        ex.process(None)
        assert False, "例外が発生するべき"
    except ValueError:
        pass
 
    print("全テスト合格!")
 
test_exercise1()

# 演習2: 応用パターン
from typing import List, Dict, Optional
from datetime import datetime
 
class AdvancedExercise:
    """応用パターンの演習"""
 
    def __init__(self, max_size: int = 100):
        self._items: List[Dict] = []
        self._max_size = max_size
        self._created_at = datetime.now()
 
    def add(self, key: str, value: any) -> bool:
        """アイテムの追加（サイズ制限付き）"""
        if len(self._items) >= self._max_size:
            return False
        self._items.append({
            'key': key,
            'value': value,
            'timestamp': datetime.now().isoformat()
        })
        return True
 
    def find(self, key: str) -> Optional[Dict]:
        """キーによる検索"""
        for item in reversed(self._items):
            if item['key'] == key:
                return item
        return None
 
    def remove(self, key: str) -> bool:
        """キーによる削除"""
        for i, item in enumerate(self._items):
            if item['key'] == key:
                self._items.pop(i)
                return True
        return False
 
    def stats(self) -> Dict:
        """統計情報"""
        return {
            'total_items': len(self._items),
            'max_size': self._max_size,
            'usage_percent': len(self._items) / self._max_size * 100,
            'uptime': str(datetime.now() - self._created_at)
        }
 
# テスト
def test_advanced():
    ex = AdvancedExercise(max_size=3)
    assert ex.add("a", 1) == True
    assert ex.add("b", 2) == True
    assert ex.add("c", 3) == True
    assert ex.add("d", 4) == False  # サイズ制限
    assert ex.find("b")['value'] == 2
    assert ex.remove("b") == True
    assert ex.find("b") is None
    stats = ex.stats()
    assert stats['total_items'] == 2
    print("応用テスト全合格!")
 
test_advanced()

# 演習3: パフォーマンス最適化
import time
from functools import lru_cache
 
# 最適化前（O(n^2)）
def slow_search(data: list, target: int) -> int:
    """非効率な検索"""
    for i in range(len(data)):
        for j in range(i + 1, len(data)):
            if data[i] + data[j] == target:
                return (i, j)
    return (-1, -1)
 
# 最適化後（O(n)）
def fast_search(data: list, target: int) -> tuple:
    """ハッシュマップを使った効率的な検索"""
    seen = {}
    for i, num in enumerate(data):
        complement = target - num
        if complement in seen:
            return (seen[complement], i)
        seen[num] = i
    return (-1, -1)
 
# ベンチマーク
def benchmark():
    import random
    data = list(range(5000))
    random.shuffle(data)
    target = data[100] + data[4000]
 
    start = time.time()
    result1 = slow_search(data, target)
    slow_time = time.time() - start
 
    start = time.time()
    result2 = fast_search(data, target)
    fast_time = time.time() - start
 
    print(f"非効率版: {slow_time:.4f}秒")
    print(f"効率版:   {fast_time:.6f}秒")
    print(f"高速化率: {slow_time/fast_time:.0f}倍")
 
benchmark()

# デバッグ用ユーティリティ
import logging
import traceback
from functools import wraps
 
# ロガーの設定
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s [%(levelname)s] %(name)s: %(message)s'
)
logger = logging.getLogger(__name__)
 
def debug_decorator(func):
    """関数の入出力をログ出力するデコレータ"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        logger.debug(f"呼び出し: {func.__name__}(args={args}, kwargs={kwargs})")
        try:
            result = func(*args, **kwargs)
            logger.debug(f"戻り値: {func.__name__} -> {result}")
            return result
        except Exception as e:
            logger.error(f"例外発生: {func.__name__}: {e}")
            logger.error(traceback.format_exc())
            raise
    return wrapper
 
@debug_decorator
def process_data(items):
    """データ処理（デバッグ対象）"""
    if not items:
        raise ValueError("空のデータ")
    return [item * 2 for item in items]

# 設計判断の記録テンプレート
class ArchitectureDecisionRecord:
    """ADR (Architecture Decision Record) の作成"""
 
    def __init__(self, title: str):
        self.title = title
        self.context = ""
        self.decision = ""
        self.consequences = []
        self.alternatives = []
 
    def set_context(self, context: str):
        """背景と課題の記述"""
        self.context = context
        return self
 
    def set_decision(self, decision: str):
        """決定内容の記述"""
        self.decision = decision
        return self
 
    def add_consequence(self, consequence: str, positive: bool = True):
        """結果の追加"""
        self.consequences.append({
            'description': consequence,
            'type': 'positive' if positive else 'negative'
        })
        return self
 
    def add_alternative(self, name: str, reason_rejected: str):
        """却下した代替案の追加"""
        self.alternatives.append({
            'name': name,
            'reason_rejected': reason_rejected
        })
        return self
 
    def to_markdown(self) -> str:
        """Markdown形式で出力"""
        md = f"# ADR: {self.title}\n\n"
        md += f"## 背景\n{self.context}\n\n"
        md += f"## 決定\n{self.decision}\n\n"
        md += "## 結果\n"
        for c in self.consequences:
            icon = "✅" if c['type'] == 'positive' else "⚠️"
            md += f"- {icon} {c['description']}\n"
        md += "\n## 却下した代替案\n"
        for a in self.alternatives:
            md += f"- **{a['name']}**: {a['reason_rejected']}\n"
        return md