Kimi vs Qwen for Coding

Here's a Python function that flattens nested JSON objects into dot-notation keys, with proper handling of arrays (using indices) and dictionaries:

def flatten_json(nested_obj, separator='.'):
    """
    Flatten a nested JSON structure into a single-level dictionary with dot-notation keys.
    
    Args:
        nested_obj: A dictionary, list, or primitive value representing parsed JSON
        separator: String used to separate nested keys (default: '.')
        
    Returns:
        dict: Flattened dictionary with dot-notation keys
        
    Examples:
        >>> flatten_json({"a": 1, "b": {"c": 2}})
        {'a': 1, 'b.c': 2}
        
        >>> flatten_json({"items": ["x", "y"]})
        {'items.0': 'x', 'items.1': 'y'}
        
        >>> flatten_json([{"id": 1}, {"id": 2}])
        {'0.id': 1, '1.id': 2}
    """
    flattened = {}
    
    def _flatten(obj, prefix=''):
        if isinstance(obj, dict):
            for key, value in obj.items():
                # Escape separator in keys to avoid path ambiguity
                safe_key = str(key).replace(separator, '\\' + separator)
                new_key = f"{prefix}{separator}{safe_key}" if prefix else safe_key
                _flatten(value, new_key)
                
        elif isinstance(obj, (list, tuple)):
            for index, value in enumerate(obj):
                new_key = f"{prefix}{separator}{index}" if prefix else str(index)
                _flatten(value, new_key)
                
        else:
            # Base case: primitive value (int, str, float, bool, None)
            flattened[prefix] = obj
    
    _flatten(nested_obj)
    return flattened


# Example usage
if __name__ == "__main__":
    # Complex nested example
    data = {
        "user": {
            "name": "Alice",
            "age": 30,
            "address": {
                "city": "New York",
                "zip": "10001"
            },
            "tags": ["admin", "active", "verified"],
            "scores": [
                {"subject": "math", "grade": 95},
                {"subject": "science", "grade": 88}
            ]
        },
        "metadata": None
    }
    
    flat = flatten_json(data)
    for key, value in flat.items():
        print(f"{key}: {value}")

Output:

user.name: Alice
user.age: 30
user.address.city: New York
user.address.zip: 10001
user.tags.0: admin
user.tags.1: active
user.tags.2: verified
user.scores.0.subject: math
user.scores.0.grade: 95
user.scores.1.subject: science
user.scores.1.grade: 88
metadata: None

Key Features:

1. Recursive traversal - Handles arbitrarily deep nesting
2. Array indexing - List indices become part of the key path (e.g., items.0, items.1)
3. Type safety - Handles dictionaries, lists, tuples, and primitives (including None)
4. Key escaping - Escapes separator characters in original keys to avoid ambiguity
5. Root-level arrays - Works even if the top-level object is a list
6. Custom separator - Optional parameter to change the delimiter (e.g., use / or _ instead of .)

Alternative: Iterative Version (for very deep structures to avoid recursion limits):

def flatten_json_iterative(nested_obj, separator='.'):
    flattened = {}
    stack = [(nested_obj, '')]
    
    while stack:
        obj, prefix = stack.pop()
        
        if isinstance(obj, dict):
            for key, value in obj.items():
                new_key = f"{prefix}{separator}{key}" if prefix else key
                stack.append((value, new_key))
        elif isinstance(obj, (list, tuple)):
            for index, value in enumerate(obj):
                new_key = f"{prefix}{separator}{index}" if prefix else str(index)
                stack.append((value, new_key))
        else:
            flattened[prefix] = obj
            
    return flattened

Here's a Python function that flattens a nested JSON object into a single-level dictionary using dot-notation keys. Array indices are included in the key path to preserve structure.

def flatten_json(nested_json, parent_key='', separator='.'):
    """
    Flattens a nested JSON object into a single-level dictionary with dot-notation keys.
    Array indices are included in the key path.

    Args:
        nested_json (dict or list): The nested JSON object to flatten.
        parent_key (str): The accumulated key path from parent levels.
        separator (str): The separator used between key levels (default is '.').

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

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

    return items

Example Usage

nested_data = {
    "user": {
        "name": "Alice",
        "age": 30,
        "emails": ["alice@example.com", "alice.work@example.com"]
    },
    "active": True,
    "scores": [95, 87, 92]
}

flattened = flatten_json(nested_data)
print(flattened)

Output:

{
    'user.name': 'Alice',
    'user.age': 30,
    'user.emails.0': 'alice@example.com',
    'user.emails.1': 'alice.work@example.com',
    'active': True,
    'scores.0': 95,
    'scores.1': 87,
    'scores.2': 92
}

Optional: Custom Separator

You can customize the key separator if needed:

flatten_json(nested_data, separator='_')

Output:

{
    'user_name': 'Alice',
    'user_age': 30,
    'user_emails_0': 'alice@example.com',
    ...
}

Notes

• This function handles arbitrarily nested dictionaries and lists.
• Primitive values (strings, numbers, booleans, None) are preserved as-is.
• It's suitable for preparing nested JSON for storage, indexing, or flat-file export.