# 示例：多參數(shù)函數(shù)在回調(diào)場景中的問題
def data_processor(data, config, threshold, verbose=False):
    """復雜的數(shù)據(jù)處理函數(shù)"""
    if verbose:
        print(f"處理數(shù)據(jù)，閾值: {threshold}")
    # 處理邏輯...
    return processed_data

# 但回調(diào)接口只允許單參數(shù)函數(shù)
def callback_handler(result):
    """只能接受一個參數(shù)的回調(diào)函數(shù)"""
    print(f"處理結果: {result}")

# 問題：如何將data_processor適配到callback_handler的調(diào)用約定？

from functools import partial

new_func = partial(original_func, *args, **kwargs)

from functools import partial

# 原始函數(shù)
def power(base, exponent):
    """計算base的exponent次方"""
    return base ** exponent

# 使用partial創(chuàng)建特化函數(shù)
square = partial(power, exponent=2)  # 固定exponent為2
cube = partial(power, exponent=3)    # 固定exponent為3

# 調(diào)用新函數(shù)
print(square(5))  # 輸出: 25 (計算5的平方)
print(cube(3))    # 輸出: 27 (計算3的立方)

# partial也支持固定多個參數(shù)
power_of_2 = partial(power, 2)  # 固定base為2
print(power_of_2(3))  # 輸出: 8 (計算2的3次方)

from functools import partial

def example_func(a, b, c, d=10, e=20):
    return a + b + c + d + e

# 各種固定方式
func1 = partial(example_func, 1)          # 固定a=1
func2 = partial(example_func, 1, 2)      # 固定a=1, b=2  
func3 = partial(example_func, d=100)      # 固定d=100
func4 = partial(example_func, 1, e=50)    # 固定a=1, e=50

print(func1(2, 3))        # 等效于example_func(1, 2, 3)
print(func2(3))           # 等效于example_func(1, 2, 3)
print(func3(1, 2, 3))     # 等效于example_func(1, 2, 3, d=100)
print(func4(2, 3))        # 等效于example_func(1, 2, 3, e=50)

from functools import partial

# 復雜的數(shù)據(jù)點距離計算函數(shù)
def distance(point1, point2, metric='euclidean', scale=1.0):
    """計算兩點距離，支持多種度量方式"""
    x1, y1 = point1
    x2, y2 = point2
    
    if metric == 'euclidean':
        dist = ((x2 - x1)**2 + (y2 - y1)**2) ** 0.5
    elif metric == 'manhattan':
        dist = abs(x2 - x1) + abs(y2 - y1)
    else:
        raise ValueError(f"不支持的度量方式: {metric}")
    
    return dist * scale

# 點列表
points = [(1, 2), (3, 4), (5, 6), (7, 8)]
reference_point = (4, 3)

# 使用partial創(chuàng)建特化的距離函數(shù)
euclidean_dist = partial(distance, reference_point, metric='euclidean')
manhattan_dist = partial(distance, reference_point, metric='manhattan')
scaled_dist = partial(distance, reference_point, metric='euclidean', scale=2.0)

# 按不同度量排序
points_by_euclidean = sorted(points, key=euclidean_dist)
points_by_manhattan = sorted(points, key=manhattan_dist)

print("按歐氏距離排序:", points_by_euclidean)
print("按曼哈頓距離排序:", points_by_manhattan)

# 過濾遠離參考點的點
from math import sqrt
far_points = [p for p in points if euclidean_dist(p) > sqrt(2)]
print("遠離參考點的點:", far_points)

from functools import partial
import logging

def complex_callback(data, config, logger=None, threshold=0.5):
    """復雜的回調(diào)函數(shù)，需要多個參數(shù)"""
    if logger:
        logger.info(f"處理數(shù)據(jù)，閾值: {threshold}")
    
    # 處理邏輯
    result = [x for x in data if x > threshold]
    
    if logger:
        logger.debug(f"處理結果: {result}")
    
    return result

# 簡化回調(diào)函數(shù)供框架使用
def setup_callbacks():
    """配置回調(diào)函數(shù)供事件框架使用"""
    logger = logging.getLogger('app')
    config = {'mode': 'strict', 'timeout': 30}
    
    # 使用partial創(chuàng)建適合框架的回調(diào)函數(shù)
    simple_callback = partial(complex_callback, 
                             config=config, 
                             logger=logger, 
                             threshold=0.8)
    
    # 現(xiàn)在simple_callback只需要data參數(shù)，符合框架要求
    return simple_callback

# 模擬框架使用
callback = setup_callbacks()
result = callback([0.1, 0.6, 0.9, 0.4, 0.7])
print("回調(diào)結果:", result)

from functools import partial

def create_processor_factory():
    """創(chuàng)建數(shù)據(jù)處理器工廠"""
    
    # 基礎處理函數(shù)
    def process_data(data, operation, factor=1, validation=True):
        """通用數(shù)據(jù)處理函數(shù)"""
        if validation and not all(isinstance(x, (int, float)) for x in data):
            raise ValueError("數(shù)據(jù)必須為數(shù)值類型")
        
        if operation == 'scale':
            return [x * factor for x in data]
        elif operation == 'shift':
            return [x + factor for x in data]
        elif operation == 'normalize':
            max_val = max(data) if data else 1
            return [x / max_val * factor for x in data]
        else:
            raise ValueError(f"不支持的操作: {operation}")
    
    # 使用partial創(chuàng)建特定處理器
    processors = {
        'scaler': partial(process_data, operation='scale'),
        'shifter': partial(process_data, operation='shift'),
        'normalizer': partial(process_data, operation='normalize')
    }
    
    return processors

# 使用函數(shù)工廠
factory = create_processor_factory()

# 創(chuàng)建具體的處理器
double_scaler = partial(factory['scaler'], factor=2)
increment_shifter = partial(factory['shifter'], factor=1)
unit_normalizer = partial(factory['normalizer'], factor=1)

# 使用處理器
data = [1, 2, 3, 4, 5]
print("加倍:", double_scaler(data))        # [2, 4, 6, 8, 10]
print("加一:", increment_shifter(data))    # [2, 3, 4, 5, 6]
print("歸一化:", unit_normalizer(data))    # [0.2, 0.4, 0.6, 0.8, 1.0]

from functools import partial

def complex_operation(a, b, c, d=10, e=20):
    return a + b + c + d + e

# 使用partial
func_partial = partial(complex_operation, 1, 2, d=100)

# 使用lambda
func_lambda = lambda c, e=20: complex_operation(1, 2, c, d=100, e=e)

# 測試功能等價性
test_args = (3, 30)
print("partial結果:", func_partial(*test_args))  # 1+2+3+100+30=136
print("lambda結果:", func_lambda(*test_args))    # 1+2+3+100+30=136

# 但兩者有重要區(qū)別：

from functools import partial, wraps

def configurable_decorator(*args, **kwargs):
    """可配置的裝飾器工廠"""
    def actual_decorator(func):
        @wraps(func)
        def wrapper(*inner_args, **inner_kwargs):
            # 使用partial固定配置參數(shù)
            configured_func = partial(func, *args, **kwargs)
            return configured_func(*inner_args, **inner_kwargs)
        return wrapper
    return actual_decorator

# 使用可配置裝飾器
@configurable_decorator(prefix="結果: ", verbose=True)
def process_data(data, prefix="", verbose=False):
    """數(shù)據(jù)處理函數(shù)"""
    if verbose:
        print(f"處理數(shù)據(jù): {data}")
    return prefix + str(sorted(data))

# 測試
result = process_data([3, 1, 4, 1, 5])
print(result)  # 輸出: 結果: [1, 1, 3, 4, 5]

# 等效的partial使用
def process_data_plain(data, prefix="", verbose=False):
    if verbose:
        print(f"處理數(shù)據(jù): {data}")
    return prefix + str(sorted(data))

manual_result = partial(process_data_plain, prefix="結果: ", verbose=True)([3, 1, 4, 1, 5])
print(manual_result)

import tkinter as tk
from functools import partial

class Application:
    def __init__(self):
        self.root = tk.Tk()
        self.root.title("Partial函數(shù)示例")
        self.value = 0
        
        self.create_widgets()
    
    def create_widgets(self):
        """創(chuàng)建界面組件"""
        # 沒有使用partial的繁瑣方式
        # button1 = tk.Button(self.root, text="方法1", 
        #                    command=lambda: self.update_value(1, "按鈕1"))
        
        # 使用partial的清晰方式
        button1 = tk.Button(self.root, text="加1", 
                           command=partial(self.update_value, 1, "按鈕1"))
        button1.pack(pady=5)
        
        button5 = tk.Button(self.root, text="加5", 
                           command=partial(self.update_value, 5, "按鈕5"))
        button5.pack(pady=5)
        
        button10 = tk.Button(self.root, text="加10", 
                            command=partial(self.update_value, 10, "按鈕10"))
        button10.pack(pady=5)
        
        self.label = tk.Label(self.root, text="值: 0")
        self.label.pack(pady=10)
        
        reset_btn = tk.Button(self.root, text="重置", 
                             command=partial(self.update_value, 0, "重置按鈕", True))
        reset_btn.pack(pady=5)
    
    def update_value(self, increment, source, reset=False):
        """更新值的方法"""
        if reset:
            self.value = 0
        else:
            self.value += increment
        
        self.label.config(text=f"值: {self.value} (最后操作: {source})")
        print(f"值更新為 {self.value}, 來源: {source}")

# 運行應用
if __name__ == "__main__":
    app = Application()
    app.root.mainloop()

from functools import partial
import math

def create_data_pipeline():
    """創(chuàng)建數(shù)據(jù)處理管道"""
    
    # 基礎數(shù)據(jù)處理函數(shù)
    def filter_data(data, condition_fn):
        return [x for x in data if condition_fn(x)]
    
    def transform_data(data, transform_fn):
        return [transform_fn(x) for x in data]
    
    def aggregate_data(data, aggregate_fn):
        return aggregate_fn(data)
    
    # 使用partial創(chuàng)建特定的處理函數(shù)
    # 過濾器
    positive_filter = partial(filter_data, condition_fn=lambda x: x > 0)
    even_filter = partial(filter_data, condition_fn=lambda x: x % 2 == 0)
    range_filter = partial(filter_data, condition_fn=lambda x: 0 <= x <= 100)
    
    # 轉(zhuǎn)換器
    square_transform = partial(transform_data, transform_fn=lambda x: x**2)
    log_transform = partial(transform_data, transform_fn=lambda x: math.log(x) if x > 0 else 0)
    normalize_transform = partial(transform_data, transform_fn=lambda x: x/100)
    
    # 聚合器
    sum_aggregate = partial(aggregate_data, aggregate_fn=sum)
    avg_aggregate = partial(aggregate_data, aggregate_fn=lambda x: sum(x)/len(x) if x else 0)
    max_aggregate = partial(aggregate_data, aggregate_fn=max)
    
    return {
        'filters': {
            'positive': positive_filter,
            'even': even_filter,
            'range': range_filter
        },
        'transforms': {
            'square': square_transform,
            'log': log_transform,
            'normalize': normalize_transform
        },
        'aggregates': {
            'sum': sum_aggregate,
            'average': avg_aggregate,
            'max': max_aggregate
        }
    }

# 使用數(shù)據(jù)管道
pipeline = create_data_pipeline()
data = [-5, 2, 7, -3, 10, 15, 8, -1, 6]

# 構建處理流程
result = pipeline['filters']['positive'](data)      # 過濾正數(shù)
result = pipeline['transforms']['square'](result)   # 平方變換
result = pipeline['aggregates']['average'](result)  # 求平均值

print(f"原始數(shù)據(jù): {data}")
print(f"處理結果: {result}")

# 可以輕松組合不同的處理流程
alternative_flow = pipeline['aggregates']['sum'](
    pipeline['transforms']['log'](
        pipeline['filters']['range'](data)
    )
)
print(f"替代流程結果: {alternative_flow}")

from functools import partial
import requests

class APIClient:
    def __init__(self, base_url, default_timeout=30, default_headers=None):
        self.base_url = base_url
        self.default_timeout = default_timeout
        self.default_headers = default_headers or {}
        
        # 使用partial預設常用參數(shù)
        self.get = partial(self._request, method='GET')
        self.post = partial(self._request, method='POST')
        self.put = partial(self._request, method='PUT')
        self.delete = partial(self._request, method='DELETE')
    
    def _request(self, endpoint, method='GET', params=None, data=None, 
                 headers=None, timeout=None):
        """基礎請求方法"""
        url = f"{self.base_url}/{endpoint}"
        final_headers = {**self.default_headers, **(headers or {})}
        final_timeout = timeout or self.default_timeout
        
        response = requests.request(
            method=method,
            url=url,
            params=params,
            json=data,
            headers=final_headers,
            timeout=final_timeout
        )
        
        response.raise_for_status()
        return response.json()
    
    def with_options(self, **kwargs):
        """創(chuàng)建帶有特定選項的客戶端版本"""
        return partial(self._request, **kwargs)

# 使用API客戶端
def main():
    # 創(chuàng)建客戶端
    client = APIClient(
        base_url="https://api.example.com",
        default_headers={'Authorization': 'Bearer token123'},
        default_timeout=60
    )
    
    # 使用預設方法
    users = client.get("users")  # 只需要endpoint參數(shù)
    new_user = client.post("users", data={"name": "John"})
    
    # 創(chuàng)建特化版本
    fast_client = client.with_options(timeout=5)
    slow_client = client.with_options(timeout=120)
    
    # 特化客戶端使用
    quick_status = fast_client("status")
    large_data = slow_client("reports", method='POST', data=large_payload)
    
    # 進一步特化
    upload_file = partial(client.post, "upload", headers={'Content-Type': 'multipart/form-data'})
    upload_result = upload_file(data=file_data)

if __name__ == "__main__":
    main()

from functools import partial

# 好的實踐
def create_calculator(operations):
    """創(chuàng)建計算器工廠"""
    
    def calculate(a, b, operation):
        if operation == 'add':
            return a + b
        elif operation == 'subtract':
            return a - b
        elif operation == 'multiply':
            return a * b
        elif operation == 'divide':
            return a / b if b != 0 else float('inf')
        else:
            raise ValueError(f"未知操作: {operation}")
    
    # 使用partial創(chuàng)建特定操作函數(shù)
    add = partial(calculate, operation='add')          # 好的命名
    subtract = partial(calculate, operation='subtract')
    multiply = partial(calculate, operation='multiply')
    divide = partial(calculate, operation='divide')
    
    return {
        'add': add,
        'subtract': subtract, 
        'multiply': multiply,
        'divide': divide
    }

# 差的實踐：命名不清晰
calc = partial(calculate, operation='add')  # 無法從名字知道用途

from functools import partial
import timeit

def original_func(a, b, c, d):
    return a + b + c + d

# 創(chuàng)建partial函數(shù)
partial_func = partial(original_func, 1, 2)

# 性能測試
def test_original():
    return original_func(1, 2, 3, 4)

def test_partial():
    return partial_func(3, 4)

def test_lambda():
    func = lambda c, d: original_func(1, 2, c, d)
    return func(3, 4)

# 測試性能
original_time = timeit.timeit(test_original, number=100000)
partial_time = timeit.timeit(test_partial, number=100000)
lambda_time = timeit.timeit(test_lambda, number=100000)

print(f"原始函數(shù): {original_time:.4f}秒")
print(f"Partial函數(shù): {partial_time:.4f}秒") 
print(f"Lambda函數(shù): {lambda_time:.4f}秒")

# 通常結果：partial比lambda稍快，兩者都比直接調(diào)用稍慢

from functools import partial

def safe_partial(func, *args, **kwargs):
    """帶錯誤檢查的partial包裝器"""
    try:
        return partial(func, *args, **kwargs)
    except TypeError as e:
        raise ValueError(f"參數(shù)不匹配: {e}") from e

def robust_function(a, b, c=10):
    """示例函數(shù)"""
    if not all(isinstance(x, (int, float)) for x in [a, b, c]):
        raise TypeError("參數(shù)必須為數(shù)值")
    return a + b + c

# 安全使用partial
try:
    safe_add = safe_partial(robust_function, 1, 2)
    result = safe_add(3)
    print(f"結果: {result}")
    
    # 這會引發(fā)錯誤
    invalid_partial = safe_partial(robust_function, "invalid", 2)
except ValueError as e:
    print(f"錯誤: {e}")

# 添加類型檢查
def typed_partial(func, *args, **kwargs):
    """添加類型提示的partial"""
    partial_func = partial(func, *args, **kwargs)
    
    # 保存原始函數(shù)信息用于調(diào)試
    partial_func._original_func = func
    partial_func._bound_args = args
    partial_func._bound_kwargs = kwargs
    
    return partial_func

# 使用帶調(diào)試信息的partial
debug_func = typed_partial(robust_function, 1, c=20)
print(f"原始函數(shù): {debug_func._original_func.__name__}")
print(f"綁定參數(shù): {debug_func._bound_args}")
print(f"綁定關鍵字參數(shù): {debug_func._bound_kwargs}")