Python中向字典添加多变量的高效方法及代码优化咨询

Hey there! I see you're looking to clean up that repeated update() pattern in your Python code for calculating support moments—great call, since those multiple dictionary updates aren't just verbose, they also add unnecessary overhead. Let's go through a few more efficient and readable approaches:

1. Directly Build the Full Dictionary (Simplest Fix) #

Instead of creating tiny dictionaries and calling update() five times, you can construct the final force dictionary in one go. This cuts down on redundant operations and makes the code much cleaner at a glance.

Here's the refactored version:

import math

def momentEndSpan(span_type, max_combo, length):
    q = max_combo
    if span_type == "simply supported":
        return {
            "PA": q * length / 2,
            "PB": q * length / 2,
            "MA": 0,
            "Mmid": (q * math.pow(length, 2)) / 8,
            "MB": 0
        }
    elif span_type == "one end continuous":
        return {
            "Phinge": 3 * q * length / 8,
            "Pfixed": 5 * q * length / 8,
            "Mhinge": 0,
            "Mmid": (q * math.pow(length, 2)) * (9 / 128),
            "MB": -1 * (q * math.pow(length, 2)) / 8
        }

This approach keeps the dictionary output you're used to, but eliminates all those repetitive update() calls. It's faster because we're only creating one dictionary per branch instead of six (five small ones plus the main force dict).

2. Use a Data Class (Structured, Type-Safe Output) #

If you want more structure than a dictionary (and easier attribute access later), using a dataclass is a fantastic option. It makes your code self-documenting, and you'll avoid typos from misspelling dictionary keys.

First, import dataclasses, then define a class for your results:

import math
from dataclasses import dataclass

@dataclass
class SpanMomentResult:
    # For simply supported spans
    PA: float = 0.0
    PB: float = 0.0
    MA: float = 0.0
    Mmid: float = 0.0
    MB: float = 0.0
    # For one-end continuous spans
    Phinge: float = 0.0
    Pfixed: float = 0.0
    Mhinge: float = 0.0

def momentEndSpan(span_type, max_combo, length):
    q = max_combo
    if span_type == "simply supported":
        return SpanMomentResult(
            PA=q * length / 2,
            PB=q * length / 2,
            Mmid=(q * math.pow(length, 2)) / 8
        )
    elif span_type == "one end continuous":
        return SpanMomentResult(
            Phinge=3 * q * length / 8,
            Pfixed=5 * q * length / 8,
            Mmid=(q * math.pow(length, 2)) * (9 / 128),
            MB=-1 * (q * math.pow(length, 2)) / 8
        )

Now you can access results like result.PA or result.Mmid instead of force["PA"], which is more readable and less error-prone.

3. Array/List Output (For Numerical Processing) #

If you plan to do further numerical calculations with these values, returning a list or NumPy array might be more efficient. Just make sure you document the order of values clearly:

import math

def momentEndSpan(span_type, max_combo, length):
    q = max_combo
    if span_type == "simply supported":
        # Order: PA, PB, MA, Mmid, MB
        return [
            q * length / 2,
            q * length / 2,
            0,
            (q * math.pow(length, 2)) / 8,
            0
        ]
    elif span_type == "one end continuous":
        # Order: Phinge, Pfixed, Mhinge, Mmid, MB
        return [
            3 * q * length / 8,
            5 * q * length / 8,
            0,
            (q * math.pow(length, 2)) * (9 / 128),
            -1 * (q * math.pow(length, 2)) / 8
        ]

If you use NumPy, you can return np.array([...]) instead, which lets you do vectorized operations easily if you're working with multiple spans.

Quick Notes on Efficiency #

• The direct dictionary approach is the fastest for small-scale use cases since it has minimal overhead.
• Data classes add a tiny bit of overhead but pay off in maintainability if you're working with these results frequently.
• Arrays are best if you're passing these values to numerical libraries (like NumPy or SciPy) for further analysis.

Hope these options help you streamline your code! 😊

内容的提问来源于stack exchange，提问作者Albert Pamonag