字典扁平化时如何处理自引用？附递归实现代码

Your original flattening function works great for standard nested dictionaries, but it'll hit a RecursionError immediately when faced with circular/self-referential structures. For example, if you set mydict['first']['second']['third'] = mydict, the function will recurse infinitely until it overflows the call stack.

The Root Problem #

The function doesn't track which dictionary objects it's already processed. When it encounters a reference to a dictionary it's already traversing, it just keeps recursing without stopping.

The Solution: Track Processed Dictionaries #

We can modify the function to include a seen set that tracks the unique IDs of dictionaries we've handled. This lets us detect circular references and handle them gracefully instead of looping forever.

Here's the updated function:

def recursive_flatten(mydict, seen=None):
    # Initialize the seen set (avoids mutable default parameter pitfalls)
    if seen is None:
        seen = set()
    
    flattened = {}
    current_dict_id = id(mydict)
    
    # Check if we've already processed this dictionary (circular reference detected)
    if current_dict_id in seen:
        # Return a clear marker for the circular reference
        return {"[Circular Reference]": mydict}
    
    # Add the current dictionary to our tracking set
    seen.add(current_dict_id)
    
    for key, value in mydict.items():
        if isinstance(value, dict):
            # Pass the seen set through to recursive calls to maintain tracking
            nested_flattened = recursive_flatten(value, seen)
            for nested_key, nested_value in nested_flattened.items():
                flattened[f"{key}.{nested_key}"] = nested_value
        else:
            flattened[key] = value
    
    # Optional: Remove the current dict from seen if you want to allow reprocessing
    # in separate branches (not necessary for most circular reference use cases)
    # seen.remove(current_dict_id)
    
    return flattened

How It Works #

1. Tracking with id(): We use id(mydict) to get a unique identifier for each dictionary object—since dictionaries are mutable, we can't add them directly to a set, but their IDs are unique and immutable.
2. Circular Reference Detection: Before processing a dictionary, we check if its ID is already in the seen set. If it is, we return a marker instead of recursing further.
3. Shared Tracking State: We pass the same seen set through every recursive call, so all levels of the function share the same knowledge of processed dictionaries.

Test It with a Self-Referential Dictionary #

Let's create a dictionary with a circular reference and test the function:

# Build a self-referential dictionary
mydict = {'first': {'second': {'third': {}}}}
mydict['first']['second']['third'] = mydict

# Flatten the dictionary
result = recursive_flatten(mydict)
print(result)

Sample Output:

{'first.second.third.[Circular Reference]': {'first': {...}, ...}}

Customize the Circular Reference Handling #

If you prefer a simpler marker instead of a nested entry, adjust the circular reference logic to directly set a value for the current key:

# Inside the loop, replace the dict handling block with this:
if isinstance(value, dict):
    value_id = id(value)
    if value_id in seen:
        flattened[key] = '[Circular Reference]'
        continue
    # Proceed with recursive flattening as before
    nested_flattened = recursive_flatten(value, seen)
    for nested_key, nested_value in nested_flattened.items():
        flattened[f"{key}.{nested_key}"] = nested_value

This will give you a cleaner output like:

{'first.second.third': '[Circular Reference]'}

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