How to Determine an Object’s Type in Python

By the end of this page, you will understand how Python identifies object types, when to use type() versus isinstance(), and how to safely check whether a value is a list, dictionary, or another object in real programs.

In Python, every value is an object, and every object has a type.

For example:

• [] is a list
• {} is a dict
• "hello" is a str
• 10 is an int

To inspect an object's type, Python gives you two common tools:

• type(obj) — returns the exact type of the object
• isinstance(obj, SomeType) — checks whether the object is an instance of a type, including inherited types

In beginner code, type() often seems enough. But in real Python code, isinstance() is usually preferred because it works better with:

• inheritance
• custom classes
• subclasses of built-in types
• cleaner, more flexible validation

Why this matters

Type checking is useful when your code needs to behave differently depending on the input.

Examples:

• Accepting either a single value or a list of values
• Validating API input
• Handling JSON-like data structures
• Writing utility functions that support multiple input types

That said, Python also encourages duck typing: instead of asking "what type is this?", you often ask "can this object do what I need?" Still, explicit type checks are sometimes the clearest and safest option.

Think of every Python object as a package with a label on it.

• type() reads the package's exact label
• isinstance() asks whether the package belongs to a category

For example, imagine a class AdminUser that inherits from User:

• type(admin) is exactly AdminUser
• isinstance(admin, User) is True because an admin is still a kind of user

So:

• use type() when you need the exact label
• use isinstance() when you care about whether something fits a category

The most common ways to check type in Python are:

value = [1, 2, 3]

print(type(value))           # <class 'list'>
print(isinstance(value, list))  # True

Checking for a list

value = [1, 2, 3]

if isinstance(value, list):
    print("This is a list")

Checking for a dictionary

value = {"name": "Ada"}

if isinstance(value, dict):
    print("This is a dictionary")

Checking multiple possible types

value = "hello"

if isinstance(value, (list, dict)):
    print()
:
    ()

Consider this example:

def check_value(value):
    if isinstance(value, list):
        print("list")
    elif isinstance(value, dict):
        print("dict")
    else:
        print(type(value).__name__)

check_value([10, 20])

Step by step

1. Python defines the function check_value.
2. The function is called with [10, 20].
3. Inside the function, value refers to the list [10, 20].
4. Python evaluates isinstance(value, list).
5. Since [10, 20] is a list, the result is True.
6. Python prints "list".
7. The elif and else blocks are skipped.

Type checks appear in many real programs.

Processing JSON-like data

APIs often return nested dictionaries and lists.

def walk_data(data):
    if isinstance(data, dict):
        print("Object with keys:", list(data.keys()))
    elif isinstance(data, list):
        print("Array with", len(data), "items")
    else:
        print("Primitive value:", data)

Accepting flexible input

A function may accept either one item or many items.

def save_tags(tags):
    if isinstance(tags, str):
        tags = [tags]
    print("Saving:", tags)

Validating configuration data

def validate_config():
      (config, ):
         TypeError()

In real codebases, developers usually use type checks in a few common patterns.

Guard clauses

Validate inputs early and fail fast.

def process_user(user_data):
    if not isinstance(user_data, dict):
        raise TypeError("user_data must be a dict")

    return user_data.get("name")

Early normalization

Convert different input forms into one predictable format.

def send_emails(addresses):
    if isinstance(addresses, str):
        addresses = [addresses]

    for address in addresses:
        print("Sending to", address)

Error handling

def total_numbers(values):
    if not isinstance(values, list):
         TypeError()

     (values)

Here are common mistakes beginners make when checking types in Python.

1. Using type() when isinstance() is safer

Broken approach for subclass-friendly code:

class MyList(list):
    pass

value = MyList([1, 2])

print(type(value) is list)        # False
print(isinstance(value, list))    # True

Use isinstance() unless you specifically need the exact type.

2. Comparing type names as strings

Avoid this:

value = [1, 2, 3]

if type(value).__name__ == "list":
    print("list")

This is less clear and less robust than:

 (value, ):
    ()

type() vs isinstance()

# Get exact type
type(value)

# Exact type check
type(value) is list

# Preferred general check
isinstance(value, list)

# Check for multiple types
isinstance(value, (list, dict))

# Get readable type name
type(value).__name__

Rules of thumb

• Use isinstance() for most type checks.
• Use type() when you need the exact type object.
• Use type(value).__name__ for readable messages.
• Prefer behavior-based code when exact type does not matter.

Common built-in types

isinstance(value, list)
isinstance(value, dict)
isinstance(value, str)
isinstance(value, int)
isinstance(value, float)
isinstance(value, tuple)

Edge case

How do I check if a variable is a list in Python?

Use:

isinstance(value, list)

This is the most common and recommended approach.

How do I check if a variable is a dictionary?

Use:

isinstance(value, dict)

Should I use type() or isinstance() in Python?

Usually use isinstance(). It supports inheritance and is more flexible in real applications.

How can I print the type name of an object?

Use:

type(value).__name__

This returns names like list, dict, or str.

Can isinstance() check more than one type?

Yes.

isinstance(value, (, ))

• Duck typing — related because Python often focuses on behavior instead of explicit type checks.
• Classes and objects — related because every Python value is an object with a type.
• Inheritance — related because isinstance() works with subclasses.
• Built-in data types — related because list, dict, str, and int are common types to check.
• TypeError — related because invalid types often lead to this exception.
• Function arguments — related because type checking is often used to validate inputs.
• Truthy and falsy values — related because beginners sometimes confuse type checks with boolean checks.