ChatGPT vs DeepSeek 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": "New York"
        },
        "phones": ["123-456", "987-654"]
    }
}

result = flatten_json(data)
print(result)

Output:

{
    'user.name': 'Alice',
    'user.address.city': 'New York',
    'user.phones.0': '123-456',
    'user.phones.1': '987-654'
}

If you want, I can also provide:

• a version that preserves empty lists/dicts
• a non-recursive version
• a version with custom key formatting like phones[0] instead of phones.0

Here's a Python function that flattens nested JSON objects into a single-level dictionary with dot notation:

from typing import Any, Dict, List, Union
import json

def flatten_json(data: Union[Dict, List], parent_key: str = '', sep: str = '.') -> Dict[str, Any]:
    """
    Flatten a nested JSON object into a single-level dictionary with dot notation.
    
    Args:
        data: The nested JSON object (dictionary or list)
        parent_key: Used for recursion, don't pass this when calling initially
        sep: Separator to use between key parts (default is '.')
        
    Returns:
        A flattened dictionary with dot-notation keys
        
    Example:
        >>> data = {'a': {'b': 1, 'c': [{'d': 2}, {'d': 3}]}, 'e': 4}
        >>> flatten_json(data)
        {'a.b': 1, 'a.c[0].d': 2, 'a.c[1].d': 3, 'e': 4}
    """
    items = {}
    
    def _flatten(value: Any, key: str = '') -> None:
        """Recursive helper function."""
        if isinstance(value, dict):
            if value:  # Non-empty dict
                for k, v in value.items():
                    new_key = f"{key}{sep}{k}" if key else k
                    _flatten(v, new_key)
            else:  # Empty dict
                items[key] = {}
        elif isinstance(value, list):
            if value:  # Non-empty list
                for i, v in enumerate(value):
                    new_key = f"{key}[{i}]"
                    _flatten(v, new_key)
            else:  # Empty list
                items[key] = []
        else:
            items[key] = value
    
    # Handle initial input
    if isinstance(data, list):
        for i, v in enumerate(data):
            _flatten(v, f'[{i}]')
    elif isinstance(data, dict):
        for k, v in data.items():
            _flatten(v, k)
    else:
        return {'': data}  # Simple scalar value
    
    return items


def flatten_json_string(json_str: str, sep: str = '.') -> Dict[str, Any]:
    """
    Flatten a JSON string into a single-level dictionary.
    
    Args:
        json_str: JSON string to flatten
        sep: Separator to use between key parts
        
    Returns:
        A flattened dictionary with dot-notation keys
    """
    data = json.loads(json_str)
    return flatten_json(data, sep=sep)


# Alternative implementation with more explicit handling
def flatten_json_iterative(data: Union[Dict, List], sep: str = '.') -> Dict[str, Any]:
    """
    Flatten JSON using iterative approach (useful for very deep nesting).
    """
    items = {}
    stack = [(data, '')]
    
    while stack:
        current, parent_key = stack.pop()
        
        if isinstance(current, dict):
            if not current:  # Empty dict
                items[parent_key] = {} if parent_key else current
            else:
                for k, v in current.items():
                    new_key = f"{parent_key}{sep}{k}" if parent_key else k
                    stack.append((v, new_key))
        
        elif isinstance(current, list):
            if not current:  # Empty list
                items[parent_key] = [] if parent_key else current
            else:
                for i in range(len(current) - 1, -1, -1):  # Reverse for stack LIFO
                    v = current[i]
                    new_key = f"{parent_key}[{i}]"
                    stack.append((v, new_key))
        
        else:
            items[parent_key] = current
    
    return items


# Example usage and testing
if __name__ == "__main__":
    # Example 1: Simple nested object
    example1 = {
        'name': 'John',
        'address': {
            'street': '123 Main St',
            'city': 'Boston',
            'coordinates': {
                'lat': 42.3601,
                'lng': -71.0589
            }
        },
        'age': 30
    }
    
    print("Example 1 - Simple nested object:")
    result1 = flatten_json(example1)
    for k, v in result1.items():
        print(f"  {k}: {v}")
    
    # Example 2: Object with arrays
    example2 = {
        'user': 'jdoe',
        'scores': [85, 92, 78],
        'courses': [
            {'name': 'Math', 'grade': 'A'},
            {'name': 'Science', 'grade': 'B+'}
        ]
    }
    
    print("\nExample 2 - Object with arrays:")
    result2 = flatten_json(example2)
    for k, v in result2.items():
        print(f"  {k}: {v}")
    
    # Example 3: Complex nested structure
    example3 = {
        'id': 1,
        'metadata': {
            'tags': ['important', 'urgent'],
            'history': [
                {'action': 'create', 'timestamp': '2023-01-01'},
                {'action': 'update', 'timestamp': '2023-01-02'}
            ]
        },
        'data': {
            'users': [
                {'name': 'Alice', 'roles': ['admin', 'user']},
                {'name': 'Bob', 'roles': ['user']}
            ]
        }
    }
    
    print("\nExample 3 - Complex nested structure:")
    result3 = flatten_json(example3)
    for k, v in sorted(result3.items()):
        print(f"  {k}: {v}")
    
    # Example 4: JSON string input
    json_str = '{"a": {"b": 1, "c": [{"d": 2}, {"d": 3}]}, "e": 4}'
    print("\nExample 4 - From JSON string:")
    result4 = flatten_json_string(json_str)
    for k, v in sorted(result4.items()):
        print(f"  {k}: {v}")

Key features of the implementation:

1. Handles nested dictionaries: Creates dot-separated keys (e.g., "address.city")
2. Handles arrays: Includes index in brackets (e.g., "courses[0].name")
3. Preserves empty structures: Empty dicts/lists are included as-is
4. Recursive approach: Clean, readable implementation using recursion
5. Alternative iterative approach: Provided for very deep nesting (avoids recursion limit)
6. JSON string support: Helper function to directly flatten JSON strings
7. Flexible separator: Can customize the separator (default is dot)

Output from the examples:

Example 1 - Simple nested object:
  name: John
  address.street: 123 Main St
  address.city: Boston
  address.coordinates.lat: 42.3601
  address.coordinates.lng: -71.0589
  age: 30

Example 2 - Object with arrays:
  user: jdoe
  scores[0]: 85
  scores[1]: 92
  scores[2]: 78
  courses[0].name: Math
  courses[0].grade: A
  courses[1].name: Science
  courses[1].grade: B+

Example 3 - Complex nested structure:
  data.users[0].name: Alice
  data.users[0].roles[0]: admin
  data.users[0].roles[1]: user
  data.users[1].name: Bob
  data.users[1].roles[0]: user
  id: 1
  metadata.history[0].action: create
  metadata.history[0].timestamp: 2023-01-01
  metadata.history[1].action: update
  metadata.history[1].timestamp: 2023-01-02
  metadata.tags[0]: important
  metadata.tags[1]: urgent

Usage:

# Basic usage
flattened = flatten_json(your_nested_dict)

# With custom separator
flattened = flatten_json(your_nested_dict, sep='_')

# From JSON string
flattened = flatten_json_string('{"a": {"b": 1}}')

The function handles all edge cases including empty dictionaries, empty lists, and scalar values at the root level.