Mastering Python’s type, object, and class: A Deep Dive into OOP Foundations

Introduction

Understanding the interplay between type, object, and class is essential for mastering Python’s object‑oriented programming.

type Type

type

is a built‑in metaclass used to create new types (i.e., classes). It is itself a class, so you can dynamically generate classes with it.

MyClass = type('MyClass', (), {})
print(MyClass)               # <em>output: <class '__main__.MyClass'></em>
print(type(MyClass))          # <em>output: <class 'type'></em>
print(MyClass.__bases__)      # <em>output: ()</em>

object Type

object

is the ultimate base class for all Python types. If a class does not explicitly inherit from another class, Python automatically makes it inherit from object.

class MyClass:
    pass
print(MyClass.__bases__)          # <em>output: (object,)</em>
print(issubclass(MyClass, object)) # <em>output: True</em>

class Keyword

The class statement defines a new class. In Python 3, using class is effectively calling type under the hood.

class MyClass:
    pass
print(type(MyClass))               # <em>output: <class 'type'></em>
print(MyClass.__bases__)           # <em>output: (object,)</em>

Relationship Between type and class

Both type and class achieve the same result: creating a new type. The following examples show the two equivalent approaches.

# Using type
MyClass = type('MyClass', (), {})
print(MyClass)
print(type(MyClass))
print(MyClass.__bases__)

# Using class
class MyClass:
    pass
print(MyClass)
print(type(MyClass))
print(MyClass.__bases__)

Metaclasses

A metaclass is a class of a class. type is the default metaclass, but you can define custom metaclasses to control class creation.

class Meta(type):
    def __new__(cls, name, bases, attrs):
        attrs['class_name'] = name
        return super().__new__(cls, name, bases, attrs)

class MyClass(metaclass=Meta):
    pass

obj = MyClass()
print(obj.class_name)   # <em>output: MyClass</em>

Inheritance and Multiple Inheritance

Python supports single and multiple inheritance. All classes inherit from object by default.

# Single inheritance
class Base:
    def base_method(self):
        print('Base method')

class Derived(Base):
    pass

obj = Derived()
obj.base_method()   # <em>output: Base method</em>

# Multiple inheritance
class Base1:
    def base1_method(self):
        print('Base1 method')

class Base2:
    def base2_method(self):
        print('Base2 method')

class Derived(Base1, Base2):
    pass

obj = Derived()
obj.base1_method()   # <em>output: Base1 method</em>
obj.base2_method()   # <em>output: Base2 method</em>

Common object Methods

The base object class provides several special methods that can be overridden.

# __str__
class MyClass:
    def __str__(self):
        return 'MyClass instance'
obj = MyClass()
print(str(obj))   # <em>output: MyClass instance</em>

# __repr__
class MyClass:
    def __repr__(self):
        return 'MyClass()'
obj = MyClass()
print(repr(obj))  # <em>output: MyClass()</em>

# __eq__
class MyClass:
    def __eq__(self, other):
        return isinstance(other, MyClass)
obj1 = MyClass()
obj2 = MyClass()
print(obj1 == obj2)  # <em>output: True</em>

Conclusion

In summary, type creates new types, object serves as the universal base class, and the class keyword is syntactic sugar for invoking type. Custom metaclasses allow deeper control over class creation, while Python’s inheritance model supports both single and multiple inheritance, and the base object supplies fundamental special methods such as __str__, __repr__, and __eq__.