import anthropic
 
client = anthropic.Anthropic()  # ANTHROPIC_API_KEY 環境変数を使用
 
# 基本的なメッセージ送信
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    system="あなたは日本語で回答する技術アシスタントです。",
    messages=[
        {"role": "user", "content": "Pythonのデコレータを説明してください"}
    ]
)
 
print(response.content[0].text)
print(f"入力トークン: {response.usage.input_tokens}")
print(f"出力トークン: {response.usage.output_tokens}")
print(f"モデル: {response.model}")
print(f"停止理由: {response.stop_reason}")

import anthropic
 
client = anthropic.Anthropic()
 
# ストリーミングで応答を受け取る（体感レイテンシの大幅改善）
with client.messages.stream(
    model="claude-sonnet-4-20250514",
    max_tokens=2048,
    system="あなたは技術文書の専門家です。",
    messages=[
        {"role": "user", "content": "マイクロサービスアーキテクチャの利点と課題を説明してください"}
    ]
) as stream:
    full_response = ""
    for text in stream.text_stream:
        print(text, end="", flush=True)
        full_response += text
 
    print()
 
    # ストリーム完了後のメタデータ
    final_message = stream.get_final_message()
    print(f"\n入力トークン: {final_message.usage.input_tokens}")
    print(f"出力トークン: {final_message.usage.output_tokens}")

import anthropic
from typing import List, Dict
 
class ClaudeConversation:
    """Claude とのマルチターン会話管理"""
 
    def __init__(
        self,
        model: str = "claude-sonnet-4-20250514",
        system: str = "",
        max_tokens: int = 2048,
    ):
        self.client = anthropic.Anthropic()
        self.model = model
        self.system = system
        self.max_tokens = max_tokens
        self.messages: List[Dict] = []
        self.total_input_tokens = 0
        self.total_output_tokens = 0
 
    def chat(self, user_message: str) -> str:
        """メッセージを送信して応答を取得"""
        self.messages.append({"role": "user", "content": user_message})
 
        response = self.client.messages.create(
            model=self.model,
            max_tokens=self.max_tokens,
            system=self.system,
            messages=self.messages,
        )
 
        assistant_message = response.content[0].text
        self.messages.append({"role": "assistant", "content": assistant_message})
 
        self.total_input_tokens += response.usage.input_tokens
        self.total_output_tokens += response.usage.output_tokens
 
        return assistant_message
 
    def reset(self):
        """会話をリセット"""
        self.messages = []
        self.total_input_tokens = 0
        self.total_output_tokens = 0
 
    def get_stats(self) -> Dict:
        """会話の統計情報"""
        return {
            "turns": len(self.messages) // 2,
            "total_input_tokens": self.total_input_tokens,
            "total_output_tokens": self.total_output_tokens,
            "total_tokens": self.total_input_tokens + self.total_output_tokens,
        }
 
# 使用例
conv = ClaudeConversation(
    system="あなたは親切なプログラミング講師です。段階的に教えてください。"
)
 
print(conv.chat("Pythonのリスト内包表記を教えてください"))
print(conv.chat("条件付きのリスト内包表記はどう書きますか？"))
print(conv.chat("ネストされた場合はどうなりますか？"))
print(f"\n統計: {conv.get_stats()}")

import anthropic
import base64
import httpx
 
client = anthropic.Anthropic()
 
# パターン1: ローカルファイルから
def analyze_local_image(image_path: str, prompt: str) -> str:
    """ローカル画像を分析"""
    with open(image_path, "rb") as f:
        image_data = base64.standard_b64encode(f.read()).decode("utf-8")
 
    # 拡張子からメディアタイプを判定
    media_types = {
        ".png": "image/png",
        ".jpg": "image/jpeg",
        ".jpeg": "image/jpeg",
        ".gif": "image/gif",
        ".webp": "image/webp",
    }
    ext = "." + image_path.rsplit(".", 1)[-1].lower()
    media_type = media_types.get(ext, "image/png")
 
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=2048,
        messages=[{
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": media_type,
                        "data": image_data,
                    },
                },
                {"type": "text", "text": prompt}
            ],
        }]
    )
    return response.content[0].text
 
# パターン2: URLから
def analyze_url_image(image_url: str, prompt: str) -> str:
    """URL画像を分析"""
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=2048,
        messages=[{
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "url",
                        "url": image_url,
                    },
                },
                {"type": "text", "text": prompt}
            ],
        }]
    )
    return response.content[0].text
 
# パターン3: 複数画像の比較
def compare_images(image_paths: list, prompt: str) -> str:
    """複数画像を比較分析"""
    content = []
    for path in image_paths:
        with open(path, "rb") as f:
            data = base64.standard_b64encode(f.read()).decode("utf-8")
        content.append({
            "type": "image",
            "source": {"type": "base64", "media_type": "image/png", "data": data},
        })
    content.append({"type": "text", "text": prompt})
 
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=2048,
        messages=[{"role": "user", "content": content}]
    )
    return response.content[0].text
 
# 使用例
result = analyze_local_image(
    "architecture_diagram.png",
    "このアーキテクチャ図を分析し、以下を教えてください:\n"
    "1. 全体構成の概要\n"
    "2. 潜在的なボトルネック\n"
    "3. 改善提案"
)
print(result)

import anthropic
 
client = anthropic.Anthropic()
 
# Claude の安全性特性を活用したシステム設計
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=2048,
    system="""あなたは企業の法務アシスタントです。
 
以下の原則に従ってください:
1. 法的助言ではなく一般的な情報提供であることを明記する
2. 不確実な場合は「確認が必要」と述べる
3. 個人情報の取り扱いには特に注意する
4. 専門家への相談を適切に推奨する
5. 関連する法律や条文を参照する際は正確を期す
6. 回答の最後に免責事項を記載する
 
Claude の Constitutional AI による安全性に加え、
上記のアプリケーション固有のガードレールを設定しています。""",
    messages=[{
        "role": "user",
        "content": "退職時の有給休暇の扱いについて教えてください"
    }]
)
 
print(response.content[0].text)

import anthropic
 
client = anthropic.Anthropic()
 
# Extended Thinking を有効にした推論
response = client.messages.create(
    model="claude-opus-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000,  # 思考に使えるトークン数
    },
    messages=[{
        "role": "user",
        "content": """以下の複雑なシステム設計問題を分析してください。
 
大規模ECサイトで以下の要件を満たすアーキテクチャを設計:
1. 秒間10,000リクエストの処理
2. 99.99%の可用性
3. 在庫の整合性保証（二重販売の防止）
4. グローバル展開（日本、米国、欧州）
5. リアルタイムの価格更新
6. 不正検知の組み込み
 
トレードオフを含めて詳細に分析してください。"""
    }]
)
 
# 思考過程と最終回答を分離して表示
for block in response.content:
    if block.type == "thinking":
        print("=== 思考過程 ===")
        print(block.thinking[:500] + "...")  # 長いので一部のみ
    elif block.type == "text":
        print("\n=== 最終回答 ===")
        print(block.text)
 
print(f"\n思考トークン: {response.usage.cache_creation_input_tokens}")
print(f"出力トークン: {response.usage.output_tokens}")

import anthropic
import json
 
client = anthropic.Anthropic()
 
# 複数ツールの定義
tools = [
    {
        "name": "get_weather",
        "description": "指定された都市の現在の天気を取得する",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "都市名（例: 東京、大阪、ニューヨーク）"
                },
                "unit": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "温度の単位",
                    "default": "celsius"
                }
            },
            "required": ["city"]
        }
    },
    {
        "name": "search_database",
        "description": "社内データベースから情報を検索する",
        "input_schema": {
            "type": "object",
            "properties": {
                "query": {
                    "type": "string",
                    "description": "検索クエリ"
                },
                "table": {
                    "type": "string",
                    "enum": ["customers", "orders", "products"],
                    "description": "検索対象テーブル"
                },
                "limit": {
                    "type": "integer",
                    "description": "最大件数",
                    "default": 10
                }
            },
            "required": ["query", "table"]
        }
    },
    {
        "name": "send_email",
        "description": "メールを送信する",
        "input_schema": {
            "type": "object",
            "properties": {
                "to": {"type": "string", "description": "宛先メールアドレス"},
                "subject": {"type": "string", "description": "件名"},
                "body": {"type": "string", "description": "本文"},
            },
            "required": ["to", "subject", "body"]
        }
    }
]
 
def execute_tool(name: str, input_data: dict) -> str:
    """ツールを実行する（実際のアプリケーションでは外部APIを呼び出す）"""
    if name == "get_weather":
        return json.dumps({
            "city": input_data["city"],
            "temperature": 22,
            "condition": "晴れ",
            "humidity": 45,
        }, ensure_ascii=False)
    elif name == "search_database":
        return json.dumps({
            "results": [{"id": 1, "name": "テストデータ"}],
            "total": 1,
        }, ensure_ascii=False)
    elif name == "send_email":
        return json.dumps({"status": "sent", "message_id": "msg_123"})
    return json.dumps({"error": "Unknown tool"})
 
def chat_with_tools(user_message: str) -> str:
    """ツール使用を含むチャット"""
    messages = [{"role": "user", "content": user_message}]
 
    while True:
        response = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=2048,
            tools=tools,
            messages=messages,
        )
 
        # ツール呼び出しがない場合は最終回答
        if response.stop_reason == "end_turn":
            return response.content[0].text
 
        # ツール呼び出しの処理
        messages.append({"role": "assistant", "content": response.content})
 
        tool_results = []
        for block in response.content:
            if block.type == "tool_use":
                result = execute_tool(block.name, block.input)
                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": result,
                })
 
        messages.append({"role": "user", "content": tool_results})
 
# 使用例
print(chat_with_tools("東京の天気を調べて、それに基づいた服装アドバイスをください"))

import anthropic
 
client = anthropic.Anthropic()
 
# 大量のコンテキスト（ドキュメント、コードベース等）をキャッシュ
large_context = """
（ここに大量のドキュメント、API仕様書、コードベースなど）
... 数千〜数万トークンのコンテンツ ...
"""
 
# 1回目: キャッシュを作成
response1 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": "あなたは以下のドキュメントに基づいて質問に答えるアシスタントです。"
        },
        {
            "type": "text",
            "text": large_context,
            "cache_control": {"type": "ephemeral"}  # キャッシュ対象
        }
    ],
    messages=[{"role": "user", "content": "このドキュメントの概要を教えてください"}],
)
 
print(f"1回目 - キャッシュ作成トークン: {response1.usage.cache_creation_input_tokens}")
print(f"1回目 - キャッシュ読み取り: {response1.usage.cache_read_input_tokens}")
 
# 2回目以降: キャッシュから読み取り（90%コスト削減）
response2 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": "あなたは以下のドキュメントに基づいて質問に答えるアシスタントです。"
        },
        {
            "type": "text",
            "text": large_context,
            "cache_control": {"type": "ephemeral"}
        }
    ],
    messages=[{"role": "user", "content": "セキュリティに関する部分を説明してください"}],
)
 
print(f"2回目 - キャッシュ作成トークン: {response2.usage.cache_creation_input_tokens}")
print(f"2回目 - キャッシュ読み取り: {response2.usage.cache_read_input_tokens}")
# → キャッシュヒットにより大幅なコスト削減

import anthropic
import json
 
client = anthropic.Anthropic()
 
# 大量のリクエストをバッチで処理（50%コスト削減、24時間以内に完了）
batch_requests = []
for i in range(100):
    batch_requests.append({
        "custom_id": f"request_{i}",
        "params": {
            "model": "claude-sonnet-4-20250514",
            "max_tokens": 1024,
            "messages": [
                {"role": "user", "content": f"製品レビュー #{i} を分析してください: ..."}
            ]
        }
    })
 
# バッチの作成
batch = client.batches.create(requests=batch_requests)
print(f"バッチID: {batch.id}")
print(f"ステータス: {batch.processing_status}")
 
# バッチのステータス確認
batch_status = client.batches.retrieve(batch.id)
print(f"処理済み: {batch_status.request_counts.succeeded}")
print(f"失敗: {batch_status.request_counts.errored}")
 
# 結果の取得（完了後）
if batch_status.processing_status == "ended":
    for result in client.batches.results(batch.id):
        print(f"ID: {result.custom_id}")
        if result.result.type == "succeeded":
            print(f"回答: {result.result.message.content[0].text[:100]}...")

"""
MCP (Model Context Protocol) サーバーの実装例
Claude Code や他の MCP クライアントから呼び出し可能なツールを提供
"""
from mcp.server import Server
from mcp.types import Tool, TextContent
import json
import sqlite3
 
# MCP サーバーの初期化
server = Server("my-tools")
 
@server.tool()
async def query_database(query: str, database: str = "main.db") -> str:
    """SQLiteデータベースに対してSELECTクエリを実行する
 
    Args:
        query: 実行するSELECTクエリ
        database: データベースファイルパス
 
    Returns:
        クエリ結果のJSON文字列
    """
    # セキュリティチェック: SELECT のみ許可
    if not query.strip().upper().startswith("SELECT"):
        return json.dumps({"error": "SELECT クエリのみ許可されています"})
 
    try:
        conn = sqlite3.connect(database)
        conn.row_factory = sqlite3.Row
        cursor = conn.execute(query)
        rows = [dict(row) for row in cursor.fetchall()]
        conn.close()
        return json.dumps({"results": rows, "count": len(rows)}, ensure_ascii=False)
    except Exception as e:
        return json.dumps({"error": str(e)})
 
@server.tool()
async def analyze_logs(
    log_path: str,
    level: str = "ERROR",
    last_n: int = 100,
) -> str:
    """ログファイルを分析して指定レベル以上のログを抽出する
 
    Args:
        log_path: ログファイルのパス
        level: フィルタするログレベル (DEBUG, INFO, WARN, ERROR)
        last_n: 最後のN行を対象にする
 
    Returns:
        フィルタされたログエントリのJSON
    """
    level_order = {"DEBUG": 0, "INFO": 1, "WARN": 2, "ERROR": 3}
    min_level = level_order.get(level, 0)
 
    try:
        with open(log_path, "r") as f:
            lines = f.readlines()[-last_n:]
 
        filtered = []
        for line in lines:
            for lvl, order in level_order.items():
                if lvl in line and order >= min_level:
                    filtered.append(line.strip())
                    break
 
        return json.dumps({
            "total_lines": len(lines),
            "filtered_count": len(filtered),
            "entries": filtered[:50],  # 最大50件
        }, ensure_ascii=False)
    except Exception as e:
        return json.dumps({"error": str(e)})
 
# Claude Code の設定ファイル (.claude/mcp.json)
mcp_config = {
    "mcpServers": {
        "my-tools": {
            "command": "python",
            "args": ["mcp_server.py"],
            "env": {
                "DATABASE_PATH": "/path/to/db"
            }
        }
    }
}

import anthropic
from pathlib import Path
 
class CodeReviewAssistant:
    """Claude を使ったコードレビューアシスタント"""
 
    def __init__(self):
        self.client = anthropic.Anthropic()
 
    def review_file(self, file_path: str) -> str:
        """ファイルのコードレビュー"""
        code = Path(file_path).read_text()
        ext = Path(file_path).suffix
 
        language_map = {
            ".py": "Python",
            ".ts": "TypeScript",
            ".js": "JavaScript",
            ".go": "Go",
            ".rs": "Rust",
            ".java": "Java",
        }
        language = language_map.get(ext, "Unknown")
 
        response = self.client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=4096,
            system=f"""あなたはシニアソフトウェアエンジニアです。
{language}のコードレビューを行います。
 
レビュー観点:
1. バグ・ロジックエラー
2. セキュリティ脆弱性
3. パフォーマンス問題
4. 可読性・保守性
5. テスタビリティ
6. エラーハンドリング
 
各問題には以下の情報を含めてください:
- 行番号（概算）
- 深刻度: Critical / High / Medium / Low
- 問題の説明
- 修正案（コード付き）""",
            messages=[{
                "role": "user",
                "content": f"以下の {language} コードをレビューしてください:\n\n```{ext[1:]}\n{code}\n```"
            }]
        )
        return response.content[0].text
 
    def review_diff(self, diff: str) -> str:
        """Git diff のレビュー"""
        response = self.client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=4096,
            system="""あなたはコードレビュアーです。
Git diff を分析し、以下を確認してください:
1. 変更の目的は明確か
2. 意図しない変更がないか
3. テストの追加・更新が必要か
4. パフォーマンスへの影響
5. 後方互換性の問題""",
            messages=[{
                "role": "user",
                "content": f"以下の diff をレビューしてください:\n\n```diff\n{diff}\n```"
            }]
        )
        return response.content[0].text
 
# 使用例
reviewer = CodeReviewAssistant()
review = reviewer.review_file("src/api/handlers.py")
print(review)

import anthropic
from typing import List, Dict
import json
 
class DocumentAnalyzer:
    """長文ドキュメントの分析パイプライン"""
 
    def __init__(self, model: str = "claude-sonnet-4-20250514"):
        self.client = anthropic.Anthropic()
        self.model = model
 
    def analyze(self, document: str, analysis_type: str = "comprehensive") -> Dict:
        """ドキュメントの包括的分析"""
        analyses = {
            "comprehensive": self._comprehensive_analysis,
            "summary": self._summary,
            "key_points": self._extract_key_points,
            "risks": self._risk_analysis,
            "action_items": self._extract_action_items,
        }
 
        analyzer = analyses.get(analysis_type, self._comprehensive_analysis)
        return analyzer(document)
 
    def _comprehensive_analysis(self, document: str) -> Dict:
        """包括的な分析"""
        response = self.client.messages.create(
            model=self.model,
            max_tokens=4096,
            system="ドキュメントアナリストとして分析してください。",
            messages=[{
                "role": "user",
                "content": f"""以下のドキュメントを包括的に分析し、JSON形式で出力してください。
 
<document>
{document}
</document>
 
出力形式:
{{
    "title": "ドキュメントのタイトル/主題",
    "summary": "200字以内の要約",
    "key_points": ["要点1", "要点2", ...],
    "risks": ["リスク1", "リスク2", ...],
    "action_items": ["アクション1", "アクション2", ...],
    "sentiment": "positive/neutral/negative",
    "confidence": 0.0-1.0,
    "topics": ["トピック1", "トピック2", ...],
    "questions": ["追加調査が必要な点1", ...]
}}"""
            }]
        )
 
        try:
            return json.loads(response.content[0].text)
        except json.JSONDecodeError:
            return {"raw_analysis": response.content[0].text}
 
    def compare_documents(self, doc1: str, doc2: str) -> Dict:
        """2つのドキュメントの比較分析"""
        response = self.client.messages.create(
            model=self.model,
            max_tokens=4096,
            messages=[{
                "role": "user",
                "content": f"""以下の2つのドキュメントを比較分析してください。
 
<document_1>
{doc1}
</document_1>
 
<document_2>
{doc2}
</document_2>
 
比較観点:
1. 共通点
2. 相違点
3. 矛盾する内容
4. 一方にのみ含まれる情報
5. 推奨事項"""
            }]
        )
        return {"comparison": response.content[0].text}

from dataclasses import dataclass
from typing import List
 
@dataclass
class CostEstimate:
    model: str
    input_tokens: int
    output_tokens: int
    cost_usd: float
 
class ClaudeCostOptimizer:
    """Claude の利用コストを最適化する"""
 
    PRICING = {
        "haiku": {"input": 0.80, "output": 4.00, "cache_read": 0.08},
        "sonnet": {"input": 3.00, "output": 15.00, "cache_read": 0.30},
        "opus": {"input": 15.00, "output": 75.00, "cache_read": 1.50},
    }
 
    @classmethod
    def estimate_cost(
        cls,
        model: str,
        input_tokens: int,
        output_tokens: int,
        cache_read_tokens: int = 0,
        batch: bool = False,
    ) -> CostEstimate:
        """コスト概算"""
        pricing = cls.PRICING[model]
        batch_discount = 0.5 if batch else 1.0
 
        input_cost = (input_tokens / 1_000_000) * pricing["input"] * batch_discount
        output_cost = (output_tokens / 1_000_000) * pricing["output"] * batch_discount
        cache_cost = (cache_read_tokens / 1_000_000) * pricing["cache_read"]
 
        total = input_cost + output_cost + cache_cost
 
        return CostEstimate(
            model=model,
            input_tokens=input_tokens,
            output_tokens=output_tokens,
            cost_usd=total,
        )
 
    @classmethod
    def compare_models(
        cls,
        input_tokens: int,
        output_tokens: int,
        requests_per_day: int = 1000,
    ) -> List[CostEstimate]:
        """モデル間のコスト比較"""
        results = []
        for model in ["haiku", "sonnet", "opus"]:
            estimate = cls.estimate_cost(model, input_tokens, output_tokens)
            daily_cost = estimate.cost_usd * requests_per_day
            monthly_cost = daily_cost * 30
            results.append({
                "model": model,
                "per_request": f"${estimate.cost_usd:.4f}",
                "daily": f"${daily_cost:.2f}",
                "monthly": f"${monthly_cost:.2f}",
            })
            print(f"{model:>8}: ${estimate.cost_usd:.4f}/req, "
                  f"${daily_cost:.2f}/day, ${monthly_cost:.2f}/month")
        return results
 
# コスト比較
print("=== 1000入力/500出力トークンのコスト比較 ===")
print(f"(1日1000リクエスト想定)")
ClaudeCostOptimizer.compare_models(1000, 500, 1000)
 
print("\n=== プロンプトキャッシュの効果 ===")
# キャッシュなし
no_cache = ClaudeCostOptimizer.estimate_cost("sonnet", 50000, 500)
# キャッシュあり（90%がキャッシュヒット）
with_cache = ClaudeCostOptimizer.estimate_cost(
    "sonnet", 5000, 500, cache_read_tokens=45000
)
print(f"キャッシュなし: ${no_cache.cost_usd:.4f}")
print(f"キャッシュあり: ${with_cache.cost_usd:.4f}")
print(f"節約率: {(1 - with_cache.cost_usd/no_cache.cost_usd)*100:.1f}%")

# NG: エラーハンドリングなし
response = client.messages.create(...)
 
# OK: 適切なリトライとフォールバック
import anthropic
from tenacity import retry, stop_after_attempt, wait_exponential
 
@retry(
    stop=stop_after_attempt(3),
    wait=wait_exponential(multiplier=1, min=1, max=10),
    retry=lambda e: isinstance(e, (
        anthropic.RateLimitError,
        anthropic.InternalServerError,
        anthropic.APIConnectionError,
    ))
)
def safe_call(messages, model="claude-sonnet-4-20250514"):
    try:
        return client.messages.create(
            model=model,
            max_tokens=2048,
            messages=messages,
        )
    except anthropic.BadRequestError as e:
        # トークン制限超過等 → フォールバック
        print(f"BadRequest: {e}")
        return None

# 演習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()