Quick answer: Use type(value) when you need the exact concrete type and isinstance(value, SomeType) when you want to check whether an object follows a class or inheritance hierarchy. Prefer behavior-based checks when the interface matters more than the type.
To check data type in Python, use type() when you want to inspect the exact runtime type, and use isinstance() when you want to test whether a value behaves as a member of a class or subclass.
The official Python documentation covers type(), isinstance(), and the built-in standard types.
Use type checks sparingly. Most Python code works best when objects are judged by what they can do, not by a long chain of type tests. Still, runtime checks are useful for validation, debugging, parsing, and clear error messages at the edges of a program.
The examples below show the common cases: displaying a type name, checking one expected type, accepting several types, handling the bool and int relationship, validating collection contents, and writing a small helper.
A good runtime check should sit near the boundary of your program: user input, file parsing, API payloads, command-line options, and public functions. Inside well-tested code, repeated type checks can make logic noisy and harder to maintain.
Also remember that type checking does not replace conversion. If text should become an integer, parse it first and handle conversion errors. If bytes should become text, decode them first. Then validate the shape your code expects.
Check The Exact Type With type
type() returns the exact type of a value.
value = 42
print(type(value))
print(type(value).__name__)
The __name__ attribute is useful when you need a readable type name for logs or messages.
Use type() for inspection and debugging. For most validation, isinstance() is usually more flexible.
Exact type output is helpful in logs because it tells you what Python actually received. That is often faster than guessing from printed values alone.
Check A Type With isinstance
isinstance() returns True when a value matches a type or one of its subclasses.
value = "Python"
if isinstance(value, str):
print("text")
else:
print("not text")
This is the preferred runtime check for many cases.
It is especially useful when custom classes inherit from a base class and should be accepted by the same code.
For example, a custom string-like or path-like class may be designed to work wherever its parent type is accepted. isinstance() respects that relationship.
Accept More Than One Type
Pass a tuple of types when several types are allowed.
value = 12.5
if isinstance(value, (int, float)):
print("number")
else:
print("not a number")
This avoids repeated or checks and keeps the allowed types in one place.
Use this for input that can reasonably arrive in more than one shape, such as integer or floating-point numeric values.
Keep the tuple small and intentional. If many unrelated types are accepted, the function may be doing too many jobs.
Handle bool And int Carefully
In Python, bool is a subclass of int. That means isinstance(True, int) is True.
for value in [True, 1, 0, False]:
print(value, isinstance(value, int), type(value) is int)
Use type(value) is int when you need an exact integer and want to exclude booleans.
This matters in validation code, because True and False can otherwise pass a broad integer check.
When booleans are valid input, check for them directly. When only numeric counts are valid, exclude booleans with an exact type check.
Check Items In A Collection
Use all() with isinstance() to validate every item in a collection.
items = ["red", "blue", "green"]
if all(isinstance(item, str) for item in items):
print("all text")
else:
print("mixed items")
This pattern is helpful for lists read from files, forms, or APIs.
For long collections, validation stops as soon as all() finds the first failing item.
If you need to report every bad item, use a loop and collect the indexes that fail. That gives better error messages for batch imports and form lists.
Write A Small Type Helper
A helper function can centralize runtime type rules and error messages.
def require_text(value):
if not isinstance(value, str):
found = type(value).__name__
raise TypeError(f"expected str, got {found}")
return value.strip()
print(require_text(" Python "))
This keeps validation close to the boundary where data enters your code.
For internal code, clear exceptions are better than silently converting unexpected objects. For user-facing input, return a helpful validation message instead.
Keep helper names specific. A function named require_text should check for text and return text, not also parse numbers or clean unrelated data.
That keeps errors local and easier to fix.
In short, use type() to inspect an exact runtime type, use isinstance() for most checks, pass a tuple when several types are valid, and be careful with bool when checking integers.
Use isinstance() For Input Rules
def total(values):
if not isinstance(values, (list, tuple)):
raise TypeError("expected a list or tuple")
return sum(values)
print(total([1, 2, 3]))
isinstance() accepts a tuple of allowed types and recognizes subclasses. It is usually the right tool when a function can work with several compatible implementations.
Use type() For Exact Inspection
value = True
print(type(value))
print(type(value) is bool)
Exact type comparisons are narrower. They can be appropriate for serialization rules, diagnostics, or code that must distinguish a subclass from its parent, but they can also reject valid compatible objects. Do not use type checks to replace a clear protocol when duck typing is sufficient.
Check Values And Types Separately
A value can have the expected type and still be invalid, such as an empty string, a negative count, or a non-finite float. Validate the type first when it improves the error, then validate the value and the domain rules that the operation actually requires.
Frequently Asked Questions
How do I check a data type in Python?
Use type(value) when you need the exact concrete type, or isinstance(value, SomeType) when subclasses and compatible class relationships should be accepted.
What is the difference between type() and isinstance()?
type(value) returns the concrete type object, while isinstance() tests whether the value is an instance of a class or tuple of classes, including subclasses.
Can isinstance() check multiple types?
Yes. Pass a tuple such as isinstance(value, (str, bytes)) when several accepted classes share an input rule.
Should I check types or behavior?
Use a type check when the API contract requires a class relationship; otherwise validate the required value or operation so compatible implementations are not rejected.