What Are Python's Built-in Data Types?

Python's built-in types fall into a few families. There are numbers, sequences, mappings and sets, plus the two special types None and bool. The quickest way to show them is to build one value from each family and then ask the interpreter what that value is.

values = {
    'int': 10,
    'float': 3.5,
    'complex': 2 + 3j,
    'str': 'python',
    'bytes': b'ab',
    'bool': True,
    'list': [1, 2, 3],
    'tuple': (1, 2),
    'set': {1, 2},
    'dict': {'a': 1},
    'range': range(3),
}

for name in values:
    value = values[name]
    print(name, '->', type(value).__name__, '->', repr(value))

The output pairs each value with its type name. You get int, float, complex, str, bytes, bool, list, tuple, set, dict and range.

Two observations are worth making out loud. First, the built-in sequence types, which are str, bytes, list and tuple, share the same set of abilities. They all support len(), they all let you index into them, they all let you take a slice, and they can all be used in a for loop. That shared interface is the reason so much Python code can be written once and used with many different kinds of data. Second, there is no separate type for a single character and no separate type for an array of whole numbers. A character is simply a string with one character in it, and there is no built-in numeric array type, because that is what the array module is for.

Also notice that range is a type in its own right and not a function that returns a list. It produces its numbers as they are needed, so it uses very little memory. That is the reason that a for loop over a large range does not allocate anything up front.

type() tells you the exact class of an object. isinstance() asks whether an object is an instance of a class or of any class below it, and it also accepts a tuple of classes so that you can test several types at once.

print(type(42))                       # <class 'int'>
print(type(42) is int)                # True
print(isinstance(42, int))            # True


class MyInt(int):
    pass


print(isinstance(MyInt(1), int))      # True, because a subclass counts
print(type(MyInt(1)) is int)          # False, the exact type is MyInt

# bool is a subclass of int in Python.
print(isinstance(True, int))          # True
print(type(True) is bool)             # True

# You can test several types at once.
print(isinstance('text', (int, str)))  # True

The behaviour with subclasses is the important difference, and it is the source of a well-known interview trap. Because bool is a subclass of int, the check isinstance(True, int) gives you True. Code that means to exclude booleans has to say isinstance(value, int) and not isinstance(value, bool), because the integer check on its own lets booleans through.

Another trap is writing type(x) == int instead of using isinstance(). That form fails for every subclass, so a class that derives from int, or from str, or from a framework's own base class, would slip past the check without any warning at all.

The rule of thumb is short. Use isinstance() when you care that a value behaves like the type, and use type() when you care that the value is exactly that type. In production code, isinstance() is almost always the right choice.

The types are related to each other by widening, and not by accident. An int can be used anywhere a float is expected, and a float can be used anywhere a complex is expected. Python allows that change to happen by itself, so that you do not have to cast by hand every time. The mechanism is registration, because int, float and complex each register themselves with the numbers module. bool inherits from int, so it sits at the bottom of the integer side of the hierarchy.

The consequence that trips people up is that bool is a subclass of int. That means True + True is 2, True * 3 is 3, and isinstance(True, int) is True. It also means that a function which uses isinstance(value, int) to detect an integer will happily accept True and False unless you exclude bool yourself.

The other consequence is that the hierarchy is shallower than it looks. Python 3 merged the old int and long types into a single arbitrary-precision int, and there is no separate long type any more. Decimal and Fraction are not part of the arithmetic hierarchy at all. They live in the decimal and fractions modules, and they mix with int and float through an explicit conversion rather than through inheritance.

A useful way to phrase this in an interview is that the numeric tower exists so that widening changes are legal without explicit casts, and that bool inherits from int for historical reasons tied to the same design. If you want to reason about types strictly rather than by widening, then use type() checks, or better still, express the intent with type hints and let a checker enforce it for you.