isinstance() 是什么？

isinstance() 是一个 Python 内置函数，它的主要作用是：判断一个对象是否是某个类或其子类的实例。

它的语法非常简单：

isinstance(object, classinfo)

• object: 你想要检查的对象。

• classinfo: 可以是一个类,或者一个由多个类组成的元组。

• 返回值:

  • object 是 classinfo 指定的类或其子类的实例，则返回 True。
  • 否则，返回 False。

基本用法

让我们从最简单的例子开始。

示例1：检查基本数据类型

Python 的基本数据类型（如 int, str, list）本身就是类。

# 检查一个整数
num = 10
print(isinstance(num, int))  # 输出: True
# 检查一个字符串
name = "Alice"
print(isinstance(name, str))  # 输出: True
# 检查一个列表
my_list = [1, 2, 3]
print(isinstance(my_list, list))  # 输出: True
# 检查一个整数是否是字符串类型
print(isinstance(num, str))  # 输出: False

示例2：检查自定义类的实例

这是 isinstance() 更常见的用法。

class Animal:
    pass
class Dog(Animal):
    """Dog 是 Animal 的子类"""
    pass
class Cat:
    pass
# 创建实例
my_dog = Dog()
my_cat = Cat()
my_animal = Animal()
# 检查 my_dog
print(isinstance(my_dog, Dog))      # 输出: True (my_dog 是 Dog 的实例)
print(isinstance(my_dog, Animal))   # 输出: True (因为 Dog 继承自 Animal，my_dog 也是 Animal 的实例)
print(isinstance(my_dog, Cat))      # 输出: False (my_dog 和 Cat 没有关系)
# 检查 my_cat
print(isinstance(my_cat, Cat))      # 输出: True
print(isinstance(my_cat, Animal))   # 输出: False (Cat 没有继承 Animal)
# 检查 my_animal
print(isinstance(my_animal, Animal)) # 输出: True
print(isinstance(my_animal, Dog))    # 输出: False

核心要点：isinstance() 会考虑继承关系，如果一个对象是子类的实例,那么它也必然是其父类的实例。

检查对象是否为元组中任意一个类的实例

classinfo 参数可以是一个元组，用来检查对象是否是元组中任意一个类的实例,这在需要检查多种类型时非常有用。

def process_value(value):
    if isinstance(value, (int, float)):
        print(f"这是一个数字，我可以进行数学运算: {value * 2}")
    elif isinstance(value, str):
        print(f"这是一个字符串，我可以进行拼接: '{value} - 处理完毕'")
    else:
        print("我不认识这种类型的数据。")
process_value(10)        # 输出: 这是一个数字，我可以进行数学运算: 20
process_value(3.14)      # 输出: 这是一个数字，我可以进行数学运算: 6.28
process_value("hello")   # 输出: 这是一个字符串，我可以进行拼接: 'hello - 处理完毕'
process_value([1, 2])    # 输出: 我不认识这种类型的数据。

isinstance() 与 type() 的区别

这是一个非常重要的知识点，初学者常常混淆 isinstance() 和 type()。

• type(obj): 返回对象的精确类型，它只关心对象本身是什么,不考虑继承关系。
• isinstance(obj, class): 返回 True 或 False，判断对象是否是指定类或其父类的实例。

让我们用之前的例子来对比：

class Animal:
    pass
class Dog(Animal):
    pass
my_dog = Dog()
# 使用 type() 检查
print(type(my_dog) is Dog)        # 输出: True (精确类型是 Dog)
print(type(my_dog) is Animal)     # 输出: False (精确类型不是 Animal)
# 使用 isinstance() 检查
print(isinstance(my_dog, Dog))     # 输出: True
print(isinstance(my_dog, Animal))  # 输出: True (考虑了继承关系)

结论与最佳实践：

• 如果你想严格检查对象的类型，不考虑继承关系，使用 type()。
• 在绝大多数情况下，特别是在处理面向对象编程、多态和鸭子类型时，你应该优先使用 isinstance()，因为它更符合“是一个...”的逻辑，并且能让你的代码更具扩展性（isinstance(my_dog, Animal) 可以处理所有 Animal 的子类，而 type() 不行）。

与 numbers 模块结合使用

Python 的 numbers 模块定义了数字类型的抽象基类,这对于泛型编程非常有用。

• numbers.Number: 所有数字类型的顶层抽象基类。
• numbers.Integral: 整数类型（如 int）。
• numbers.Real: 实数类型（如 float, int）。
• numbers.Complex: 复数类型（如 complex）。

import numbers
num_int = 10
num_float = 3.14
num_complex = 1 + 2j
# 检查是否是数字
print(isinstance(num_int, numbers.Number))    # True
print(isinstance(num_float, numbers.Number))   # True
print(isinstance(num_complex, numbers.Number)) # True
# 检查是否是实数
print(isinstance(num_int, numbers.Real))      # True (int 是 Real 的子类)
print(isinstance(num_float, numbers.Real))     # True
print(isinstance(num_complex, numbers.Real))   # False (complex 不是 Real 的子类)
# 检查是否是整数
print(isinstance(num_int, numbers.Integral))   # True
print(isinstance(num_float, numbers.Integral)) # False

实际应用场景

场景1：函数参数类型检查（防御性编程）

在函数开头，使用 isinstance() 来确保传入的参数是期望的类型,避免后续操作出错。

def add_to_list(element, my_list):
    """将元素添加到列表中"""
    if not isinstance(my_list, list):
        raise TypeError("第二个参数 'my_list' 必须是一个列表")
    my_list.append(element)
    return my_list
my_list = [1, 2, 3]
add_to_list(4, my_list)
print(my_list)  # 输出: [1, 2, 3, 4]
# 这会抛出 TypeError
# add_to_list(5, "hello")

场景2：多态和鸭子类型

isinstance() 是实现多态的关键，你可以编写一个函数，接受所有属于某个基类的对象，并对它们执行相同的操作,而不用关心它们的具体子类是什么。

class Animal:
    def speak(self):
        raise NotImplementedError
class Dog(Animal):
    def speak(self):
        return "Woof!"
class Cat(Animal):
    def speak(self):
        return "Meow!"
# 这个函数可以处理任何 Animal 或其子类的实例
def let_animal_speak(animal):
    if isinstance(animal, Animal):
        print(animal.speak())
    else:
        print("这不是一个动物，它不会说话。")
let_animal_speak(Dog())   # 输出: Woof!
let_animal_speak(Cat())   # 输出: Meow!
let_animal_speak("Tom")   # 输出: 这不是一个动物，它不会说话。

记住这个核心原则：当你想问“这个东西是不是一个...？”时，用 isinstance()，它能让你写出更健壮、更具扩展性的代码。