ChatGPT vs Qwen for Coding

def flatten_json(data, parent_key="", sep="."):
    """
    Flatten a nested JSON-like object into a single-level dict using dot notation.

    Arrays/lists are handled by including the index in the key path.

    Example:
        {
            "user": {
                "name": "Alice",
                "emails": ["a@example.com", "b@example.com"]
            }
        }

    Becomes:
        {
            "user.name": "Alice",
            "user.emails.0": "a@example.com",
            "user.emails.1": "b@example.com"
        }
    """
    items = {}

    if isinstance(data, dict):
        for key, value in data.items():
            new_key = f"{parent_key}{sep}{key}" if parent_key else str(key)
            items.update(flatten_json(value, new_key, sep=sep))

    elif isinstance(data, list):
        for index, value in enumerate(data):
            new_key = f"{parent_key}{sep}{index}" if parent_key else str(index)
            items.update(flatten_json(value, new_key, sep=sep))

    else:
        items[parent_key] = data

    return items

Example usage:

nested = {
    "user": {
        "name": "Alice",
        "address": {
            "city": "New York",
            "zip": "10001"
        },
        "phones": ["123-4567", "987-6543"]
    },
    "active": True
}

flat = flatten_json(nested)
print(flat)

Output:

{
    'user.name': 'Alice',
    'user.address.city': 'New York',
    'user.address.zip': '10001',
    'user.phones.0': '123-4567',
    'user.phones.1': '987-6543',
    'active': True
}

Here's a robust Python function that flattens a nested JSON object into a single-level dictionary using dot-notation keys. It handles nested dictionaries, arrays (with index paths), and primitive values, while also supporting customization and edge cases.

def flatten_json(nested_json, parent_key='', sep='.'):
    """
    Flatten a nested JSON object into a single-level dictionary with dot-notation keys.
    
    Args:
        nested_json (dict or list): The nested JSON/dictionary object to flatten.
        parent_key (str): The base key to use during recursion (used internally).
        sep (str): Separator between nested keys (default is '.').

    Returns:
        dict: A flat dictionary with dot-notation keys.
    """
    items = {}

    if isinstance(nested_json, dict):
        for key, value in nested_json.items():
            new_key = f"{parent_key}{sep}{key}" if parent_key else key
            items.update(flatten_json(value, new_key, sep))
    elif isinstance(nested_json, list):
        for index, value in enumerate(nested_json):
            new_key = f"{parent_key}{sep}{index}" if parent_key else str(index)
            items.update(flatten_json(value, new_key, sep))
    else:
        # Base case: primitive value (including None)
        items[parent_key] = nested_json

    return items

Example Usage

nested_data = {
    "user": {
        "name": "Alice",
        "age": 30,
        "address": {
            "city": "Wonderland",
            "zip": "12345"
        }
    },
    "orders": [
        {"id": 1, "item": "Book"},
        {"id": 2, "item": "Pen"}
    ],
    "active": True,
    "notes": None
}

flattened = flatten_json(nested_data)
for k, v in flattened.items():
    print(f"{k}: {v}")

Sample Output

user.name: Alice
user.age: 30
user.address.city: Wonderland
user.address.zip: 12345
orders.0.id: 1
orders.0.item: Book
orders.1.id: 2
orders.1.item: Pen
active: True
notes: None

Features

• ✅ Handles nested dictionaries and lists recursively
• ✅ Includes array indices in key paths (e.g., orders.0.item)
• ✅ Preserves None and other primitive values
• ✅ Customizable key separator via the sep argument
• ✅ Works with empty structures, mixed types, and deep nesting

This function is ideal for preparing complex JSON data for storage, logging, or analysis in systems that require flat key-value structures.