如何将7层级DataFrame转换为适用于D3.js的嵌套JSON？

Hey there! I get it—you're a Python newbie trying to turn a 7-level DataFrame into the nested JSON structure D3.js expects, but your current code only handles a simple parent-child setup. Let's fix this with a flexible, scalable solution that works for any number of hierarchy levels.

First, Let's Diagnose the Problem with Your Current Code #

Your existing to_flare_json function hardcodes only the first two levels (parent and child) and doesn't recursively build out the deeper layers (Region, Country, State, City, Boroughs). It also relies on index positions which makes it brittle if your DataFrame columns ever change.

The Solution: A Generic Hierarchy Builder #

We'll create a function that traverses each row of your DataFrame, building the nested structure one level at a time. It will automatically find or create nodes for each hierarchy level, then attach the population value to the final leaf node.

Step 1: Helper Function to Find/Create Nodes

First, a small helper to avoid repeating code—this checks if a node exists under a parent, and creates it if not:

def find_or_create_node(parent, node_name):
    # Look for an existing child node with the given name
    for child in parent.get('children', []):
        if child['name'] == node_name:
            return child
    # If not found, create a new node and add it to the parent's children
    new_node = {'name': node_name, 'children': []}
    parent['children'].append(new_node)
    return new_node

Step 2: Main Conversion Function

This function takes your DataFrame, the root node name (default: "World"), and the name of your value column (default: "Population"):

import json
import pandas as pd

def dataframe_to_d3_json(df, root_name="World", value_col="Population"):
    # Initialize the root of our nested structure
    root = {"name": root_name, "children": []}
    
    # Get all columns that form the hierarchy (exclude the value column)
    hierarchy_columns = [col for col in df.columns if col != value_col]
    
    # Process each row in the DataFrame
    for _, row in df.iterrows():
        current_node = root
        # Traverse each level of the hierarchy
        for col in hierarchy_columns:
            level_value = row[col]
            # Skip empty/NaN values (adjust this logic if needed for your data)
            if pd.isna(level_value):
                break
            # Move to the next level (create node if it doesn't exist)
            current_node = find_or_create_node(current_node, level_value)
        
        # Convert the final node to a leaf: remove 'children' and add the value
        current_node.pop("children", None)
        current_node[value_col.lower()] = row[value_col]
    
    return root

Step 3: Test with Your Sample Data

Let's use your sample DataFrame to test this out. First, let's define the sample data properly (I adjusted the first column to "World" since your expected JSON uses that as the root):

# Sample DataFrame matching your structure
sample_data = {
    "World": ["World", "World", "World"],
    "Continent": ["Europe", "Europe", "Europe"],
    "Region": ["Western Europe", "Western Europe", "Western Europe"],
    "Country": ["France", "France", "France"],
    "State": ["Ile de France", "Ile de France", "Ile de France"],
    "City": ["Paris", "Paris", "Paris"],
    "Boroughs": ["17", "19", "20"],
    "Population": [821964, 821964, 821964]
}

df = pd.DataFrame(sample_data)

# Convert to nested JSON
nested_json = dataframe_to_d3_json(df)

# Save to a JSON file (ready for D3.js!)
with open("flare.json", "w", encoding="utf-8") as outfile:
    json.dump(nested_json, outfile, indent=4, ensure_ascii=False)

What the Output Looks Like #

The generated JSON will match the nested structure you need for D3.js, with all 7 levels included:

{
    "name": "World",
    "children": [
        {
            "name": "Europe",
            "children": [
                {
                    "name": "Western Europe",
                    "children": [
                        {
                            "name": "France",
                            "children": [
                                {
                                    "name": "Ile de France",
                                    "children": [
                                        {
                                            "name": "Paris",
                                            "children": [
                                                {
                                                    "name": "17",
                                                    "population": 821964
                                                },
                                                {
                                                    "name": "19",
                                                    "population": 821964
                                                },
                                                {
                                                    "name": "20",
                                                    "population": 821964
                                                }
                                            ]
                                        }
                                    ]
                                }
                            ]
                        }
                    ]
                }
            ]
        }
    ]
}

Key Benefits of This Approach #

• Flexible: Works for any number of hierarchy levels (not just 7)
• Robust: Doesn't rely on hardcoded column indexes
• Clean: Leaves leaf nodes without a children array (D3.js prefers this for non-branching nodes)

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