Python通用类型解析方法咨询：如何实现复杂嵌套类型转换

Great question! Let's start with the quick answer: yes, Python has excellent libraries for this exact use case, and if you need to roll your own for learning or dependency reasons, it's totally doable with recursive type inspection.

Using Existing Libraries: Pydantic is the Standard #

If you don't mind adding a dependency, Pydantic is designed specifically for validating and parsing data into strict types, including complex nested structures like list[int] or dict[str, str | int]. It handles edge cases, provides clear error messages, and requires minimal code.

For your example of converting ['1','2','3'] to list[int], here's how you'd do it with Pydantic v2 (the latest version):

from pydantic import TypeAdapter

# Convert list[str] to list[int]
input_data = ['1', '2', '3']
target_type = list[int]
parsed_data = TypeAdapter(target_type).validate_python(input_data)

print(parsed_data)  # Output: [1, 2, 3]
print(type(parsed_data[0]))  # Output: <class 'int'>

And for a more complex nested type like dict[str, str | int]:

input_dict = {'username': 'jdoe', 'age': '32', 'post_count': '150'}
target_type = dict[str, str | int]
parsed_dict = TypeAdapter(target_type).validate_python(input_dict)

print(parsed_dict)  # Output: {'username': 'jdoe', 'age': 32, 'post_count': 150}

Pydantic will automatically raise a ValidationError if any value can't be converted to the target type, with details about exactly what went wrong—super helpful for debugging.

Building Your Own Generic Parser #

If you need to avoid external dependencies and want to implement this yourself, you can create a recursive function that inspects the target type and converts values accordingly. The key is using Python's typing module to unpack generic types (like list[int] or Union[str, int]).

Here's a basic but functional implementation:

from typing import Any, TypeVar, Union, get_origin, get_args

T = TypeVar('T')

def parse_value(value: Any, target_type: type[T]) -> T:
    # Handle basic numeric/string types
    basic_types = (int, str, float)
    if target_type in basic_types:
        try:
            return target_type(value)
        except (ValueError, TypeError) as e:
            raise ValueError(f"Failed to convert {repr(value)} to {target_type.__name__}: {str(e)}")
    
    # Special handling for booleans (since bool("False") returns True by default)
    if target_type is bool:
        if isinstance(value, str):
            lower_val = value.strip().lower()
            if lower_val in ('true', '1', 'yes'):
                return True
            elif lower_val in ('false', '0', 'no'):
                return False
            raise ValueError(f"Cannot convert string '{value}' to boolean")
        return bool(value)
    
    # Handle list types (e.g., list[int])
    origin = get_origin(target_type)
    if origin is list:
        element_type = get_args(target_type)[0]
        if not isinstance(value, (list, tuple)):
            raise TypeError(f"Expected list/tuple for list type, got {type(value).__name__}")
        return [parse_value(item, element_type) for item in value]
    
    # Handle dict types (e.g., dict[str, int | str])
    if origin is dict:
        key_type, val_type = get_args(target_type)
        if not isinstance(value, dict):
            raise TypeError(f"Expected dict for dict type, got {type(value).__name__}")
        parsed_dict = {}
        for k, v in value.items():
            parsed_dict[parse_value(k, key_type)] = parse_value(v, val_type)
        return parsed_dict
    
    # Handle Union types (e.g., str | int)
    if origin is Union:
        for candidate_type in get_args(target_type):
            try:
                return parse_value(value, candidate_type)
            except (ValueError, TypeError):
                continue
        raise ValueError(f"Cannot convert {repr(value)} to any type in {get_args(target_type)}")
    
    # Fallback for unsupported types
    raise TypeError(f"Unsupported target type: {target_type}")

Testing the Custom Parser #

Let's test it with your example and some complex cases:

# Convert list[str] to list[int]
print(parse_value(['1', '2', '3'], list[int]))  # Output: [1, 2, 3]

# Convert dict with mixed string values to dict[str, str | int | bool]
input_dict = {'name': 'Alice', 'age': '28', 'is_active': 'true'}
result = parse_value(input_dict, dict[str, Union[str, int, bool]])
print(result)  # Output: {'name': 'Alice', 'age': 28, 'is_active': True}

# Test union type conversion
print(parse_value('42', Union[int, str]))  # Output: 42 (as int)
print(parse_value('hello', Union[int, str]))  # Output: 'hello' (as str)

Notes on the Custom Implementation #

This is a minimal version—you'd want to extend it for production use to:

• Support more types (e.g., set, Optional, datetime)
• Add better error handling and more descriptive messages
• Handle optional values (e.g., None in Optional[int])
• Support custom types (like your own classes)

But it covers the core functionality you asked for: parsing nested generic types that basic conversions like int(value) can't handle.

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