isinstance()判断一个对象是否为指定类型

1. 基本概念

isinstance() 函数是 Python 内置的函数，用于判断一个对象是否为指定类型或指定类型的子类。其语法如下：

isinstance(object, classinfo)

object：表示要判断类型的对象。

classinfo：可以是单个类型或由多个类型组成的元组。如果 object 是其中任意一个类型或其子类的实例，则返回 True，否则返回 False。

2. 基本用法

2.1 判断单个类型

1
# 判断整数类型
2
print(isinstance(10, int))  # 输出：True
3
 
4
# 判断字符串类型
5
print(isinstance("hello", str))  # 输出：True
6
 
7
# 判断列表类型
8
print(isinstance([1, 2, 3], list))  # 输出：True
9
 
10
# 判断字典类型
11
print(isinstance({"key": "value"}, dict))  # 输出：True
12
 
13
# 判断自定义类类型
14
class MyClass:
15
    pass
16
 
17
obj = MyClass()
18
print(isinstance(obj, MyClass))  # 输出：True

2.2 判断多个类型

可以使用元组传递多个类型，如果对象是其中任意一个类型的实例，则返回 True。

xxxxxxxxxx
4
1
# 判断对象是否为整数或字符串类型
2
print(isinstance(10, (int, str)))  # 输出：True
3
print(isinstance("hello", (int, str)))  # 输出：True
4
print(isinstance(3.14, (int, str)))  # 输出：False

2.3 判断子类

isinstance() 可以用来判断一个对象是否为某个类型的子类的实例。

xxxxxxxxxx
9
1
class Animal:
2
    pass
3
 
4
class Dog(Animal):
5
    pass
6
 
7
dog = Dog()
8
print(isinstance(dog, Animal))  # 输出：True
9
print(isinstance(dog, Dog))     # 输出：True

3. 实际应用

3.1 类型检查和条件执行

在处理函数参数 进行类型检查，确保参数或输入符合预期类型。

xxxxxxxxxx
14
1
def process_data(data):
2
    if isinstance(data, list):
3
        print("处理列表数据")
4
    elif isinstance(data, dict):
5
        print("处理字典数据")
6
    elif isinstance(data, str):
7
        print("处理字符串数据")
8
    else:
9
        print("未知数据类型")
10
 
11
process_data([1, 2, 3])  # 输出：处理列表数据
12
process_data({"key": "value"})  # 输出：处理字典数据
13
process_data("hello")  # 输出：处理字符串数据
14
process_data(42)  # 输出：未知数据类型

3.2 类型多态

在实现多态行为时，使用 isinstance() 确定对象的类型，以便调用适当的方法。

xxxxxxxxxx
24
1
class Animal:
2
    def speak(self):
3
        pass
4
 
5
class Dog(Animal):
6
    def speak(self):
7
        print("Woof!")
8
 
9
class Cat(Animal):
10
    def speak(self):
11
        print("Meow!")
12
 
13
def make_sound(animal):
14
    if isinstance(animal, Dog):
15
        animal.speak()
16
    elif isinstance(animal, Cat):
17
        animal.speak()
18
    else:
19
        print("未知动物")
20
 
21
dog = Dog()
22
cat = Cat()
23
make_sound(dog)  # 输出：Woof!
24
make_sound(cat)  # 输出：Meow!

3.3 数据验证

在数据处理和验证过程中，使用 isinstance() 检查数据类型，确保数据符合预期格式。

xxxxxxxxxx
8
1
def validate_data(data):
2
    if not isinstance(data, (int, float)):
3
        raise ValueError("数据类型必须为整数或浮点数")
4
    print("数据有效")
5
 
6
validate_data(42)     # 输出：数据有效
7
validate_data(3.14)   # 输出：数据有效
8
validate_data("hello")  # 抛出异常：ValueError: 数据类型必须为整数或浮点数

3.4 检查继承关系

在面向对象编程中，使用 isinstance() 检查对象是否是某个类的实例或其子类的实例，以确保对象符合预期的继承关系。

xxxxxxxxxx
20
1
class Shape:
2
    pass
3
 
4
class Circle(Shape):
5
    pass
6
 
7
class Square(Shape):
8
    pass
9
 
10
def check_shape(shape):
11
    if isinstance(shape, Shape):
12
        print("是一个形状对象")
13
    else:
14
        print("不是一个形状对象")
15
 
16
circle = Circle()
17
square = Square()
18
check_shape(circle)  # 输出：是一个形状对象
19
check_shape(square)  # 输出：是一个形状对象
20
check_shape(42)      # 输出：不是一个形状对象

3.5 使用 isinstance() 避免类型错误

在处理涉及多种类型的复杂逻辑时，使用 isinstance() 可以有效避免类型错误，提高代码的健壮性。

xxxxxxxxxx
8
1
def add(a, b):
2
    if not isinstance(a, (int, float)) or not isinstance(b, (int, float)):
3
        raise TypeError("参数必须为数字类型")
4
    return a + b
5
 
6
print(add(3, 4))       # 输出：7
7
print(add(3.5, 2.5))   # 输出：6.0
8
print(add(3, "4"))     # 抛出异常：TypeError: 参数必须为数字类型

4. 复杂场景中的应用

4.1 检查对象的多种类型

在一些复杂场景中，可能需要检查对象是否属于多种类型之一。

xxxxxxxxxx
16
1
def process_item(item):
2
    if isinstance(item, (int, float)):
3
        print(f"数值类型：{item}")
4
    elif isinstance(item, (list, tuple)):
5
        print(f"序列类型：{item}")
6
    elif isinstance(item, dict):
7
        print(f"字典类型：{item}")
8
    else:
9
        print(f"未知类型：{item}")
10
 
11
process_item(10)          # 输出：数值类型：10
12
process_item(3.14)        # 输出：数值类型：3.14
13
process_item([1, 2, 3])   # 输出：序列类型：[1, 2, 3]
14
process_item((4, 5, 6))   # 输出：序列类型：(4, 5, 6)
15
process_item({"a": 1})    # 输出：字典类型：{'a': 1}
16
process_item("hello")     # 输出：未知类型：hello

4.2 检查自定义类和子类

在面向对象编程中，使用 isinstance() 来检查对象是否属于自定义类或其子类。

xxxxxxxxxx
21
1
class Vehicle:
2
    pass
3
 
4
class Car(Vehicle):
5
    pass
6
 
7
class Bike(Vehicle):
8
    pass
9
 
10
def check_vehicle(vehicle):
11
    if isinstance(vehicle, Vehicle):
12
        print("这是一个交通工具")
13
    if isinstance(vehicle, Car):
14
        print("这是一个汽车")
15
    if isinstance(vehicle, Bike):
16
        print("这是一个自行车")
17
 
18
car = Car()
19
bike = Bike()
20
check_vehicle(car)  # 输出：这是一个交通工具 这是一个汽车
21
check_vehicle(bike) # 输出：这是一个交通工具 这是一个自行车

4.3 结合 isinstance() 和 getattr()

在动态属性访问时，结合 isinstance() 和 getattr() 使用，可以更灵活地处理对象属性。

xxxxxxxxxx
16
1
class Person:
2
    def __init__(self, name, age):
3
        self.name = name
4
        self.age = age
5
 
6
def print_attribute(obj, attr_name):
7
    if isinstance(obj, Person):
8
        attr_value = getattr(obj, attr_name, "属性不存在")
9
        print(f"{attr_name}: {attr_value}")
10
    else:
11
        print("对象不是Person类")
12
 
13
p = Person("Alice", 30)
14
print_attribute(p, "name")  # 输出：name: Alice
15
print_attribute(p, "age")   # 输出：age: 30
16
print_attribute(p, "height")# 输出：height: 属性不存在

4.4 多层嵌套类型检查

在处理嵌套数据结构时，可以使用 isinstance() 进行多层类型检查。

xxxxxxxxxx
17
1
nested_dict = {
2
    "a": {"b": {"c": 42}}
3
}
4
 
5
def get_nested_value(d, keys):
6
    for key in keys:
7
        if isinstance(d, dict):
8
            d = d.get(key, "键不存在")
9
        else:
10
            return "不是一个字典"
11
    return d
12
 
13
keys = ["a", "b", "c"]
14
print(get_nested_value(nested_dict, keys))  # 输出：42
15
 
16
keys = ["a", "x", "c"]
17
print(get_nested_value(nested_dict, keys))  # 输出：键不存在

版权声明：

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

原文链接：https://blog.csdn.net/weixin_65190179/article/details/138498641