def calculate_statistics(numbers):
    """計(jì)算一組數(shù)字的統(tǒng)計(jì)指標(biāo)"""
    total = sum(numbers)
    count = len(numbers)
    average = total / count if count > 0 else 0
    maximum = max(numbers) if numbers else 0
    minimum = min(numbers) if numbers else 0
    
    # 返回多個(gè)值作為元組
    return total, count, average, maximum, minimum

# 調(diào)用函數(shù)并解包返回值
data = [10, 20, 30, 40, 50]
total, count, avg, max_val, min_val = calculate_statistics(data)

print(f"總和: {total}, 數(shù)量: {count}, 平均值: {avg:.2f}")
print(f"最大值: {max_val}, 最小值: {min_val}")

# 也可以直接接收元組
result = calculate_statistics(data)
print(f"完整結(jié)果: {result}")  # 輸出: (150, 5, 30.0, 50, 10)

def process_data_points(raw_data):
    """處理數(shù)據(jù)點(diǎn)，返回多個(gè)列表"""
    valid_data = [x for x in raw_data if x is not None]
    outliers = [x for x in raw_data if x is not None and (x < 0 or x > 100)]
    normalized_data = [(x - min(valid_data)) / (max(valid_data) - min(valid_data)) 
                      for x in valid_data] if valid_data else []
    
    # 返回多個(gè)列表
    return valid_data, outliers, normalized_data

# 使用示例
input_data = [5, 15, None, 25, 35, 105, 45]
valid, outliers, normalized = process_data_points(input_data)

print(f"有效數(shù)據(jù): {valid}")      # 輸出: [5, 15, 25, 35, 105, 45]
print(f"異常值: {outliers}")     # 輸出: [105]
print(f"歸一化數(shù)據(jù): {normalized}")

# 列表返回的值可以修改
valid.append(55)
print(f"修改后有效數(shù)據(jù): {valid}")

def analyze_text(text):
    """分析文本特征，返回多個(gè)統(tǒng)計(jì)指標(biāo)"""
    if not text:
        return {}
    
    words = text.split()
    characters = len(text)
    sentences = text.count('.') + text.count('!') + text.count('?')
    unique_words = len(set(words))
    
    # 返回字典，每個(gè)值都有明確的標(biāo)簽
    return {
        'word_count': len(words),
        'character_count': characters,
        'sentence_count': sentences,
        'unique_words': unique_words,
        'average_word_length': characters / len(words) if words else 0,
        'most_common_word': max(set(words), key=words.count) if words else None
    }

# 使用示例
sample_text = "Python是一種強(qiáng)大的編程語(yǔ)言。Python易于學(xué)習(xí)且功能強(qiáng)大!"
stats = analyze_text(sample_text)

print("文本分析結(jié)果:")
for key, value in stats.items():
    print(f"{key}: {value}")

# 直接訪問(wèn)特定值
print(f"單詞數(shù)量: {stats['word_count']}")
print(f"平均單詞長(zhǎng)度: {stats['average_word_length']:.2f}")

from collections import namedtuple

# 定義命名元組類(lèi)型
Statistics = namedtuple('Statistics', ['total', 'count', 'average', 'maximum', 'minimum'])

def calculate_detailed_stats(numbers):
    """計(jì)算詳細(xì)統(tǒng)計(jì)信息"""
    if not numbers:
        return Statistics(0, 0, 0, 0, 0)
    
    total = sum(numbers)
    count = len(numbers)
    average = total / count
    maximum = max(numbers)
    minimum = min(numbers)
    
    return Statistics(total, count, average, maximum, minimum)

# 使用示例
data = [10, 20, 30, 40, 50]
stats = calculate_detailed_stats(data)

# 通過(guò)屬性名訪問(wèn)值，代碼可讀性極高
print(f"總和: {stats.total}")
print(f"平均值: {stats.average:.2f}")
print(f"數(shù)據(jù)范圍: {stats.minimum} - {stats.maximum}")

# 命名元組仍然支持元組的所有操作
print(f"前兩個(gè)值: {stats[0]}, {stats[1]}")

# 轉(zhuǎn)換為字典
print(f"字典形式: {stats._asdict()}")

from dataclasses import dataclass
from typing import List, Optional

@dataclass
class AnalysisResult:
    """數(shù)據(jù)分析結(jié)果類(lèi)"""
    valid_count: int
    invalid_count: int
    average_value: float
    values_above_threshold: List[float]
    warning_message: Optional[str] = None  # 可選字段
    
    def summary(self):
        """生成結(jié)果摘要"""
        return f"有效數(shù)據(jù): {self.valid_count}, 平均值: {self.average_value:.2f}"

def analyze_dataset(data, threshold=50):
    """分析數(shù)據(jù)集"""
    valid_data = [x for x in data if x is not None and x >= 0]
    invalid_count = len(data) - len(valid_data)
    
    if not valid_data:
        return AnalysisResult(0, invalid_count, 0, [], "無(wú)有效數(shù)據(jù)")
    
    average = sum(valid_data) / len(valid_data)
    above_threshold = [x for x in valid_data if x > threshold]
    
    warning = None
    if invalid_count > len(valid_data):
        warning = "無(wú)效數(shù)據(jù)過(guò)多"
    
    return AnalysisResult(
        valid_count=len(valid_data),
        invalid_count=invalid_count,
        average_value=average,
        values_above_threshold=above_threshold,
        warning_message=warning
    )

# 使用示例
dataset = [10, 25, None, 60, 75, -5, 45]
result = analyze_dataset(dataset, threshold=30)

print(result)  # 自動(dòng)生成的有用表示
print(result.summary())
print(f"超過(guò)閾值的值: {result.values_above_threshold}")

if result.warning_message:
    print(f"警告: {result.warning_message}")

class FinancialReport:
    """財(cái)務(wù)報(bào)告類(lèi)"""
    
    def __init__(self, revenue, expenses, period):
        self.revenue = revenue
        self.expenses = expenses
        self.period = period
        self.profit = revenue - expenses
        self.margin = self.profit / revenue if revenue > 0 else 0
    
    def get_summary(self):
        """獲取報(bào)告摘要"""
        return {
            'period': self.period,
            'revenue': self.revenue,
            'expenses': self.expenses,
            'profit': self.profit,
            'margin': f"{self.margin:.1%}"
        }
    
    def is_profitable(self):
        """判斷是否盈利"""
        return self.profit > 0
    
    def __str__(self):
        return (f"財(cái)務(wù)報(bào)告({self.period}): "
                f"收入￥{self.revenue:,}, 利潤(rùn)￥{self.profit:,}, "
                f"利潤(rùn)率{self.margin:.1%}")

def generate_quarterly_report(sales_data, cost_data, quarter):
    """生成季度財(cái)務(wù)報(bào)告"""
    total_revenue = sum(sales_data)
    total_expenses = sum(cost_data)
    
    return FinancialReport(total_revenue, total_expenses, quarter)

# 使用示例
q1_sales = [100000, 120000, 110000]
q1_costs = [80000, 85000, 90000]
report = generate_quarterly_report(q1_sales, q1_costs, "2024-Q1")

print(report)
print(f"是否盈利: {report.is_profitable()}")
print("摘要信息:", report.get_summary())

from typing import Tuple, Dict, Any
import statistics

def comprehensive_data_analysis(data: List[float]) -> Dict[str, Any]:
    """執(zhí)行綜合數(shù)據(jù)分析"""
    if not data:
        return {"error": "無(wú)有效數(shù)據(jù)"}
    
    # 計(jì)算多個(gè)統(tǒng)計(jì)指標(biāo)
    cleaned_data = [x for x in data if x is not None]
    n = len(cleaned_data)
    
    if n == 0:
        return {"error": "無(wú)有效數(shù)據(jù)點(diǎn)"}
    
    results = {
        'sample_size': n,
        'mean': statistics.mean(cleaned_data),
        'median': statistics.median(cleaned_data),
        'std_dev': statistics.stdev(cleaned_data) if n > 1 else 0,
        'variance': statistics.variance(cleaned_data) if n > 1 else 0,
        'range': max(cleaned_data) - min(cleaned_data),
        'q1': statistics.quantiles(cleaned_data, n=4)[0] if n >= 4 else None,
        'q3': statistics.quantiles(cleaned_data, n=4)[2] if n >= 4 else None,
    }
    
    # 添加數(shù)據(jù)質(zhì)量信息
    results['original_size'] = len(data)
    results['missing_count'] = len(data) - n
    results['data_quality'] = f"{(n/len(data))*100:.1f}%" if data else "0%"
    
    return results

# 使用示例
experimental_data = [23.5, 24.1, None, 22.8, 25.3, 23.9, None, 24.7]
analysis = comprehensive_data_analysis(experimental_data)

print("數(shù)據(jù)分析結(jié)果:")
for key, value in analysis.items():
    if not key.startswith('_'):  # 跳過(guò)內(nèi)部鍵
        print(f"{key}: {value}")

from typing import TypedDict, Optional

class APIResponse(TypedDict):
    """API響應(yīng)類(lèi)型定義"""
    success: bool
    data: Optional[dict]
    message: str
    status_code: int
    timestamp: str

def process_api_request(endpoint: str, payload: dict) -> APIResponse:
    """處理API請(qǐng)求并返回多個(gè)信息"""
    import time
    from datetime import datetime
    
    try:
        # 模擬API調(diào)用
        if endpoint == "/users":
            # 模擬成功響應(yīng)
            response_data = {
                'users': [{'id': 1, 'name': 'Alice'}, {'id': 2, 'name': 'Bob'}],
                'total_count': 2
            }
            return {
                'success': True,
                'data': response_data,
                'message': '數(shù)據(jù)獲取成功',
                'status_code': 200,
                'timestamp': datetime.now().isoformat()
            }
        else:
            # 模擬錯(cuò)誤響應(yīng)
            return {
                'success': False,
                'data': None,
                'message': f'端點(diǎn)未找到: {endpoint}',
                'status_code': 404,
                'timestamp': datetime.now().isoformat()
            }
    except Exception as e:
        # 模擬異常處理
        return {
            'success': False,
            'data': None,
            'message': f'服務(wù)器錯(cuò)誤: {str(e)}',
            'status_code': 500,
            'timestamp': datetime.now().isoformat()
        }

# 使用示例
response = process_api_request("/users", {"page": 1})

if response['success']:
    print("API調(diào)用成功!")
    print(f"數(shù)據(jù): {response['data']}")
    print(f"時(shí)間: {response['timestamp']}")
else:
    print(f"API調(diào)用失敗: {response['message']}")
    print(f"狀態(tài)碼: {response['status_code']}")

from dataclasses import dataclass
from typing import List, Tuple
import math

@dataclass
class OptimizationResult:
    """優(yōu)化算法結(jié)果"""
    solution: List[float]
    objective_value: float
    iterations: int
    converged: bool
    error_message: str = ""
    history: List[float] = None
    
    def __post_init__(self):
        if self.history is None:
            self.history = []

def gradient_descent(objective_function, initial_point, learning_rate=0.01, max_iters=1000):
    """梯度下降優(yōu)化算法"""
    current_point = initial_point[:]
    history = [objective_function(current_point)]
    converged = False
    
    for i in range(max_iters):
        # 模擬梯度計(jì)算和更新
        gradient = [x * 0.01 for x in current_point]  # 簡(jiǎn)化梯度計(jì)算
        new_point = [current_point[j] - learning_rate * gradient[j] 
                    for j in range(len(current_point))]
        
        current_point = new_point
        current_value = objective_function(current_point)
        history.append(current_value)
        
        # 檢查收斂
        if i > 0 and abs(history[-1] - history[-2]) < 1e-6:
            converged = True
            break
    
    return OptimizationResult(
        solution=current_point,
        objective_value=objective_function(current_point),
        iterations=i + 1,
        converged=converged,
        history=history
    )

# 使用示例
def sphere_function(x):
    """球面測(cè)試函數(shù)"""
    return sum(xi**2 for xi in x)

result = gradient_descent(sphere_function, [2.0, -2.0, 1.5])

print(f"最優(yōu)解: {result.solution}")
print(f"目標(biāo)函數(shù)值: {result.objective_value:.6f}")
print(f"迭代次數(shù): {result.iterations}")
print(f"是否收斂: {result.converged}")
print(f"最終誤差: {abs(result.objective_value):.2e}")

from typing import Union, Tuple
import sys

def safe_divide(a: float, b: float) -> Tuple[bool, Union[float, str]]:
    """安全除法運(yùn)算，返回成功狀態(tài)和結(jié)果"""
    try:
        if b == 0:
            return False, "除數(shù)不能為零"
        result = a / b
        return True, result
    except TypeError as e:
        return False, f"類(lèi)型錯(cuò)誤: {str(e)}"
    except Exception as e:
        return False, f"意外錯(cuò)誤: {str(e)}"

def robust_statistical_calculation(data: List[float]) -> Dict[str, Union[float, str, None]]:
    """健壯的統(tǒng)計(jì)計(jì)算，處理各種邊界情況"""
    if not data:
        return {'error': '數(shù)據(jù)為空', 'result': None}
    
    valid_data = [x for x in data if isinstance(x, (int, float)) and not math.isnan(x)]
    
    if not valid_data:
        return {'error': '無(wú)有效數(shù)值數(shù)據(jù)', 'result': None}
    
    if len(valid_data) == 1:
        return {
            'result': valid_data[0],
            'warning': '數(shù)據(jù)點(diǎn)不足，無(wú)法計(jì)算標(biāo)準(zhǔn)差',
            'mean': valid_data[0],
            'std_dev': None
        }
    
    try:
        mean = statistics.mean(valid_data)
        std_dev = statistics.stdev(valid_data)
        
        return {
            'result': mean,
            'mean': mean,
            'std_dev': std_dev,
            'sample_size': len(valid_data),
            'confidence_interval': (
                mean - 1.96 * std_dev / math.sqrt(len(valid_data)),
                mean + 1.96 * std_dev / math.sqrt(len(valid_data))
            )
        }
    except Exception as e:
        return {'error': f'計(jì)算失敗: {str(e)}', 'result': None}

# 使用示例
success, result = safe_divide(10, 2)
if success:
    print(f"除法結(jié)果: {result}")
else:
    print(f"錯(cuò)誤: {result}")

stats = robust_statistical_calculation([1, 2, 3, "invalid", 4, 5])
print(f"統(tǒng)計(jì)結(jié)果: {stats}")

from typing import Generator
import memory_profiler

def large_data_processing_efficient(data: List[float]) -> Tuple[List[float], Dict[str, float]]:
    """高效處理大數(shù)據(jù)集，優(yōu)化內(nèi)存使用"""
    # 使用生成器表達(dá)式減少內(nèi)存占用
    filtered_data = (x for x in data if x is not None and x > 0)
    
    # 轉(zhuǎn)換為列表并計(jì)算統(tǒng)計(jì)量
    valid_data = list(filtered_data)
    
    # 分批處理大型數(shù)據(jù)集
    batch_size = 1000
    statistics = {}
    
    for i in range(0, len(valid_data), batch_size):
        batch = valid_data[i:i + batch_size]
        batch_stats = {
            'batch_mean': sum(batch) / len(batch),
            'batch_size': len(batch)
        }
        statistics[f'batch_{i//batch_size}'] = batch_stats
    
    # 只返回必要的匯總數(shù)據(jù)
    summary = {
        'total_processed': len(valid_data),
        'overall_mean': sum(valid_data) / len(valid_data) if valid_data else 0,
        'batches_processed': len(statistics)
    }
    
    return valid_data, summary

def memory_efficient_analysis(large_dataset: List[float]) -> Generator[Dict[str, float], None, None]:
    """內(nèi)存高效的分析函數(shù)，使用生成器返回結(jié)果"""
    current_batch = []
    
    for value in large_dataset:
        current_batch.append(value)
        
        # 每處理1000個(gè)值 yield一次結(jié)果
        if len(current_batch) >= 1000:
            batch_result = {
                'mean': sum(current_batch) / len(current_batch),
                'min': min(current_batch),
                'max': max(current_batch),
                'count': len(current_batch)
            }
            yield batch_result
            current_batch = []  # 重置批次
    
    # 處理剩余數(shù)據(jù)
    if current_batch:
        final_result = {
            'mean': sum(current_batch) / len(current_batch),
            'min': min(current_batch),
            'max': max(current_batch),
            'count': len(current_batch)
        }
        yield final_result

# 使用示例
large_data = [float(x) for x in range(10000)]
processed, summary = large_data_processing_efficient(large_data)

print(f"處理了 {summary['total_processed']} 個(gè)數(shù)據(jù)點(diǎn)")
print(f"總體均值: {summary['overall_mean']:.2f}")

# 使用生成器版本節(jié)省內(nèi)存
print("分批處理結(jié)果:")
for i, batch_result in enumerate(memory_efficient_analysis(large_data)):
    if i < 3:  # 只顯示前3批避免輸出過(guò)長(zhǎng)
        print(f"批次 {i}: {batch_result}")

from typing import TypedDict, List, Optional, Tuple
from dataclasses import dataclass

class CalculationResult(TypedDict):
    """計(jì)算結(jié)果類(lèi)型定義"""
    value: float
    precision: float
    units: str
    is_estimated: bool
    confidence_interval: Tuple[float, float]

@dataclass
class ExperimentalMeasurement:
    """實(shí)驗(yàn)測(cè)量結(jié)果"""
    measured_value: float
    uncertainty: float
    instrument_id: str
    timestamp: str
    conditions: Dict[str, Any]
    quality_rating: int
    
    def to_dict(self) -> Dict[str, Any]:
        """轉(zhuǎn)換為字典格式"""
        return {
            'value': self.measured_value,
            'uncertainty': self.uncertainty,
            'quality': self.quality_rating,
            'conditions': self.conditions
        }

def calculate_physical_quantity(
    inputs: List[float], 
    method: str = "standard"
) -> CalculationResult:
    """
    計(jì)算物理量，返回詳細(xì)結(jié)果
    
    Args:
        inputs: 輸入數(shù)據(jù)列表
        method: 計(jì)算方法（"standard" 或 "precise"）
    
    Returns:
        CalculationResult: 包含計(jì)算結(jié)果和元數(shù)據(jù)的字典
        
    Raises:
        ValueError: 當(dāng)輸入數(shù)據(jù)無(wú)效時(shí)
    """
    if not inputs or any(math.isnan(x) for x in inputs):
        raise ValueError("輸入數(shù)據(jù)無(wú)效")
    
    if method == "standard":
        value = statistics.mean(inputs)
        precision = statistics.stdev(inputs) if len(inputs) > 1 else 0.0
    else:  # precise method
        value = statistics.mean(inputs)
        precision = statistics.stdev(inputs) / math.sqrt(len(inputs)) if len(inputs) > 1 else 0.0
    
    # 計(jì)算置信區(qū)間
    n = len(inputs)
    if n > 1 and precision > 0:
        interval = (
            value - 1.96 * precision,
            value + 1.96 * precision
        )
    else:
        interval = (value, value)
    
    return {
        'value': value,
        'precision': precision,
        'units': 'meters',
        'is_estimated': n < 30,
        'confidence_interval': interval
    }

# 使用示例
try:
    measurements = [1.23, 1.25, 1.22, 1.24, 1.26]
    result = calculate_physical_quantity(measurements, "precise")
    
    print(f"測(cè)量結(jié)果: {result['value']:.3f} ± {result['precision']:.3f} {result['units']}")
    print(f"置信區(qū)間: {result['confidence_interval']}")
    print(f"是否為估計(jì)值: {result['is_estimated']}")
    
except ValueError as e:
    print(f"計(jì)算錯(cuò)誤: {e}")