If I had a nickel for every time I got the "TypeError: random_function() takes 1 positional argument but 2 were given" because I forget the "self" parameter I could buy myself a coffee. Probably a fancy one from the Starbucks even!
Other languages have implied "this" or "self".
class LiterallyThere:
def method(self, foo):
"Literally explicit, self"
LiterallyThere.method('foo')
passes the class object LitterallyThere as the first arg
lt = LiterallyThere()
lt.method('foo')
passes the instance of the class object represented by lt as the first argument.
method(something, 'foo')
If you were able to reference method without a dot, you would have to supply two arguments cause method takes two arguments.
You literally, explicitly have to tell the interpreter what you are passing as first parameter and you method signature has to literally, explicitly accept that parameter.
Yegge thinks that "self" is a wart and I agree. The article is a fun read but it's showing its age. I suspect Python might just have beaten Perl by now.
https://sites.google.com/site/steveyegge2/tour-de-babel#TOC-...
I suppose Python's way there's one less reserved word. Are there any other advantages?
class Foo:
b = 4
def foo(self, a):
return a + self.b
inst = Foo()
inst.foo(3)
Foo.foo(inst, 3)
These days, however, I mostly write Common Lisp and Clojure which, each in their own way, have explicit selfs: Common Lisp because it uses multiple dispatch and, consequently, there isn't one "self" and Clojure's protocols are designed to dispatch on the first argument, which is always passed explicitly.