The World of Python Programming

How to Check Data Types in Python: A Complete Guide to type(), isinstance(), and More

Data Types & Structures
目次

1. Introduction

Why is type checking important in Python? Python is a dynamically typed language, meaning that the type of a variable or object is determined at runtime. Thanks to its flexible design, you don’t need to explicitly declare types. However, this flexibility can also cause unexpected type errors or runtime issues. Therefore, type checking is crucial for maintaining the reliability and stability of Python programs. In this article, we will explain the main type-checking methods in Python, including type(), isinstance(), and other advanced techniques.

2. Overview of Data Types in Python

Python provides various data types such as numbers, strings, lists, and dictionaries. Each type has specific use cases, and performing type checks helps prevent unexpected errors.

Main Data Types

  • Numeric Types (int, float) Numeric types include int for integers and float for decimal numbers.
  num1 = 10
  num2 = 3.14
  print(type(num1))  # <class 'int'>
  print(type(num2))  # <class 'float'>
  • String Type (str) Used to store text data, defined by enclosing text in single or double quotes.
  text = "Hello, World!"
  print(type(text))  # <class 'str'>
  • List Type (list) A list is an ordered collection that can store multiple elements. Lists are defined using [] and support many operations.
  mylist = [1, 2, 3, 4]
  print(type(mylist))  # <class 'list'>
  • Dictionary Type (dict) Dictionaries store data as key-value pairs, defined using {}.
  mydict = {"one": 1, "two": 2}
  print(type(mydict))  # <class 'dict'>
 

3. Checking Types with the type() Function

The type() function is a basic built-in function used to retrieve the type of a given object. It’s very useful for quickly identifying object types.

Basic Usage of type()

The following example checks the type of a variable using type():
myvar = 1234
print(type(myvar))  # <class 'int'>
You can check other types in the same way:
mystr = "Hello"
print(type(mystr))  # <class 'str'>

Advantages and Limitations of type()

While type() makes type checking simple, it does not account for subclasses. It only checks for exact matches with the specified type.
class Animal:
    pass

class Dog(Animal):
    pass

dog = Dog()
print(type(dog) == Animal)  # False
In this case, although Dog inherits from Animal, type() returns False. To include subclass checks, use isinstance(), introduced next.

4. Checking Types with the isinstance() Function

The isinstance() function checks if an object is an instance of a specific type or its subclass. This allows more flexible type checking with inheritance support.

Basic Usage of isinstance()

Example of using isinstance() to check the type of a variable:
myvar = 1234
print(isinstance(myvar, int))  # True
Since myvar is an int, it returns True.

Checking Against Multiple Types

isinstance() can check against multiple types by passing them as a tuple:
value = 3.14
print(isinstance(value, (int, float)))  # True
This is useful when validating multiple possible types.

Checking Subclasses

Because isinstance() supports subclasses, it can confirm inheritance relationships as well:
class Animal:
    pass

class Dog(Animal):
    pass

dog = Dog()
print(isinstance(dog, Animal))  # True
Here, since Dog inherits from Animal, it returns True.

5. Other Methods of Type Checking

Besides type() and isinstance(), Python provides other ways to check types. These can be chosen depending on the use case.

issubclass() Function

The issubclass() function checks whether a class is a subclass of another class.
class Animal:
    pass

class Dog(Animal):
    pass

print(issubclass(Dog, Animal))  # True

collections.abc Module

The collections.abc module is useful for checking collection types such as lists or dictionaries. Example: verifying if a list is a Sequence.
import collections.abc

mylist = [1, 2, 3]
print(isinstance(mylist, collections.abc.Sequence))  # True

typing Module for Type Hints

The typing module introduces static type checking in Python code. It improves readability and makes debugging easier.
from typing import List

def greet(names: List[str]) -> None:
    for name in names:
        print(f"Hello, {name}!")

Checking for NoneType

NoneType is the type of the special object None. Checking for it helps prevent unexpected errors.
myvar = None
print(type(myvar))  # <class 'NoneType'>
NoneType checks are especially useful for confirming whether a function’s return value is None.

6. Conclusion

Type checking in Python is an essential practice for writing reliable and maintainable code. While Python’s dynamic typing provides great flexibility, it also increases the risk of runtime errors. By understanding and using different type-checking methods such as type(), isinstance(), issubclass(), collections.abc, and type hints from the typing module, you can reduce unexpected issues and improve the stability of your programs. When to use which method depends on the specific situation:
  • Use type() for simple, exact type checks.
  • Use isinstance() when subclass relationships should be considered.
  • Use issubclass() to confirm class inheritance.
  • Use collections.abc to verify collection-related behavior.
  • Use typing for adding static type hints and improving code readability.
By combining these approaches, you can ensure that your Python projects are more robust, easier to debug, and maintainable in the long run.
RUNTEQ（ランテック）｜超実戦型エンジニア育成スクール