Python isinstance() 函数的使用小结

# 判断整数
num = 42
print(isinstance(num, int))  # 输出: True
# 判断浮点数
pi = 3.14159
print(isinstance(pi, float))  # 输出: True
# 判断字符串
greeting = "Hello, World!"
print(isinstance(greeting, str))  # 输出: True
# 判断布尔值
flag = True
print(isinstance(flag, bool))  # 输出: True
# 判断列表
my_list = [1, 2, 3]
print(isinstance(my_list, list))  # 输出: True
# 判断字典
my_dict = {"name": "Alice", "age": 30}
print(isinstance(my_dict, dict))  # 输出: True
# 判断元组
my_tuple = (1, 2, 3)
print(isinstance(my_tuple, tuple))  # 输出: True

# 检查一个值是否是数字（整数或浮点数）
value1 = 10
value2 = 3.14
value3 = "hello"
print(isinstance(value1, (int, float)))  # 输出: True
print(isinstance(value2, (int, float)))  # 输出: True
print(isinstance(value3, (int, float)))  # 输出: False
# 检查一个对象是否是序列类型（列表、元组、字符串）
seq1 = [1, 2, 3]
seq2 = (1, 2, 3)
seq3 = "abc"
seq4 = 123
print(isinstance(seq1, (list, tuple, str)))  # 输出: True
print(isinstance(seq4, (list, tuple, str)))  # 输出: False

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
class Student(Person):
    def __init__(self, name, age, student_id):
        super().__init__(name, age)
        self.student_id = student_id
# 创建实例
p = Person("Bob", 40)
s = Student("Alice", 20, "S12345")
# 检查实例
print(isinstance(p, Person))  # 输出: True
print(isinstance(s, Student))  # 输出: True
print(isinstance(s, Person))   # 输出: True (关键：子类实例被视为父类类型)
print(isinstance(p, Student))  # 输出: False

class Animal:
    pass
class Dog(Animal):
    pass
my_dog = Dog()
# isinstance() 的视角
print(isinstance(my_dog, Dog))    # True
print(isinstance(my_dog, Animal)) # True (因为Dog继承自Animal)
# type() 的视角
print(type(my_dog) == Dog)    # True
print(type(my_dog) == Animal) # False (严格匹配，不认继承)

from collections.abc import Iterable, Sequence, Mapping, Set
# 检查一个对象是否是可迭代的 (Iterable)
print(isinstance([1, 2, 3], Iterable))   # True
print(isinstance("hello", Iterable))     # True
print(isinstance(123, Iterable))         # False
# 检查对象是否是一个序列 (Sequence)
print(isinstance([1, 2, 3], Sequence))   # True
print(isinstance((1, 2), Sequence))      # True
print(isinstance({"a": 1}, Sequence))    # False (字典不是序列)
# 检查对象是否是一个映射 (Mapping)
print(isinstance({"a": 1}, Mapping))     # True
# 检查对象是否是一个集合 (Set)
print(isinstance({1, 2, 3}, Set))        # True

def process_data(data, multiplier=2):
    """
    处理数据，要求data必须是int或float类型。
    """
    if not isinstance(data, (int, float)):
        raise TypeError(f"参数 'data' 必须是 int 或 float 类型，但收到了 {type(data).__name__} 类型。")
    if not isinstance(multiplier, (int, float)):
        raise TypeError(f"参数 'multiplier' 必须是 int 或 float 类型。")
    return data * multiplier
# 正确调用
print(process_data(10))              # 输出: 20
print(process_data(3.14, 3))         # 输出: 9.42
# 错误调用
# process_data("hello")   # 抛出 TypeError

def get_user_name(user_id):
    """
    根据用户ID获取用户名，可能返回None。
    """
    # ... 假设这里有数据库查询逻辑
    if user_id == 1:
        return "Alice"
    else:
        return None
result = get_user_name(2)
# 检查结果是否为None
if not isinstance(result, type(None)):  # 或者更简单地: if result is not None:
    print(f"用户名是: {result}")
else:
    print("未找到用户。")

# 正确
isinstance("hello", str)   # True
# 错误：会抛出 NameError，因为 Python 没有名为 'string' 的内置类型
# isinstance("hello", string)

# 正确：classinfo 是一个类
isinstance(5, int)  # True
# 正确：classinfo 是一个类型元组
isinstance(5, (int, float))  # True
# 错误：classinfo 是一个列表
# isinstance(5, [int, float])  # 会抛出 TypeError

# LBYL 风格 (使用 isinstance)
def divide_lbyl(a, b):
    if not isinstance(a, (int, float)) or not isinstance(b, (int, float)):
        raise TypeError("参数必须是数字")
    if b == 0:
        raise ValueError("除数不能为0")
    return a / b
# EAFP 风格 (使用 try-except)
def divide_eafp(a, b):
    try:
        result = a / b
    except TypeError:
        raise TypeError("参数必须是数字")
    except ZeroDivisionError:
        raise ValueError("除数不能为0")
    return result

def read_files(paths):
    """
    读取文件内容。
    支持传入单个路径 (str) 或路径列表 (list of str)。
    """
    # 核心逻辑：统一处理为路径列表
    if isinstance(paths, str):
        # 如果传入的是单个字符串，将其包装为列表
        paths = [paths]
    elif not isinstance(paths, list):
        raise TypeError("paths 必须是字符串或字符串列表")
    # 现在 paths 保证是一个列表，可以统一处理
    contents = []
    for path in paths:
        if not isinstance(path, str):
            raise ValueError(f"路径列表中的每个元素必须是字符串，但收到 {type(path).__name__}")
        # ... 读取文件的逻辑 ...
        contents.append(f"内容来自 {path}")
    return contents
# 多种调用方式
print(read_files("single_file.txt"))      # 输出: ['内容来自 single_file.txt']
print(read_files(["a.txt", "b.txt"]))     # 输出: ['内容来自 a.txt', '内容来自 b.txt']
# print(read_files(123))                  # 抛出 TypeError

from pathlib import Path
import os
def robust_read(paths):
    """
    一个更健壮的路径处理函数，支持 str, Path, 以及它们的列表。
    """
    # 统一转换为 Path 对象，方便后续处理
    if isinstance(paths, (str, Path)):
        paths = [Path(paths)]
    elif isinstance(paths, (list, tuple)):
        # 处理列表中的每个元素
        paths = [Path(p) if isinstance(p, str) else p for p in paths]
        # 验证转换后的列表是否全部为 Path 对象
        if not all(isinstance(p, Path) for p in paths):
            raise TypeError("路径列表中的元素必须是 str 或 Path 对象")
    else:
        raise TypeError("paths 参数必须是 str, Path, 或它们的列表/元组")
    for p in paths:
        if p.exists():
            print(f"路径 {p} 存在")
        else:
            print(f"路径 {p} 不存在")
# 使用示例
robust_read("/tmp/test.txt")                    # 单个字符串
robust_read(Path("/tmp/test.txt"))              # 单个 Path 对象
robust_read(["/tmp/a.txt", "/tmp/b.txt"])       # 字符串列表
robust_read([Path("/tmp/a.txt"), Path("/tmp/b.txt")])  # Path 对象列表

from collections.abc import Sequence
def process_paths_sequence(paths):
    """
    接受任何序列类型的路径（如 list, tuple, set 等）。
    """
    if isinstance(paths, (str, Path)):
        paths = [paths]
    elif isinstance(paths, Sequence):
        # 确保是序列，但不一定是列表
        paths = list(paths)  # 转换为列表以便修改
    else:
        raise TypeError("无法处理的路径类型")
    # 后续处理
    for p in paths:
        # ...
        pass

# 使用类型提示
def read_files(paths: str | list[str]) -> list[str]:
    # 运行时依然可以使用 isinstance 进行动态检查
    if isinstance(paths, str):
        paths = [paths]
    # ... 其他逻辑