What is self used for in OOP in Python?

In Python almost everything is an object, unlike other languages, a class is an object as well, it sounds weird but it really is like this:

class Prueba():
  pass

p = Prueba()

print(type(Prueba))
print(type(p))

> <class 'type'>
> <class 'Prueba'>

We can see that the class Pruebais an object of type <class 'type'>and the instantiated object is now if, of type <class 'Prueba'>. With this in mind it may be clearer why the use of the self. Suppose something similar to your example:

class Persona:

    def __init__(self,nom):
        self.nombre=nom

    def imprimir(self):
        print("Nombre: {0}".format(self.nombre))

p1 = Persona("Juan")
p2 = Persona("Pedro")
print(type(Persona))
print(type(p1))
print(type(p2))

> <class 'type'>
> <class 'Persona'>
> <class 'Persona'>

We have used the object Personaof type <class 'type'>(class) to create two new objects of <class 'Persona'>. The normal way to access methods would be to do this:

p1.imprimir())
p2.imprimir())
> Juan
> Pedro

But what is actually happening underneath, that is, what Python is actually doing, is something like this:

Persona.imprimir(p1))
Persona.imprimir(p2))
> Juan
> Pedro

One way to see this is that each instance p1and does not have p2"copies" of the method imprimirdoes not make sense, the method belongs to the class Persona, the data self.nombredoes belong to each instance. So in order for it to be Personaable to be invoked imprimirbut with the proper instance data, you need to declare the method as imprimir(<instancia>).

Clarification: selfit is a convention we could use any name but it is not recommended.

To complete and to take into account. The use of selfis a convention in Python, a good practice but not a rule (it's not a reserved word or anything like that).

By this I mean that you can use any name to represent the class instance:

>>> class A:
...   def __init__(instancia, numero):
...     instancia.numero = numero
...   def get_numero(instancia):
...     return instancia.numero
... 
>>> a = A(10)
>>> a.get_numero()
10

For Python this is a perfectly normal class. In the class AI have changed the selfto instancia. Note , this is just a clarification.

You may also come across some methods that lack selfsuch as when using static methods:

>>> class A:
...   def __init__(self, numero):
...     self.numero = numero
...   @staticmethod
...   def saludo():
...     print('Hola')
... 
>>> a = A(10)
>>> a.saludo()
Hola

The use of selfas the first argument of methods is specified in Function and method arguments of PEP 8 (the style guide for Python code).

The parameter selfrefers to the instantiated object of that class on which said method is being invoked. That is, the object you used to call the method (in your example persona1and persona2).

Python, within the defined methods of a class, establishes that the first parameter defined in a method will receive the object with which said method is invoked. This parameter (which is usually called selfalthough any variable name can be used [ see comments ]) is used within the method implementation to modify the content or attributes of said object as desired.

Therefore, it is a necessary condition that all methods of a class that can be called through an object have at least one parameter, which will be automatically assigned to the object used in the invocation.

Although in the definition of the method, selfit is the first parameter, when calling said method it is not necessary to explicitly pass the object itself as the first parameter, since Python does it implicitly without having to do it manually. That is, the first parameter selfof the method is automatically assigned to the object itself and the rest of the parameters to the arguments with which you call the method.

In the case of the method __init__(), the parameter selfrefers to the newly instantiated object of the class that you want to get when creating said object with Nombre_Clase().

selfis the equivalent thisof other languages ​​(although selfit is not a reserved word like this[ see comments ]), with the difference that in other languages ​​it is not necessary to define the methods with a parameter this, while in Python it is necessary.

As you say, it is a self reference and in general, in a model instance method, you should use self when modifying attributes or when there is some ambiguity between calling a local variable and an already defined attribute/method. This happens in all languages ​​that use OOP and it is a very common practice and the most correct, so I advise you to use it.