Python中如何用匿名yield生成器一次性构造列表？

Great question! I totally get wanting to avoid defining a named generator function when you only need it once—Python's restriction on single-line lambdas can feel frustrating here. Luckily, there are a few clean ways to achieve what you're after:

1. Use a Generator Expression (The Best Default) #

Generator expressions are essentially anonymous generators built right into Python's syntax, and they're perfect for one-off sequence generation. Even though they look like single-line code, you can absolutely split them across multiple lines for readability with complex logic:

xs = list(
    processed_x
    for item in large_dataset
    if item.is_active()  # First filter condition
    for sub_item in item.get_subitems()  # Nested loop over sub-elements
    if sub_item.value > 50  # Second filter condition
    for processed_x in sub_item.generate_values()  # Final value to yield
)

This works exactly like your hypothetical multi-line lambda generator, but it's idiomatic Python and way more readable. Generator expressions are designed specifically for this "create a sequence once without a named function" use case.

2. Chain Iterator Tools with itertools #

If your logic is made up of common iterative operations (filtering, mapping, flattening, etc.), you can combine functions from the itertools module instead of writing a custom generator. This keeps things concise without needing a named function:

from itertools import chain, filterfalse

xs = list(
    chain.from_iterable(
        filterfalse(lambda val: val < 0, sub_item.get_values())
        for item in dataset
        if item.is_valid()
    )
)

This is great for composing simple operations into a single, clean pipeline.

3. Temporary Generator Function (For Ultra-Complex Logic) #

If your code requires multi-line statements (like intermediate variable assignments or complex branching) that can't be cleanly expressed in a generator expression, you can define an unnamed generator function inside an immediately-invoked lambda (though this is a bit of a hack):

xs = list((lambda:
    def _temp_gen():
        for item in dataset:
            temp_calc = item.compute_metric()
            if temp_calc > 100:
                yield temp_calc * 2
            elif temp_calc < 20:
                yield temp_calc + 50
            # Add more complex conditional logic here
        return _temp_gen()
)())

That said, if your logic is this involved, it's usually better to just define a named generator function anyway—readability should take priority over avoiding a short, descriptive function name.

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