1. 基本概念
`isinstance()` 函数是 Python 内置的函数，用于判断一个对象是否为指定类型或指定类型的子类。其语法如下：
isinstance(object, classinfo)object：表示要判断类型的对象。
classinfo：可以是单个类型或由多个类型组成的元组。如果 `object` 是其中任意一个类型或其子类的实例，则返回 `True`，否则返回 `False`。
2. 基本用法
2.1 判断单个类型
# 判断整数类型
print(isinstance(10, int)) # 输出：True
# 判断字符串类型
print(isinstance("hello", str)) # 输出：True
# 判断列表类型
print(isinstance([1, 2, 3], list)) # 输出：True
# 判断字典类型
print(isinstance({"key": "value"}, dict)) # 输出：True
# 判断自定义类类型
class MyClass:
pass
obj = MyClass()
print(isinstance(obj, MyClass)) # 输出：True2.2 判断多个类型
可以使用元组传递多个类型，如果对象是其中任意一个类型的实例，则返回 `True`。
# 判断对象是否为整数或字符串类型
print(isinstance(10, (int, str))) # 输出：True
print(isinstance("hello", (int, str))) # 输出：True
print(isinstance(3.14, (int, str))) # 输出：False2.3 判断子类
`isinstance()` 可以用来判断一个对象是否为某个类型的子类的实例。
class Animal:
pass
class Dog(Animal):
pass
dog = Dog()
print(isinstance(dog, Animal)) # 输出：True
print(isinstance(dog, Dog)) # 输出：True3. 实际应用
3.1 类型检查和条件执行
在处理函数参数或用户输入时，使用 `isinstance()` 进行类型检查，确保参数或输入符合预期类型。
def process_data(data):
if isinstance(data, list):
print("处理列表数据")
elif isinstance(data, dict):
print("处理字典数据")
elif isinstance(data, str):
print("处理字符串数据")
else:
print("未知数据类型")
process_data([1, 2, 3]) # 输出：处理列表数据
process_data({"key": "value"}) # 输出：处理字典数据
process_data("hello") # 输出：处理字符串数据
process_data(42) # 输出：未知数据类型3.2 类型多态
在实现多态行为时，使用 `isinstance()` 确定对象的类型，以便调用适当的方法。
class Animal:
def speak(self):
pass
class Dog(Animal):
def speak(self):
print("Woof!")
class Cat(Animal):
def speak(self):
print("Meow!")
def make_sound(animal):
if isinstance(animal, Dog):
animal.speak()
elif isinstance(animal, Cat):
animal.speak()
else:
print("未知动物")
dog = Dog()
cat = Cat()
make_sound(dog) # 输出：Woof!
make_sound(cat) # 输出：Meow!3.3 数据验证
在数据处理和验证过程中，使用 `isinstance()` 检查数据类型，确保数据符合预期格式。
def validate_data(data):
if not isinstance(data, (int, float)):
raise ValueError("数据类型必须为整数或浮点数")
print("数据有效")
validate_data(42) # 输出：数据有效
validate_data(3.14) # 输出：数据有效
validate_data("hello") # 抛出异常：ValueError: 数据类型必须为整数或浮点数3.4 检查继承关系
在面向对象编程中，使用 `isinstance()` 检查对象是否是某个类的实例或其子类的实例，以确保对象符合预期的继承关系。
class Shape:
pass
class Circle(Shape):
pass
class Square(Shape):
pass
def check_shape(shape):
if isinstance(shape, Shape):
print("是一个形状对象")
else:
print("不是一个形状对象")
circle = Circle()
square = Square()
check_shape(circle) # 输出：是一个形状对象
check_shape(square) # 输出：是一个形状对象
check_shape(42) # 输出：不是一个形状对象3.5 使用 `isinstance()` 避免类型错误
在处理涉及多种类型的复杂逻辑时，使用 `isinstance()` 可以有效避免类型错误，提高代码的健壮性。
def add(a, b):
if not isinstance(a, (int, float)) or not isinstance(b, (int, float)):
raise TypeError("参数必须为数字类型")
return a + b
print(add(3, 4)) # 输出：7
print(add(3.5, 2.5)) # 输出：6.0
print(add(3, "4")) # 抛出异常：TypeError: 参数必须为数字类型4. 复杂场景中的应用
4.1 检查对象的多种类型
在一些复杂场景中，可能需要检查对象是否属于多种类型之一。
def process_item(item):
if isinstance(item, (int, float)):
print(f"数值类型：{item}")
elif isinstance(item, (list, tuple)):
print(f"序列类型：{item}")
elif isinstance(item, dict):
print(f"字典类型：{item}")
else:
print(f"未知类型：{item}")
process_item(10) # 输出：数值类型：10
process_item(3.14) # 输出：数值类型：3.14
process_item([1, 2, 3]) # 输出：序列类型：[1, 2, 3]
process_item((4, 5, 6)) # 输出：序列类型：(4, 5, 6)
process_item({"a": 1}) # 输出：字典类型：{'a': 1}
process_item("hello") # 输出：未知类型：hello4.2 检查自定义类和子类
在面向对象编程中，使用 `isinstance()` 来检查对象是否属于自定义类或其子类。
class Vehicle:
pass
class Car(Vehicle):
pass
class Bike(Vehicle):
pass
def check_vehicle(vehicle):
if isinstance(vehicle, Vehicle):
print("这是一个交通工具")
if isinstance(vehicle, Car):
print("这是一个汽车")
if isinstance(vehicle, Bike):
print("这是一个自行车")
car = Car()
bike = Bike()
check_vehicle(car) # 输出：这是一个交通工具 这是一个汽车
check_vehicle(bike) # 输出：这是一个交通工具 这是一个自行车4.3 结合 `isinstance()` 和 `getattr()`
在动态属性访问时，结合 `isinstance()` 和 `getattr()` 使用，可以更灵活地处理对象属性。
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def print_attribute(obj, attr_name):
if isinstance(obj, Person):
attr_value = getattr(obj, attr_name, "属性不存在")
print(f"{attr_name}: {attr_value}")
else:
print("对象不是Person类")
p = Person("Alice", 30)
print_attribute(p, "name") # 输出：name: Alice
print_attribute(p, "age") # 输出：age: 30
print_attribute(p, "height")# 输出：height: 属性不存在4.4 多层嵌套类型检查
在处理嵌套数据结构时，可以使用 `isinstance()` 进行多层类型检查。
nested_dict = {
"a": {"b": {"c": 42}}
}
def get_nested_value(d, keys):
for key in keys:
if isinstance(d, dict):
d = d.get(key, "键不存在")
else:
return "不是一个字典"
return d
keys = ["a", "b", "c"]
print(get_nested_value(nested_dict, keys)) # 输出：42
keys = ["a", "x", "c"]
print(get_nested_value(nested_dict, keys)) # 输出：键不存在通过这些示例和扩展，希望你能更全面地理解和应用 `isinstance()` 函数，以提高代码的健壮性和灵活性。