构建含多公式的复杂字典的最佳实践方案咨询

Great question! When you're building a large dictionary with 50+ calculated fields, separating the computation logic from the dictionary assembly is a smart move—it makes your code way more maintainable and easier to debug. Let’s walk through a few clean approaches that solve this problem:

1. Use a Calculation Rule Map (Recommended) #

This approach centralizes all your computation logic in a single dictionary of rules, then generates the final output by iterating over these rules. It completely decouples "how to calculate each field" from "how to build the output dict."

def produce_dict(cost_dict, revenue_dict, date):
    # Define calculation rules: key = output field name, value = function to compute the value
    calculation_rules = {
        'pnl': lambda: revenue_dict.get('revenue') - cost_dict.get('cost'),
        'pnl_usd': lambda: calculation_rules['pnl']() * get_fx_rate(date),
        'pnl_eur': lambda: calculation_rules['pnl']() * get_eur_fx_rate(date),
        'ytd': lambda: revenue_dict.get('revenue_ytd') - cost_dict.get('cost_ytd'),
        'ytd_usd': lambda: calculation_rules['ytd']() * get_fx_rate(date),
        'ytd_eur': lambda: calculation_rules['ytd']() * get_eur_fx_rate(date),
        'mtd': lambda: revenue_dict.get('revenue_mtd') - cost_dict.get('cost_mtd'),
        'mtd_eur': lambda: calculation_rules['mtd']() * get_eur_fx_rate(date),
        'daily_pnl_gain': lambda: (calculation_rules['mtd']() * get_fx_rate(date)) - (calculation_rules['mtd']() * get_fx_rate(date - 1)),
        'cost': lambda: [
            {'prod_1': {'labour': cost_dict.get('prod_1_labour'), 'material': cost_dict.get('prod_1_material')}},
            {'prod_2': {'labour': cost_dict.get('prod_2_labour'), 'material': cost_dict.get('prod_2_material')}}
        ]
        # Add all other 50+ fields here as key-value rule pairs
    }

    # Build the output dict by evaluating each rule
    output = {field: calc_func() for field, calc_func in calculation_rules.items()}
    return output

Benefits: #

• Full separation: All computation logic lives in calculation_rules, and the dict construction is a single, reusable loop.
• Easy maintenance: Adding/removing fields only requires updating the rules dict—no need to touch the dict-building code.
• Reusable calculations: You can reference previously defined rules (like calculation_rules['pnl']()) to avoid redundant math.

2. Use a Dataclass as an Intermediate Layer #

If you prefer structured, type-safe code, use a dataclass to store your calculated values first, then convert it to a dictionary automatically. This keeps your calculation logic organized and eliminates manual dict construction.

from dataclasses import dataclass, asdict

@dataclass
class FinancialMetrics:
    pnl: float
    pnl_usd: float
    pnl_eur: float
    ytd: float
    ytd_usd: float
    ytd_eur: float
    mtd: float
    mtd_eur: float
    daily_pnl_gain: float
    cost: list[dict]
    # Define all other 50+ fields here with their types

def produce_dict(cost_dict, revenue_dict, date):
    # Calculate core values once to avoid repetition
    pnl = revenue_dict.get('revenue') - cost_dict.get('cost')
    ytd = revenue_dict.get('revenue_ytd') - cost_dict.get('cost_ytd')
    mtd = revenue_dict.get('revenue_mtd') - cost_dict.get('cost_mtd')
    fx_rate = get_fx_rate(date)
    eur_fx_rate = get_eur_fx_rate(date)

    # Populate the dataclass with calculated values
    metrics = FinancialMetrics(
        pnl=pnl,
        pnl_usd=pnl * fx_rate,
        pnl_eur=pnl * eur_fx_rate,
        ytd=ytd,
        ytd_usd=ytd * fx_rate,
        ytd_eur=ytd * eur_fx_rate,
        mtd=mtd,
        mtd_eur=mtd * eur_fx_rate,
        daily_pnl_gain=(mtd * fx_rate) - (mtd * get_fx_rate(date - 1)),
        cost=[
            {'prod_1': {'labour': cost_dict.get('prod_1_labour'), 'material': cost_dict.get('prod_1_material')}},
            {'prod_2': {'labour': cost_dict.get('prod_2_labour'), 'material': cost_dict.get('prod_2_material')}}
        ]
        # Fill in all other fields here
    )

    # Convert dataclass to dict and return
    return asdict(metrics)

Benefits: #

• Type safety: The dataclass enforces field types, which helps catch bugs early (especially with IDE support).
• Clean organization: Calculations are grouped by the dataclass fields, making it easy to track which values feed into which outputs.
• Auto dict conversion: asdict() handles the heavy lifting of turning your structured data into a dictionary.

3. Modularize Calculations into Helper Functions #

For complex computations that need to be tested independently, split your logic into small, single-responsibility helper functions. Then call these functions directly when building your output dict.

# Helper functions for specific calculations
def calculate_pnl(revenue_dict, cost_dict):
    return revenue_dict.get('revenue') - cost_dict.get('cost')

def calculate_metric_in_usd(metric_value, date):
    return metric_value * get_fx_rate(date)

def calculate_cost_breakdown(cost_dict):
    return [
        {'prod_1': {'labour': cost_dict.get('prod_1_labour'), 'material': cost_dict.get('prod_1_material')}},
        {'prod_2': {'labour': cost_dict.get('prod_2_labour'), 'material': cost_dict.get('prod_2_material')}}
    ]

# Add other helper functions for YTD, MTD, EUR conversions, etc.

def produce_dict(cost_dict, revenue_dict, date):
    pnl = calculate_pnl(revenue_dict, cost_dict)
    ytd = calculate_pnl(revenue_dict, cost_dict)  # Replace with dedicated YTD function if needed
    mtd = calculate_pnl(revenue_dict, cost_dict)  # Replace with dedicated MTD function if needed

    return {
        'pnl': pnl,
        'pnl_usd': calculate_metric_in_usd(pnl, date),
        'pnl_eur': pnl * get_eur_fx_rate(date),
        'ytd': ytd,
        'ytd_usd': calculate_metric_in_usd(ytd, date),
        'ytd_eur': ytd * get_eur_fx_rate(date),
        'mtd': mtd,
        'mtd_eur': mtd * get_eur_fx_rate(date),
        'daily_pnl_gain': calculate_metric_in_usd(mtd, date) - calculate_metric_in_usd(mtd, date - 1),
        'cost': calculate_cost_breakdown(cost_dict)
        # Call other helper functions for remaining fields
    }

Benefits: #

• Testability: Each helper function can be unit-tested independently, ensuring your calculations are correct.
• Reusability: Helper functions can be reused across other parts of your codebase if needed.
• Readability: The output dict clearly shows which function generates each field, making the code self-documenting.

内容的提问来源于stack exchange，提问作者Can Lu