What are classes really (Python)?

wow! Interesting question, complex answer. Although it could be answered at different levels (it's the nice thing about python, you can stay at one level for years without needing anything from the lower level).

Highest level. Classes are templates

A class is a template that allows you to create objects. This explanation is wrong in the sense that the created objects are not mere "copies" of the class, but rather contain references to the class, to avoid for example duplicating the code of the methods, as @jachguate mentions in his answer . However, you can work with that mental model without finding cracks for quite some time.

However, that explanation does not clarify why you have to put a parameter selfin each of the class methods. Or the difference between a class attribute and an object attribute. Or between a staticmethod and a normal method.

So let's dig a little deeper.

Medium level. classes are objects

Everything in python is objects. A function is an object. A class is also an object, but it has the ability, when called, to create new objects. They are in fact the only way to create user-defined objects.

Then perhaps it is necessary to clarify before what is an object? .

Deep down we could say that an object is a dictionary. In fact, it is implemented as such, but it offers other ways to interact with it. Within every object there is a predefined named attribute called __dict__and that is the dictionary that contains all the object's attributes and their values.

For example, as stated before, a function is an object. When you write:

def f():
  "Ejemplo"
  return 0

An object of type is created function, and a reference fpointing to that object is created function. The reference is nothing more than a name, and you can think of it as a pointer. The function itself is not f, but the object functionit fpoints to. Being an object, it has its __dict__that we can consult:

>>> f.__dict__
{}

It is empty by default because functions, although they are objects, by default have no attributes. Nothing would prevent us from creating them (although it's not common practice, but they can sometimes be used to store data in them that persists between different invocations of the function):

>>> f.test = 1
>>> f.__dict__
{'test': 1}

But there are not only attributes in objects. They actually contain more things, like a documentation (stored in your .__doc__), or a reference to their type (the class they are an instance of), stored in your .__class__. In this example:

>>> f.__doc__
'Ejemplo'
>>> f.__class__
<class 'function'>

So we see that it fis actually an instance of <class 'function'>, but that class is itself an object, so it will also have its .__doc__, .__dict__and even .__class__:

>>> f.__class__.__doc__
'Create a function object.\n\n  code\n    a code object\n  globals\n    the globals dictionary\n  name\n    a string that overrides the name from the code object\n  argdefs\n    a tuple that specifies the default argument values\n  closure\n    a tuple that supplies the bindings for free variables'
>>> f.__class__.__dict__
mappingproxy({'__repr__': <slot wrapper '__repr__' of 'function' objects>, '__call__': <slot wrapper '__call__' of 'function' objects>, '__get__': <slot wrapper '__get__' of 'function' objects>, '__new__': <built-in method __new__ of type object at 0x10f369880>, '__closure__': <member '__closure__' of 'function' objects>, '__doc__': <member '__doc__' of 'function' objects>, '__globals__': <member '__globals__' of 'function' objects>, '__module__': <member '__module__' of 'function' objects>, '__code__': <attribute '__code__' of 'function' objects>, '__defaults__': <attribute '__defaults__' of 'function' objects>, '__kwdefaults__': <attribute '__kwdefaults__' of 'function' objects>, '__annotations__': <attribute '__annotations__' of 'function' objects>, '__dict__': <attribute '__dict__' of 'function' objects>, '__name__': <attribute '__name__' of 'function' objects>, '__qualname__': <attribute '__qualname__' of 'function' objects>})
>>> f.__class__.__class__
<class 'type'>

This already allows us to differentiate a little better between a class and an instance of the class. They are both objects, but they contain different information.

When you write a class of your own, such as:

class C:
  x = 1
  def __init__(self, n=0):
     self.n = n
  def metodo(self):
     return self.n

We create an object of type class, which has its own __dict__, inside which there are among other things the keys "x", "__init__"and "metodo". The first contains simply an integer (1) and the following contain a function-object (called C.__init__and C.metodo, respectively)

When you instantiate that class to create an object, for example with

o = C(3)

its initializer is executed which does the assignment self.n=3. At that moment selfit is the newly created object, therefore a new object. The attribute nwill be part of o.__dict__, but not part of C.__dict__.

>>> o = C(3)
>>> o.__dict__
{'n': 3}

As we can see, in the dictionary othere is only the key 'n'. However that does not prevent us from trying to access o.x:

>>> o.x
1

It so happens that python will first look for an attribute called "x"within o.__dict__. If you find it, it will be over there. If it doesn't find it, it will use o.__class__to know the class of which it is an instance, and then it will use o.__class__.__dict__to search there "x", where it will find it with value 1. That is why all the instances of that class share that attribute, because it is not in each object but in the class.

By the way, this behavior applies only to reading the attribute. If we assign it instead, that will always create a new entry in the __dict__object's:

>>> o.x = 100
>>> o.__dict__
{'n': 3, 'x': 100}
>>> o.__dict__["x"]
100
>>> o.__class__.__dict__["x"]
1

The methods operate in a similar way (at least at the level we are explaining now, which is not the deepest yet). When we do o.metodo(), we look "metodo"for o.__dict__it and when we don't find it, we look for o.__class__.__dict__where we find it, which is a reference to a function. At that point Python transforms it into what it calls an "instance method" (but does not alter o.__dict__), which is a special function that will receive as its first parameter the concrete object through which it was called.

In other words, it o.metodo()is basically equivalent to:

>>> o.__class__.__dict__["metodo"](o)
3
>>> o.metodo()
3

And there are even more levels

Actually, looking for an attribute on an object is something that can be redefined. What I explained before is how it's done by default , but if the class Cdefined a method called __getattribute__(), then python would use it to look up the given attribute in o. So that o.foowould translate to C.__getattribute__(o, "foo"), and that function could decide to return anything, thereby skipping the role of o.__dict__and C.__dict__.

This in turn can be made more complex by taking inheritance (and the possibility of multiple inheritance) into account, which would cause recursive calls "up" the inheritance tree, according to a well-defined order (MRO). And we should talk about the protocol descriptor

And I didn't want to go into how the object itself is created, which is something that python normally takes care of, but which we have control over as well if we want, by implementing the special method __new__()in the class. That method is the one that must return the newly created object on which it will be applied later __init__().

All the details are of course in the data model documentation

Leaving aside the conceptual part of the class as a template , if you look at it from another point of view, at runtime each instance of Personahas to have all its attributes ( nombre, apellido, etc). If you have 1,000 people (and ignoring other optimizations), there will be 1,000 first names, 1,000 last names, etc. in memory.

However, a method, say saludar(), will exist in memory only once (both the code to execute it and the reference to this code).

Since they only have to be there once, these attributes are stored in the class itself, and not in each instance, where it wouldn't make much sense.

When you call the method on an instance, say juan.saludar(), what happens behind the scenes is that it juanhas a pointer to the class Persona(its class) and this class is the one with the pointer to the method code saludar(). The call is constructed by passing to said function, as its first parameter, the pointer to the instance on which it is going to operate (the self-parameter self), in this case, a reference to juan.

In other words, calling juan.decir('hola')is the equivalent of calling Persona.decir(juan, 'hola'), which I don't know if it can be done that way, but that's what the call translates into .

The underlying model that python operates on is quite different from c++ and other compiled languages... in that it is at compile time that many of these references are resolved and memory addresses of attributes are computed, making it less flexible to the model.

In python, since everything is resolved at run time, you can more freely manipulate the structure of a class or its instances, even after having copies in memory, in a way that you couldn't do in c++ or Pascal, for example. mention some languages.

Complementing the given answer a bit, what happens when a class is created and it is instantiated, an empty object is created, which is often filled with a constructor __init__ . Let's take an example:

class persona():
    pass
    #puedes crear métodos pero igual se creará un objeto vacío al instanciarlo

persona_nueva = persona() #crea un objeto vacío

In your case, you define a constructor __init__, this makes the class immediately call this method in which the attributes are assigned, these are created when the class is instantiated (calling an object __call__). What will happen here will be, effectively, what will be in memory the same number of instances and attributes you have (#a*#i) as explained in the other answer.

On the other hand, the methods are functions, which are executed when the function is called and therefore create and assign the variables when they are called, a function when called from an instance generates a pointer to such a class, this is already I explain why I will leave it here.

When a class is created, it is executed in a new execution frame using newly created local names, this has to do with the scope of a class, but what happens when it ends? When a new object has already been created, its execution frame execution is discarded, however it saves the local namespace.

Inheritance
Inheritance is something fundamental in object-oriented programming, when the class object is constructed, the base class is taken into account, this helps to resolve references of requested attributes and methods that are not found, to which python proceeds to search in the base class, All the classes that you create inherit by default from a base class objectthis class has all the methods that are common to all the instances, this class does not have a method __dict__which does not make it possible to assign attributes to the instance of this class.

What is scope?
Earlier we talked about the scope of a class. The scope is the visibility of a name in a block, something similar to var, letjavascript, the first indicates that the variable will be accessed from anywhere and the second that it only works in a specific block. When a name is not found an exception is thrown NameError. You have to remember that python binds the variables, here is a small example, it is not on the same topic but it serves to explain it.