What exactly are methods in python? Is a method an attribute?

So a method is actually an attribute?

The short answer is yes , for the level at which the question is focused for practical purposes it is. Technically anything that can be referenced through an object using the .nombredotted expression notation is considered an attribute , that includes methods.

IMPORTANT

This may seem to contradict the concepts of attribute and method in the OOP paradigm, in which, broadly speaking, an attribute is a feature that describes a given object while a method is something that object can do. This separation is maintained conceptually at a high level in Python, conceptually a method and an attribute are of course not the same, but as far as the language is concerned and how OOP is implemented in Python, the separation is not so clear, rather Quite the contrary , and that is what the question is about and that is what we are trying to answer in this answer.

Is the attribute methodthat I define in the class A( method = funcion) a method?

If it is. Although the concept of method is normally restricted to "function defined in the body of a class", for practical and not conceptual purposes, it is a method. You can define the methods outside the class, even in another module, and then bind them like this. Or even after the class definition:

class Test:
    def foo(self):
        print(f"Hola, soy un método de {self} definido de forma 'normal'")
    

>>> inst = Test()
>>> inst.foo
<bound method Test.foo of <__main__.Test object at 0x7f13658fac70>>
>>> inst.foo()
Hola, soy un método de <__main__.Test object at 0x7f13658fac70> definido de forma 'normal'

>>> inst.bar()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Test' object has no attribute 'bar'

>>> def bar(self):
        print(f"Soy un método de {self} definido a 'distancia'")

>>> Test.bar = bar
>>> inst.bar
<bound method bar of <__main__.Test object at 0x7f13658fac70>>
>>> inst.bar()
Soy un método de <__main__.Test object at 0x7f13658fac70> definido a 'distancia'

Take! Dynamic language in all its splendor, for better and for worse... :)

That it can be done does not mean that it is a good idea, Python lets you do almost everything, very good ideas and very bad ideas. When something is usually restricted, it is because it endangers the interpreter itself or for a very good reason of design, optimization, etc. Instead of doing this we have inheritance for example, but we can even add methods to a class with created instances and call them from the already created instances without any problem.

So what exactly is a method in Python?

If someone wants to read for a little while with the possibility of not understanding anything at the end, because of me, they have been warned, but here it goes.

In Python practically everything is an object in memory (including imported modules, the script itself, functions, classes, integers, etc), which in turn have methods, functions or anything with a method __call __(), as objects that can be called.

The attribute resolution system (in which it __dict__has a primary role) doesn't care at all whether the object is callable or not. Just try to find that name in the class(es) it derives from by following the MRO. Then you try to call it, you try to assign it or you set it on fire, but its mission ends when it gives you a reference to the attribute or an exception because it couldn't find it.

Actually methods are objects that act as wrappers for functions holding references to the instance they belong to and thus linking the function to its instance. They are also created on the fly by accessing the function as an attribute using the aforementioned syntax .nombre.

If we look at how a method is defined, it doesn't differ at all from defining a function, the only thing that changes is that a reference to the class or the instance is received as the first argument ( cls/ selfby convention nothing else).

Obviously there has to be a mechanism that binds the function to the class or instance and allows the method to be referenced with .nombre. Python solves this by using non-data descriptors. In the end we will see it above.

Keep in mind that Python is a dynamic language, in which a variable/attribute is just a name associated at all times with a reference to an object in memory.

This means that basically all variables/attributes are the same, they are all just ways to find an object in memory, it doesn't matter if the object is callable or not, or if at a given moment the variable points to another object or that several point to the same. The type and properties always belong to the object, not to the variable. It really doesn't matter to the language if instancia.nombreit's an integer, a string, a list, or a method, they're all objects.

In languages ​​like C++, this does not happen, the data and the methods are clearly separated, with the data (attributes) fixed to a specific type and in which the methods are not objects.

The attribute__dict__

An object's attribute __dict__(if it's also an attribute) behaves like a dictionary, but it's not. It's really an instance of a class DictProxywhose objects behave like dictionaries but with some differences, for example, we can't add attributes like we do with the keys of a dictionary, this doesn't work:

 Clase.__dict__["foo"] = 13
 
 

we must use:

Clase.foo = 13

either

setattr(Clase, "foo", 13)

For example, if we are so unaware of doing this:

del instancia.__dict__

is created again...

The reasons for using DictProxyit are several, in essence it is done by optimization, forcing the keys to always be strings, which allows the interpreter to perform certain optimizations. Also for security, to prevent things like the one above from mutilating a class or instance and sending the interpreter itself into a tailspin...

class "dictionaries" like __dict__simply store methods as functions.

descriptors

A descriptor is an object that has at least one of the following magic methods in its attributes: __get__, __set__or __delete__. Its implementation and use is known as the descriptor protocol and basically it is to change an attribute for an object (the descriptor) that intermediates in the access to that attribute, in this way they allow to define and establish the behavior of the attribute of an object.

A descriptor that only implements __get__is called a non-data descriptor and they are used to access methods as we will see. While if it implements __set__, they are also data descriptors, which do not interest us much in this case.

Descriptors are used for many things related to attributes and methods, they are everywhere in Python even if we don't see them. For example for static methods ( @staticmethod), class methods ( @classmethod) and properties ( @property) descriptors are used, decorators are nothing more than a way to implement them in a simple way without looking like they are being used.

Properties are perhaps a very clear example of this:

class Foo:
    def __init__(self):
        self._bar = None
        
    @property
    def bar(self):
        return self._bar
        
    @bar.setter
    def bar(self, valor):
        self._bar = valor
        

>>> inst = Foo()  
>>> inst.bar = 5  
>>> inst.bar  
5

But all this goes much further, otherwise I would not have gotten into the "pool" of descriptors. As I mentioned before, to allow a function to be called as methods you need something else. Functions include the method __get__()to bind the function with access to tributes via .nombre, so all functions are non-data descriptors that return bound methods when called from an object.

In fact, if we access a method through __dict__, it doesn't call __get__, but just returns a reference to the function below:

class Foo:
    def bar(self):
        pass

>>> Foo.__dict__["bar"]
<function Foo.bar at 0x7f0345da3a60>

If we access using Clase.método, if it is __get__called, since, as has been commented, it is the link between the function and the class to allow said syntax, but the underlying function object is also returned without further ado:

>>> Foo.bar
<function Foo.bar at 0x7f0345da3a60>

Instead, when accessed via the instance, the function is wrapped on the fly in a bound method:

>>> Foo().bar
<bound method Foo.bar of <__main__.Foo object at 0x7f0345df0460>>

This object internally stores the reference to the function and the instance to which it is associated, among other things:

>>> Foo().bar.__func__
<function Foo.bar at 0x7f0345da3a60>
>>> Foo().bar.__self__
<__main__.Foo object at 0x7f0345df0460>

A method, therefore, is nothing more than an attribute bound to a function through a descriptor.