Groovy spread-dot运算符的Python等效实现及更优可读写法问询

Great question! I totally feel your pain—Groovy's *. spread-dot operator is incredibly clean for extracting properties from collections, especially when dealing with deeply nested structures. Python doesn't have a built-in operator that does exactly this, but there are several approaches to get similar readability and conciseness.

1. Using Built-in Tools: operator.itemgetter + map #

For simple, single-level extractions, you can use itemgetter from the operator module combined with map. It’s more concise than a basic list comprehension:

from operator import itemgetter

A = [{"a": "1", "b": "2"}, {"a": "3", "b": "4"}, {"a": "5", "b": "6"}]
B = list(map(itemgetter("b"), A))
# B becomes ["2", "4", "6"]

For nested structures, you’ll still need to traverse to the inner collection first, but it’s a bit cleaner than a full nested list comprehension:

records = response.json()['data']['ConfigRecords']['page']['records']
ASV_list = list(map(itemgetter("ASV"), records))

2. Third-Party Libraries (Most Groovy-like Experience) #

If you don’t mind adding a dependency, libraries like pydash or toolz offer pluck functions that mimic Groovy’s spread-dot behavior—even for nested paths.

pydash #

pydash’s pluck method works with dot-separated paths, which is almost identical to Groovy’s syntax:

import pydash

# Single level
B = pydash.pluck(A, "b")

# Nested structure (matches your Groovy example perfectly!)
ASV_list = pydash.pluck(response.json(), "data.ConfigRecords.page.records.ASV")

toolz #

toolz has a pluck function too. While it doesn’t handle dot-separated nested paths out of the box, you can combine it with get_in for deeper structures:

from toolz import pluck, get_in

# Single level
B = list(pluck("b", A))

# Nested structure
records = get_in(["data", "ConfigRecords", "page", "records"], response.json())
ASV_list = list(pluck("ASV", records))

3. Build Your Own Custom pluck Function #

If you want to avoid third-party dependencies, you can easily write a reusable function that handles dot-separated paths, just like Groovy:

def pluck(items, path):
    keys = path.split(".")
    # Traverse all but the last key to reach the target collection
    for key in keys[:-1]:
        items = [item[key] for item in items]
    # Extract the final property from each item
    return [item[keys[-1]] for item in items]

# Usage for single level
B = pluck(A, "b")

# Usage for nested structure
ASV_list = pluck(response.json(), "data.ConfigRecords.page.records.ASV")

This function gives you the exact readability you’re missing from Groovy, without needing any external libraries.

Which Should You Choose? #

• Use built-in itemgetter if you want no dependencies and only need simple extractions.
• Use pydash if you want the closest possible experience to Groovy’s spread-dot, including nested path support.
• Build your own function if you want full control and no external dependencies for nested use cases.

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