What exactly is "object" in Python?

Perhaps a good summary is:

In Python everything is an object and everything else doesn't exist, plus every object has a type. And yes, a type is also an object...

It is common that, when supporting OOP in a language, there is a metaclass from which the other classes derive and a root class from which all objects derive. For example, in Smalltalk there is Classand Objectrespectively. Well, we could think that in Python its equivalents are typeand object, but if, as mentioned above, everything is an object, typeit is also an object and therefore it should derive from object. Since objectit's a class, it should derive from type... which brings us to a classic question in philosophy and which is your question in essence:

What came before the egg or...? Excuse me, the object or the type?

Everything in Python revolves around the concept of "object", it's Python's abstraction for representing data. All data in Python is represented by objects or by relationships between them.

Every object has three characteristics:

• An identity : it is unique to each object and never changes as long as it exists. In CPython the memory address of the object is used. It is what the identity operator ( is) compares and what the builtin id()returns.

• A value : the data represented by the object, the value can change in mutable objects like lists. In immutable objects such as strings cannot be modified after the instance of the object.

• A type : The type (or class) of an object is the class of which it is an instance. A class is also an object and therefore has a type, the type of these objects is type. It typeis also an object and its type is also type, the only object with this characteristic.

Conceptually, since Python 2.2 "type" and "class" are the same.

object

The class objectis the base of the class hierarchy in Python. All classes are subclasses of the class of object, therefore all objects are instances of object. This class contains the basic skeleton of a class, from it come the essential methods that every class has, such as __getattribute__, methods that we can always call from a subclass to, for example in the case of ' __getattribute__', make it impossible for private attributes to exist in Python by much that we insist...

Remember, that a class itself is also an object, an object stored in memory with the instructions to build other objects.

>>> import sys
>>> isinstance(sys, object)
True

>>> isinstance(str, object)
True

>>> class Foo: pass
>>> isinstance(Foo, object)
True

>>> isinstance(type(type), object)
True

>>> isinstance(object, object)  # ?????
True

>>> isistance("El Universo", object) # !!!!!
True

type

Defined in C ( PyObject* PyType_Type), it is the only built-in metaclass in CPython. A metaclass is simply a class whose instances are also classes.

Just as we affirm that everything is an object, everything has a type , yes, objectalso...

>>> type(object)
type

but unlike object, not everything is a type (or derives from type):

>>> import sys
>>> isinstance(sys, type)
False

>>> isinstance(str, type)
True

>>> class Foo: pass
>>> isinstance(Foo, type)
True

>>> isistance("El Universo", type)
False

Everything looks like a mess, it may seem that typeand objectmutually inherit from each other, but this is not really true, in fact this is intrinsically conceptually impossible in OOP. In addition, we must always keep in mind that we are moving at a level where OOP does not really exist, it is being created. CPython is implemented in C and C does not understand OOP. Neither objectinherits from typenor typefrom objectat this level, there is simply no inheritance.

More than inheriting each other, what happens is that it objectis an instance of typeand typederives from object. Indeed, there is still a cyclical relationship that is resolved at the C level in several steps and with several indirections in between that I am not going to go into.

At the Python level, the small paragraph at the beginning of the answer must always be true to respect the data model:

• Since everything is an object, typeit has to be an object to exist.
• Since objectit is the base type of all objects, it is a type and as a type it must be an instance of type.

If we abstract away from all the implementation and conceptual details, we could be left to not disturb our existence with the following:

The base class for every object is object(other than its own of objectcourse), always, always, always:

>>> class Foo(): pass
>>> Foo.__bases__
(object,)

>>> object.__bases__
()

>>> type.__bases__
(object,)

Every object has a type, which is simply the class of which it is an instance, so type and class are equivalent concepts. Very nice so far, but if every object has a type and a class is also an object, what type do we assign to a "class" object? This is precisely where it comes in type, it is the type of every "class" object, including objectand typeitself.

The class typeexposed through the builtin type()allows us to create new types/classes dynamically, as a good metaclass allows us to create instances that are classes, but does anyone guess at this point what is the base class of the classes it typegenerates for us?

>>> new = type("Bar", (), {})

>>> type(new)
type

>>> new.__bases__
(object,)  # No podía ser de otra forma....

Always keep in mind the distinction between deriving/inheriting and being an instance of something. One thing is "being an instance of X" and quite another "being a class that derives from X":

class Foo():
    pass

class Bar(Foo):
    pass

foo = Foo()

foois an instance of Foo, but does not inherit from it, instead Barif it derives from Foo, but is not an instance of it.

Summary

• Every object except its own objectderives from object, otherwise it does not exist.

• The metaclass typeas an object that exists, derives from object.

• The metaclass typecreates other classes that all, without exception, derive from object.

• So it objectdoesn't derive/inherit from anything, but typeit is an instance of object.

• As much objectas typethey are classes, then their type is type, so it typeis the only class in which the following is true:

  type(type) == type
  

Therefore we can consider that a class/type is an instance of typeand always derives from object.

>>> isinstance(object, type)
True

>>> issubclass(object, type)
False

>>> isinstance(type, object)
True

>>> issubclass(type, object)
True

What a most interesting question. I share my answer with reference to the official documentation of the language, but also based on my personal experience in the deepest point of your question.

And out of curiosity to know more about object, it seems that all classes inherit or descend from it:

Indeed, according to the language documentation, https://docs.python.org/3/library/functions.html#object , object objectis an object of type class, and is a base for all other classes. That is why all classes, including those built into the language, such as int, dict, set, list, etc., have the object as one of their base classes object.

On the other hand object is an instance of type:

>>> object.__class__
<class 'type'>
>>> isinstance(object, type)
True

What doesn't work for me at all is this:

>>> isinstance(type, object)
True

How can type be an instance of object if object is supposed to be an instance of type? Has no sense. I mean python is contradicting itself... In addition to this object is a base class of type:

>>> type.__bases__
(<class 'object'>,)

But according to python object is an instance of type and according to that, how is it possible for a class (type) to inherit from an instance (object) of said class?

Without a doubt, this is very confusing by virtue of the above. In my experience there is no contradiction: following the documentation, the object objectis the class from which all the others derive; we can explore further, and we will find that it typeis a subclass of object,

issubclass(type, object)  # -> True

but it is not true that objectit is a subclass of type. So, objectit is instance (instance) of typeby design, to show that it objectis a class (or else, an object of type class), and all classes are objects whose type is type( https://docs.python.org/3/ reference/datamodel.html ), even if objectit doesn't get from the object = type("object", bases=(), dict=some_dict). Analogously it happens with type.

So based on this, what exactly is type and object? Which of the two is the "true" metaclass or "the class that creates classes" so to speak?

type('MyClass', (), {})

At this point there is no further confusion. The object objectis the base of all classes, and contains the methods common to all instances of any class, even if these instances are classes themselves. When you call it in the form object(), it returns an object with no features or attributes ( https://docs.python.org/3/library/functions.html#object ), so it doesn't create classes. The object typeis a class, and therefore its type is itself: type. Calling it with three arguments is a dynamic way to create a class instead of declaring class https://docs.python.org/3/library/functions.html#type . The class that creates classes is type(is a metaclass), and so all classes are instances of type.