isinstance()

isinstance(object, classinfo)

The isinstance() function checks whether an object is an instance of a class or of a subclass thereof. It can also check against a tuple of classes, making it versatile for type validation. This is the Pythonic way to perform type checks, preferred over direct type() comparison because it respects inheritance.

Syntax

isinstance(object, classinfo)

Parameters

Parameter	Type	Default	Description
object	object	—	Any Python object to check. Position-only parameter.
classinfo	class | tuple	—	A class, abstract base class, or tuple of classes. Can also be a union type (3.10+).

Returns: True if object is an instance of classinfo or any class in the tuple; False otherwise.

Examples

Basic type checking

# Check against a single class
print(isinstance(42, int))
# True

print(isinstance("hello", str))
# True

print(isinstance([1, 2, 3], list))
# True

Checking against multiple classes

# Check against a tuple of classes
value = "hello"
print(isinstance(value, (int, str, float)))
# True

value = 3.14
print(isinstance(value, (int, str)))
# False

Inheritance support

isinstance() respects inheritance, unlike type() comparison:

class Animal:
    pass

class Dog(Animal):
    pass

dog = Dog()
print(isinstance(dog, Dog))
# True

print(isinstance(dog, Animal))
# True  # Dog IS an Animal via inheritance

print(type(dog) == Animal)
# False  # type() doesn't respect inheritance

Checking against abstract base classes

from collections.abc import Iterable, MutableSequence

my_list = [1, 2, 3]
print(isinstance(my_list, list))
# True

print(isinstance(my_list, Iterable))
# True  # list implements Iterable

print(isinstance(my_list, MutableSequence))
# True  # list is a MutableSequence

Practical use in functions

def process(data):
    if isinstance(data, str):
        return data.upper()
    elif isinstance(data, list):
        return sum(data)
    elif isinstance(data, dict):
        return len(data)
    else:
        return "Unknown type"

print(process("hello"))
# HELLO

print(process([1, 2, 3]))
# 6

print(process({"a": 1}))
# 1

With custom classes

class User:
    def __init__(self, name):
        self.name = name

class Admin(User):
    def __init__(self, name, permissions):
        super().__init__(name)
        self.permissions = permissions

user = User("Alice")
admin = Admin("Bob", ["read", "write"])

print(isinstance(user, User))
# True

print(isinstance(admin, User))
# True  # Admin is a subclass of User

print(isinstance(admin, Admin))
# True

isinstance() vs type()

Aspect	isinstance()	type()
Inheritance	Respects subclass relationships	Exact match only
Code style	Pythonic	Less pythonic
Multiple types	Supports tuple	Requires multiple comparisons
Abstract bases	Works with ABCs	Doesn’t recognize ABCs

Common Patterns

Type hints validation at runtime

def validate_config(config: dict) -> dict:
    required_keys = ["name", "value"]
    for key in required_keys:
        if key not in config:
            raise ValueError(f"Missing required key: {key}")
    
    if not isinstance(config["value"], (int, float)):
        raise TypeError("value must be numeric")
    
    return config

Duck typing fallback

def get_length(obj):
    # Check if it has __len__ (duck typing)
    if hasattr(obj, "__len__"):
        return len(obj)
    # Fallback to isinstance for known types
    elif isinstance(obj, str):
        return len(obj)
    else:
        raise TypeError("Object has no length")

Processing mixed types

def summarize(items):
    total = 0
    strings = []
    
    for item in items:
        if isinstance(item, (int, float)):
            total += item
        elif isinstance(item, str):
            strings.append(item)
    
    return {"sum": total, "strings": strings}

result = summarize([1, "hello", 2, "world", 3])
print(result)
# {'sum': 6, 'strings': ['hello', 'world']}

Errors

TypeError for invalid classinfo

# Invalid classinfo type
isinstance(42, "int")
# TypeError: isinstance() arg 2 must be a type, a tuple of types, or a union

## See Also

- [built-in::type](/reference/built-in-functions/type/) — returns the type of an object (doesn't respect inheritance)
- [built-in::issubclass](/reference/built-in-functions/issubclass/) — checks class inheritance relationships
- [built-in::hasattr](/reference/built-in-functions/hasattr/) — checks if an object has a specific attribute