Home / Questions / 452648
Accepted
PySanti
Asked: 2022-05-18 08:14:32 +0800 CST 2022-05-18 08:14:32 +0800 CST

Why can't you remove methods in python?

  • 772

-The question would be the following: why can't the methods be eliminated through the use of the keyworddel

-In the case of decorating them with a deleter, it would not be the same, since in such cases the objects to which the method decorated with is relative would be eliminated @property, not the method itself

-Let's remember that after all, functions are (just like everything in python) objects, pointers that point to variables, in this case, said variables would be the code block that loads into RAM, for example...

  def saludo():
      print('Hola como estamos por aca? ')

-In this case saludoitself, without the use of the dunder __call__(that is, without calling the parentheses), it is a pointer that points to saludo(), it is for the same reason as with these if we can use the keyword delwithout errors, since (if I'm not wrong, it's what my intuition tells me, if you have reasons to say that I'm wrong about something, please say so), what it does delis basically make saludo(as a pointer) point to None. And therein lies the question, because if functions and methods are basically the same, they cannot be removed as easily.

-Note that deleting a method given that it is decorated with a deletter, does not enter into my perception of deletion, since, as I mentioned at the beginning, in such cases the attributes to which that method is relative would be deleted, not the method itself.

python

1 Answers

  1. Best Answer

    Of course you can remove methods in python. A method is nothing more than an attribute and as you indicate in the question it is a kind of "pointer" to the function code.

    A function is at heart an object (of a special "callable" type) and the function name is nothing more than a symbol pointing to the function. When you delete that symbol with del simbolo, you simply "break" the connection between that symbol and the object it pointed to. The object is left undefined (which is not the same as with value None), and an attempt to access that symbol will fail:

    >>> def f():
...   pass
...
>>> f
<function f at 0x102310af0>
>>> del f
>>> f
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'f' is not defined

    The symbol fhas ceased to exist, but the object (function) it pointed to may not. In particular, if you have another symbol pointing to the same object, the object will still exist:

    >>> def f():
...   return "Existo"
...
>>> f()
'Existo'
>>> g = f
>>> g()
'Existo'
>>> del f
>>> g()
'Existo'

    As you can see, del fit does not remove the function itself, but only the symbol fthat pointed to the function. The function still exists and can be called via the symbol g. Only when all the symbols that pointed to that object are gone is the object finally removed from memory by the garbage collector.

    And the methods?

    The same thing happens with methods, only there is a nuance. A method is nothing more than an attribute that "points" to a function, but that attribute can exist as part of the object or as part of the class. Let's first see an example with attributes that are not methods, but for example integers:

    >>> class A:
...   x = 1
...
>>> a = A()
>>> a.y = 2

    The class Ahas an attribute called x. The object a(which is an instance of the class A) has another attribute called y. Although the user may try to access a.x, it does not actually xexist as part of a, but as part of the class (and is "inherited" by the object).

    This implies that we can delete a.ybut not a.xbecause ait does not actually have the attribute x:

    >>> a.x
1
>>> a.y
2
>>> del a.x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: x
>>> del a.y

    Instead there is no problem in removing it from the class (which is where it actually exists):

    >>> del A.x
>>>

    Naturally once we have deleted it from the class, any subsequent instance will not be able to inherit it:

    >>> b = A()
>>> b.x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'A' object has no attribute 'x'

    Exactly the same thing happens with methods . Except that in almost all cases the methods belong to the class, and not to the object. Therefore if you want to delete them you must do it through the class:

    >>> class A:
...   def foo(self):
...     return "Existo"
...
>>> a = A()
>>> a.foo()
'Existo'
>>> del a.foo    # No podemos porque foo no existe en a, sino en A
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: foo
>>> del A.foo    # Esto en cambio no da problemas
>>> a.foo()      # Ahora fallará el intento de usarlo desde una instancia
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'A' object has no attribute 'foo'
    • 8