Is because by the way python is designed the alternatives would hardly work. Python is designed to allow methods or functions to be defined in a context where both implicit this
(a-la Java/C++) or explicit @
(a-la ruby) wouldn't work. Let's have an example with the explicit approach with python conventions:
def fubar(x):
self.x = x
class C:
frob = fubar
Now the fubar
function wouldn't work since it would assume that self
is a global variable (and in frob
as well). The alternative would be to execute method's with a replaced global scope (where self
is the object).
The implicit approach would be
def fubar(x)
myX = x
class C:
frob = fubar
This would mean that myX
would be interpreted as a local variable in fubar
(and in frob
as well). The alternative here would be to execute methods with a replaced local scope which is retained between calls, but that would remove the posibility of method local variables.
However the current situation works out well:
def fubar(self, x)
self.x = x
class C:
frob = fubar
here when called as a method frob
will receive the object on which it's called via the self
parameter, and fubar
can still be called with an object as parameter and work the same (it is the same as C.frob
I think).