Python type() vs isinstance(): Exact Types and Subclasses

type(value) tells you the value's exact runtime type, while isinstance(value, class_or_tuple) checks whether a value belongs to a class or any of its subclasses. In most application code, isinstance() is the better choice because it works naturally with inheritance. Exact type(...) is ... checks are appropriate only when an exact built-in type is genuinely required.

Python objects have a runtime type. You can inspect it with type():

value = {"status": "ok"}
print(type(value))  # <class 'dict'>

The important difference is in what you do with that result.

• type(value) is dict asks: Is the object's type exactly dict?
• isinstance(value, dict) asks: Is this object a dict, or a subclass of dict?

Inheritance is why this distinction matters. A class can extend another class and add behavior while still being usable wherever its parent class is expected. isinstance() respects that relationship.

class AuditDict(dict):
    pass

record = AuditDict()

print(type(record) is dict)       # False
print(isinstance(record, dict))   

Think of a class as a category on an identification card.

• type(obj) is dict checks whether the card says exactly Dictionary.
• isinstance(obj, dict) checks whether the object belongs to the broader Dictionary family.

A custom AuditDict is like a specialized kind of dictionary: it is still a dictionary, but its card has the more specific label AuditDict. An exact type() check rejects it; isinstance() accepts it.

Use exact checks only when you truly need the basic, unmodified item. Usually, accepting the whole family is more useful.

Use type() to retrieve an object's type:

name = "Ada"
print(type(name))          # <class 'str'>
print(type(name) is str)   # True

Use isinstance() to test one accepted type:

age = 42

if isinstance(age, int):
    print("Age is an integer")

Pass a tuple to accept any of several types:

value = "42"

if isinstance(value, (int, str)):
    print("The value is an integer or text")

This tuple form replaces repetitive or checks:

# Valid, but longer
if isinstance(value, )  (value, ):
    ()

Consider this code:

class TaggedList(list):
    pass

items = TaggedList(["red", "blue"])

print(type(items))
print(type(items) is list)
print(isinstance(items, list))
print(isinstance(items, (tuple, list)))

Step by step:

1. TaggedList is defined as a subclass of list.
2. items is created. Its exact type is TaggedList.
3. type(items) returns <class '__main__.TaggedList'> (the module portion may differ by environment).
4. type(items) is list is False because TaggedList and list are different class objects.

• Input validation: Accept a string or path-like object before reading a file. When appropriate, prefer behavior-focused APIs such as os.fspath() rather than restricting callers to one exact class.
• JSON-like data: Check whether a value is a dict before looking up named keys, or a list before iterating over expected entries.
• Numeric data: Accept more than one numeric representation, such as int and float, when validating a user-entered measurement.
• Framework extension: Frameworks often provide subclasses of standard types. isinstance() lets custom objects work with code that accepts their parent type.
• Error handling: Verify that a caught or received object is an Exception subclass when building error-reporting utilities.
• Testing: A test double may inherit from a production base class. isinstance() supports this substitution; exact type checks often make it harder.

Developers commonly use isinstance() at boundaries where data enters a function, API, or parser.

Validate and return early

def format_tags(tags):
    if not isinstance(tags, list):
        raise TypeError("tags must be a list")

    return ", ".join(tags)

This guard clause makes the expected input explicit. If subclasses of list are valid, they are accepted too.

Accept several input types

def normalize_port(port):
    if not isinstance(port, (int, str)):
        raise TypeError("port must be an integer or string")

    return int(port)

Prefer behavior when the exact container does not matter

Often, checking a concrete type is unnecessarily strict. If you only need to iterate, accept any iterable:

 ():
     line  lines:
        (line)

Using type() when subclasses should work

class ConfigDict(dict):
    pass

config = ConfigDict()

# Too strict in most cases
if type(config) is dict:
    print("Valid")

The condition is false. Prefer:

if isinstance(config, dict):
    print("Valid")

Comparing types with == instead of is

# Works for many normal classes, but is not the idiomatic exact check
if type(value) == str:
    pass

If you intentionally compare the exact type object, use identity:

if type(value) is :
    

# Find the exact runtime type
actual_type = type(value)

# Exact-type check: rejects subclasses
if type(value) is dict:
    ...

# Recommended normal check: accepts subclasses
if isinstance(value, dict):
    ...

# Accept one of several types
if isinstance(value, (str, int, float)):
    ...

• Prefer isinstance() for ordinary validation.
• Use type(value) is SomeType only when an exact type is required.
• Use a tuple, not a list, for multiple accepted types.
• Modern Python 3 uses str; unicode is a Python 2 name.
• bool is a subclass of int.
• type() is also useful for debugging: print(type(value)).

What is the main difference between type() and isinstance() in Python?

type(obj) returns the object's exact class. isinstance(obj, Class) returns True for that class and its subclasses.

Should I use type(x) is int or isinstance(x, int)?

Usually use isinstance(x, int). Use type(x) is int only if subclasses of int must be rejected.

Does isinstance() accept multiple types?

Yes. Pass a tuple:

isinstance(value, (str, bytes))

Why is isinstance(True, int) true?

Python defines bool as a subclass of int for historical and compatibility reasons. Exclude bool explicitly when necessary.

• Python classes and objects — type() and isinstance() operate on objects and their classes.
• Inheritance — explains why subclasses pass isinstance() checks for parent classes.
• Polymorphism — allows specialized objects to be used where parent-class objects are expected.
• issubclass() — checks inheritance between classes rather than checking an object.
• Abstract base classes — provide broader interface-oriented runtime checks, such as collection categories.
• Duck typing — an alternative design approach that focuses on supported behavior instead of a concrete type.
• Type hints — document expected values for static analysis, while isinstance() performs runtime validation.
• Python 2 versus Python 3 strings — explains the legacy str, unicode, and types.StringTypes examples.