from functools import partial

# 原始函數，假設是一個計算總和的函數，接受三個參數
def calculate_sum(a, b, c):
    return a + b + c

# 創(chuàng)建一個偏函數，預先設定 b 參數為 10
sum_with_b_10 = partial(calculate_sum, b=10)

# 調用偏函數時，只需要提供 a 和 c 參數
result = sum_with_b_10(5, c=15)
print(result)  # 輸出：30

# 因為偏函數 sum_with_b_10 已經預設了 b=10，所以這里不需要顯式地傳遞 b
another_result = sum_with_b_10(7, 8)
print(another_result)  # 輸出：25 （實際上是 7 + 10 + 8）

import math
from functools import partial

# 創(chuàng)建一個只接收一個參數的 sqrt 函數版本，忽略其初始的 domain 參數
sqrt_positive = partial(math.sqrt, domain='real')

# 定義數據
numbers = [16, -9, 4, -1, 9]

# 先過濾出正數，然后對每個正數求平方根
positive_roots = map(sqrt_positive, filter(lambda x: x >= 0, numbers))

# 轉換為列表并打印結果
print(list(positive_roots))  # 輸出：[4.0, 2.0, 3.0]

class MyClass:
    def method(self, x, y):
        return x * y

# 創(chuàng)建一個 MyClass 實例
my_instance = MyClass()

# 使用 functools.partial 將 my_instance.method 方法轉化為一個偏函數，并固定 self 參數
method_partial = partial(my_instance.method, my_instance)

# 現在可以直接調用偏函數并只傳入 x 和 y 參數
result = method_partial(3, 4)
print(result)  # 輸出：12

# 此時 method_partial 相當于執(zhí)行了 my_instance.method(3, 4)

from functools import partial

def original_func(a, b, c=1, d=2):
    """這是一個原始函數的文檔字符串"""
    print(f"a: {a}, b: , c: {c}, d: 5tnfjzl")

# 創(chuàng)建偏函數，并更改默認參數
partially_applied_func = partial(original_func, c=10, d='new_default')

# 偏函數保留了原始函數的 __name__ 和 __doc__
print(partially_applied_func.__name__)  # 輸出：original_func
print(partially_applied_func.__doc__)   # 輸出：這是一個原始函數的文檔字符串

# 調用偏函數
partially_applied_func(3, 4)  # 輸出：a: 3, b: 4, c: 10, d: new_default

from functools import wraps
from functools import partial

# 假設我們有一個日志裝飾器，需要記錄每個函數的執(zhí)行時間
def log_decorator(prefix='', suffix=''):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            start_time = time.time()
            result = func(*args, **kwargs)
            end_time = time.time()
            print(f"{prefix}Function execution time: {end_time - start_time}{suffix}")
            return result
        return wrapper
    return decorator

# 創(chuàng)建一個帶參數的裝飾器實例
log_time_decorator = partial(log_decorator, prefix="[INFO] ", suffix=" seconds\n")

@log_time_decorator
def slow_function(n):
    time.sleep(n)
    return n * n

# 調用函數
slow_function(2)  # 輸出：[INFO] Function execution time: X.XX seconds

import tkinter as tk
from functools import partial

def generic_button_handler(context_info, button_text):
    print(f"The button '{button_text}' was clicked with context: {context_info}")

root = tk.Tk()

# 假設 context_info 是一個需要傳遞給事件處理函數的變量
context_info = {"username": "John Doe"}

# 創(chuàng)建一個預置了 context_info 的偏函數
button_click_handler = partial(generic_button_handler, context_info)

# 創(chuàng)建按鈕并將偏函數綁定為點擊事件的處理函數
button1 = tk.Button(root, text="Button 1")
button1.config(command=partial(button_click_handler, "Button 1"))

button2 = tk.Button(root, text="Button 2")
button2.config(command=partial(button_click_handler, "Button 2"))

button1.pack()
button2.pack()

root.mainloop()

from PyQt5.QtWidgets import QApplication, QPushButton
from PyQt5.QtCore import QObject, pyqtSignal
from functools import partial

class MyObject(QObject):
    signal_clicked = pyqtSignal(str)

    def __init__(self):
        super().__init__()

        self.button = QPushButton("Click me", self)
        self.button.clicked.connect(partial(self.on_button_clicked, "附加信息"))

    def on_button_clicked(self, additional_info, checked):
        print(f"Button clicked! Additional info: {additional_info}")

if __name__ == "__main__":
    app = QApplication([])
    obj = MyObject()
    obj.button.show()
    app.exec_()

import asyncio
from functools import partial

async def handle_event(user_id, event_type, data):
    print(f"Handling event for user {user_id}: {event_type} - {data}")

async def main():
    # 假設 user_id 在整個應用程序生命周期內都是已知的
    user_id = 123

    # 創(chuàng)建一個預置了 user_id 的偏函數
    handle_user_event = partial(handle_event, user_id)

    # 注冊回調函數
    event_dispatcher.register_callback(handle_user_event)

asyncio.run(main())

from concurrent.futures import ThreadPoolExecutor
from functools import partial

def process_data(data, shared_resource):
    # 對 data 進行處理，并可能使用 shared_resource
    processed_data = ...
    return processed_data

# 共享資源
shared_resource = SomeSharedResource()

# 創(chuàng)建一個預置了 shared_resource 參數的偏函數
process_data_with_shared_resource = partial(process_data, shared_resource=shared_resource)

with ThreadPoolExecutor(max_workers=5) as executor:
    future_results = []
    
    # 處理一組數據
    for data in dataset:
        future = executor.submit(process_data_with_shared_resource, data)
        future_results.append(future)

    # 等待所有任務完成并收集結果
    results = [future.result() for future in future_results]

from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from functools import partial

# 假設我們有一個自定義的特征提取函數，它需要一個額外的參數
def custom_feature_extraction(X, extra_param):
    # 根據 extra_param 進行特征提取
    extracted_features = ...
    return extracted_features

# 創(chuàng)建一個預置了 extra_param 的偏函數
extract_features = partial(custom_feature_extraction, extra_param='some_value')

# 構建數據預處理管道
preprocessing_pipeline = Pipeline([
    ('scale', StandardScaler()),  # 對數據進行標準化
    ('extract', extract_features),  # 使用偏函數進行特征提取
])

# 訓練和應用管道
preprocessing_pipeline.fit_transform(data)

import tensorflow as tf
from keras.models import load_model
from functools import partial

# 加載已訓練好的模型
model = load_model('my_model.h5')

# 設定設備為 GPU 并在預測時關閉動態(tài)計算圖
predict_on_gpu = partial(model.predict, steps=1, use_multiprocessing=False, workers=0, 
                         experimental_run_tf_function=False, device='/GPU:0')

# 預測數據
predictions = predict_on_gpu(preprocessed_data)

from sqlalchemy import create_engine, Table, Column, Integer, String
from sqlalchemy.orm import sessionmaker
from functools import partial

# 假設我們有一個 User 表
Base = declarative_base()
class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    role = Column(String)

# 初始化數據庫引擎及 Session
engine = create_engine('sqlite:///example.db')
Session = sessionmaker(bind=engine)

# 創(chuàng)建一個只查找角色為 'admin' 的用戶的部分查詢函數
find_admins = partial(User.query.filter_by, role='admin')

# 后續(xù)使用時，只需傳遞其他變動的查詢條件
session = Session()
admins_named_john = session.execute(find_admins(name='John')).scalars().all()

from flask import Flask, render_template, url_for, request
from functools import partial

app = Flask(__name__)

# 假設有一個需要用戶登錄后才能訪問的通用視圖函數
def authenticated_view(user_id, template_name):
    @app.route('/authenticated/<int:user_id>')
    def view(user_id=user_id):
        # 獲取用戶信息并渲染模板
        user = get_user_info(user_id)
        return render_template(template_name, user=user)

# 使用偏函數預設用戶ID和模板名稱
admin_view = partial(authenticated_view, user_id=1, template_name='admin.html')

# 注冊偏函數作為視圖
app.add_url_rule('/admin', endpoint='admin', view_func=admin_view)

# 啟動應用
if __name__ == '__main__':
    app.run()

from flask import Flask
from functools import partial

app = Flask(__name__)

# 定義一個預設了 URL 規(guī)則的偏函數
admin_route = partial(app.route, '/admin')

@admin_route('/users')
def admin_users():
    return "Admin users page"

@admin_route('/settings')
def admin_settings():
    return "Admin settings page"

if __name__ == '__main__':
    app.run()

def send_request(url, method='GET', headers=None, body=None):
    # 實現具體的請求邏輯...
    pass

api_post_headers = {'Content-Type': 'application/json'}
post_to_api = partial(send_request, method='POST', headers=api_post_headers)

# 現在可以直接這樣調用：
response = post_to_api('https://example.com/api/data')