如何在Python中实现支持穿透、无全Break的Case/Switch语句

Great question! I totally get wanting to replicate that familiar C/Java switch fallthrough behavior in Python—since Python doesn't have a native switch statement that supports this out of the box, we need to roll our own solution. Let's break down exactly how to mirror your example, including all the fallthrough, shared case logic, and default behavior.

First, let's define the helper functions from your example so we have something to execute:

def doA():
    print("Running doA()")

def doB():
    print("Running doB()")

def doC():
    print("Running doC()")

def doDE():
    print("Running doDE()")

def doFG():
    print("Running doFG()")

def doH():
    print("Running doH()")

def doI():
    print("Running doI()")

def foo():
    print("Running default foo()")

The Custom Switch Function with Fallthrough #

This implementation uses an ordered list of case definitions to ensure fallthrough follows the same sequence as your C/Java code. Each case entry specifies which values it matches, what actions to run, and whether to continue falling through to subsequent cases.

def switch_with_fallthrough(expression):
    # Ordered list of case rules: (matching_values, actions_to_run, allow_fallthrough)
    # - matching_values: single value or tuple of values (for shared cases like d/e)
    # - actions_to_run: list of functions to execute (empty for cases with no code)
    # - allow_fallthrough: True = no break, continue to next case; False = break after this case
    cases = [
        (('a',), [doA], True),
        (('b',), [doB], True),
        (('c',), [doC], False),
        (('d', 'e'), [doDE], False),
        (('f',), [], True),  # No code here, just fall through to g
        (('g',), [doFG], True),
        (('h',), [doH], False),
        (('i',), [doI], True),
    ]

    fallthrough_active = False
    matched_any_case = False

    for case_vals, actions, allow_fallthrough in cases:
        # Trigger this case if we're in fallthrough mode OR the expression matches
        if fallthrough_active or expression in case_vals:
            matched_any_case = True
            # Run all actions for this case
            for action in actions:
                action()
            # Update fallthrough status for next iteration
            fallthrough_active = allow_fallthrough
            # Stop looping if we hit a "break" (allow_fallthrough = False)
            if not fallthrough_active:
                break

    # Run default if no cases matched OR we fell through all cases
    if not matched_any_case or fallthrough_active:
        foo()

Testing the Behavior #

Let's verify this works exactly like your example:

• Input 'a': Runs doA() → falls through to 'b' → runs doB() → falls through to 'c' → runs doC() → hits break (stops)
• Input 'd': Runs doDE() → hits break (stops)
• Input 'f': No action for 'f' → falls through to 'g' → runs doFG() → falls through to 'h' → runs doH() → hits break (stops)
• Input 'i': Runs doI() → no break, falls through to default → runs foo()
• Input 'x': No case matches → runs default foo()

What About Python 3.10+ match? #

Python's match statement is great for pattern matching, but it doesn't support native fallthrough. You could manually duplicate code to mimic it, but that defeats the purpose of clean, maintainable code (unlike our custom function above). For example:

match expression:
    case 'a':
        doA()
        doB()
        doC()
    case 'b':
        doB()
        doC()
    # ... this gets messy fast for complex fallthrough logic

Stick with the custom switch function if you need true C/Java-style fallthrough behavior.

内容的提问来源于stack exchange，提问作者Miguel Angel Alvarez Rodriguez