ChatGPT vs Gemini for Coding

def flatten_json(obj, parent_key="", sep="."):
    flat = {}

    if isinstance(obj, dict):
        for key, value in obj.items():
            new_key = f"{parent_key}{sep}{key}" if parent_key else key
            flat.update(flatten_json(value, new_key, sep))
    elif isinstance(obj, list):
        for i, value in enumerate(obj):
            new_key = f"{parent_key}{sep}{i}" if parent_key else str(i)
            flat.update(flatten_json(value, new_key, sep))
    else:
        flat[parent_key] = obj

    return flat

Example:

data = {
    "user": {
        "name": "Alice",
        "address": {
            "city": "NYC"
        },
        "phones": ["1234", "5678"]
    }
}

print(flatten_json(data))

Output:

{
    'user.name': 'Alice',
    'user.address.city': 'NYC',
    'user.phones.0': '1234',
    'user.phones.1': '5678'
}

If you want, I can also provide:

• a version that preserves empty dicts/lists
• a non-recursive version
• an unflatten function

Here is the Python function to achieve this. It uses a recursive Depth-First Search (DFS) approach to traverse the nested JSON (which is represented as a dictionary in Python).

It assigns dot-notation keys for nested dictionaries and uses the list indices as parts of the dot-notation path for arrays.

def flatten_json(nested_json):
    """
    Flattens a nested dictionary/JSON object into a single-level dictionary.
    Handles nested dictionaries and lists by combining keys/indices with a dot (.).
    """
    flat_dict = {}

    def flatten(obj, parent_key=''):
        # If the object is a dictionary, iterate over its keys
        if isinstance(obj, dict):
            # Handle empty dictionary edge case
            if not obj and parent_key:
                flat_dict[parent_key] = obj
                
            for k, v in obj.items():
                # Create the new key using dot notation
                new_key = f"{parent_key}.{k}" if parent_key else k
                flatten(v, new_key)
                
        # If the object is a list, iterate using enumerate to get the index
        elif isinstance(obj, list):
            # Handle empty list edge case
            if not obj and parent_key:
                flat_dict[parent_key] = obj
                
            for i, v in enumerate(obj):
                # Use the index as part of the dot notation path
                new_key = f"{parent_key}.{i}" if parent_key else str(i)
                flatten(v, new_key)
                
        # Base case: if it's a primitive (str, int, float, bool, None)
        else:
            flat_dict[parent_key] = obj

    flatten(nested_json)
    return flat_dict

# ==========================================
# Example Usage:
# ==========================================
if __name__ == "__main__":
    example_json = {
        "user": {
            "id": 101,
            "name": "Alice",
            "contact": {
                "email": "alice@example.com",
                "phones": ["123-456-7890", "987-654-3210"]
            }
        },
        "settings": {
            "notifications": True,
            "themes": [
                {"name": "dark", "active": True},
                {"name": "light", "active": False}
            ]
        },
        "tags": [], # tests empty list handling
        "role": None
    }

    flattened = flatten_json(example_json)
    
    import json
    print(json.dumps(flattened, indent=4))

Output of the Example Usage:

{
    "user.id": 101,
    "user.name": "Alice",
    "user.contact.email": "alice@example.com",
    "user.contact.phones.0": "123-456-7890",
    "user.contact.phones.1": "987-654-3210",
    "settings.notifications": true,
    "settings.themes.0.name": "dark",
    "settings.themes.0.active": true,
    "settings.themes.1.name": "light",
    "settings.themes.1.active": false,
    "tags": [],
    "role": null
}

How it works:

1. Helper Function (flatten): An inner function makes it easy to keep passing the newly assembled string path (parent_key) down the recursion tree.
2. Dictionary Check (isinstance(obj, dict)): If the current item is a dictionary, we iterate through its items(). We append the key to the parent_key with a dot (unless it's the root level, in which case we don't start with a dot).
3. Array Check (isinstance(obj, list)): If the current item is a list, we use enumerate() to get both the index (i) and value (v). The index becomes the new key in the dot-notation path (e.g., phones.0).
4. Base Case: If the item isn't a dictionary or a list (meaning it is a string, number, boolean, or None), we've reached a terminal node. We add it to flat_dict.
5. Empty Iterables: Logic if not obj and parent_key is included so that if a JSON object contains empty arrays [] or nested elements {} that have no children, they aren't completely erased from the final output.