能否在单个match语句中结合使用多个extractor对象？

Absolutely! You don’t have to split your logic across multiple match statements to work with multiple extractors—you can combine them directly in one statement using Python’s pattern matching syntax. Let’s walk through a few practical examples to demonstrate this.

Example 1: Combining extractors with the OR operator (|) #

Say you have two custom extractor classes (using __match_args__ to define their pattern structure):

class UserExtractor:
    __match_args__ = ("name", "age")
    def __init__(self, name, age):
        self.name = name
        self.age = age

class OrderExtractor:
    __match_args__ = ("order_id", "total")
    def __init__(self, order_id, total):
        self.order_id = order_id
        self.total = total

You can match both extractors in a single case using the | operator. Python will try matching the first extractor, then fall back to the second if needed:

def process_data(data):
    match data:
        case UserExtractor(name, age) | OrderExtractor(order_id, total):
            if isinstance(data, UserExtractor):
                print(f"Processing user: {name}, Age: {age}")
            else:
                print(f"Processing order: ID {order_id}, Total: ${total:.2f}")
        case _:
            print("Unrecognized data type")

# Test the function
process_data(UserExtractor("Alice", 32))
process_data(OrderExtractor(78901, 89.99))

Example 2: Nested extractors in a single case #

If your data has nested structures, you can extract values from multiple nested extractors all in one match statement:

class AddressExtractor:
    __match_args__ = ("street", "city")
    def __init__(self, street, city):
        self.street = street
        self.city = city

class UserWithAddressExtractor:
    __match_args__ = ("user_details", "user_address")
    def __init__(self, user_details, user_address):
        self.user_details = user_details
        self.user_address = user_address

def process_nested_data(data):
    match data:
        case UserWithAddressExtractor(
            UserExtractor(name, age), 
            AddressExtractor(street, city)
        ):
            print(f"User {name} ({age}) resides at {street}, {city}")
        case _:
            print("Nested data format not recognized")

# Test nested extraction
user_record = UserWithAddressExtractor(
    UserExtractor("Bob", 28),
    AddressExtractor("456 Oak Ave", "Chicago")
)
process_nested_data(user_record)

This lets you pull all relevant fields in one go, no need for separate match blocks.

Example 3: Extractors with guard clauses #

You can also pair multiple extractors with guard clauses (conditional checks) in the same match statement to filter cases:

def filter_and_process(data):
    match data:
        case UserExtractor(name, age) if age >= 18:
            print(f"Approved adult user: {name}")
        case OrderExtractor(order_id, total) if total > 100.00:
            print(f"Flagging high-value order #{order_id}")
        case _:
            print("No matching criteria satisfied")

Each case uses a different extractor and adds a condition to narrow down the matches, all within the same match logic.

The key takeaway is that Python’s pattern matching is flexible enough to handle multiple extractors directly—whether you’re combining them with |, nesting them, or adding guards. No need to split your code into separate statements!

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