Python中简单类型与复杂类型的区分及快速判定方法

Great question! Even though Python doesn't officially label types as "simple" or "complex" like you're describing, I totally get what you're after—you want to tell apart types that hold a single, atomic value versus those that act as containers for other values, even if that container only has one item. Let's break this down clearly.

Simple Types (Atomic Single Values) #

These are types that represent a single, indivisible value:

• int: Whole numbers (e.g., 42, -10) — a single numeric entity
• float: Decimal numbers (e.g., 3.14, -0.001) — a single floating-point value
• str: Text strings (e.g., "hello", 'world') — even though strings are technically iterable in Python, you're treating them as a single atomic element per your definition

Complex Types (Container Values) #

These are types designed to hold one or more other values (even just one):

• list: Ordered, mutable collections (e.g., [1], ["apple", "banana"]) — stores sequential elements
• tuple: Ordered, immutable collections (e.g., (5,), (True, False)) — note the trailing comma for single-element tuples, which still count as complex here
• dict: Key-value mappings (e.g., {"name": "Alice"}, {1: "one", 2: "two"}) — any number of key-value pairs (including one) makes it complex
• Bonus: Other container types like set (e.g., {1}, {"a"}) also fall into this category, as they're built to hold multiple (or even one) distinct elements

Since your definition is custom (based on atomic vs container, not Python's official hierarchies), here are practical, code-based methods to check:

Method 1: Explicit Whitelist Check #

The most direct way is to verify if the variable's type is in your predefined list of "simple" types:

def is_simple_type(var):
    # Checks exactly against your specified simple types
    return isinstance(var, (int, float, str))

# Test cases
print(is_simple_type(42))          # True
print(is_simple_type(3.14))        # True
print(is_simple_type("test"))      # True
print(is_simple_type([1]))         # False
print(is_simple_type({"key": "val"})) # False
print(is_simple_type((5,)))        # False

This method is rigid but perfectly aligned with your requirements—no surprises.

Method 2: Check for Container Behavior (Exclude Strings) #

If you want to generalize to other container types (like set), you can check if the variable is iterable but exclude strings (since you consider them simple):

def is_complex_type(var):
    # Try to iterate; if it works and it's not a string, it's complex
    try:
        iter(var)
        return not isinstance(var, str)
    except TypeError:
        # Not iterable = simple type
        return False

# Test cases
print(is_complex_type([1]))         # True
print(is_complex_type({"key": "val"})) # True
print(is_complex_type((5,)))        # True
print(is_complex_type({1}))         # True
print(is_complex_type(42))          # False
print(is_complex_type("test"))      # False

This catches all iterable containers, including custom ones, while respecting your string-as-simple rule.

Method 3: Use Abstract Base Classes (Formal Approach) #

For a more Pythonic, robust check against container-like behavior, use collections.abc:

from collections.abc import Container, Iterable

def is_complex_type(var):
    # Skip strings even though they implement Container/Iterable
    if isinstance(var, str):
        return False
    return isinstance(var, (Container, Iterable))

# Same test case results as Method 2

This leverages Python's type system to identify container behavior, making it scalable if you need to include more container types later.

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