4 ms·
I just don't think the decorator should be required for static methods. If you write `def foo(a, b)` inside a class, the lack of `self` should be sufficient to
by pansa2 6y ago
I just don't think the decorator should be required for static methods. If you write `def foo(a, b)` inside a class, the lack of `self` should be sufficient to make `foo` a static method.
IMO it would make sense for Python to look at `a, b` and assume you wanted a static method with two parameters. Instead it assumes you're using `a` instead of `self` and really wanted an instance method with one parameter.
- joshuamorton 6y agoThis requires blessing "self" as special (like this in java etc.). Python made a specific choice not to do that (and there are cases where you don't want to use "self", such as metaclasses, classmethods, and (rarely) nested classes that close over their parent class. Like I said: most of the time, a missing `self` is an error by the user, and so python requires explicit notification both to the language, and to other people, that you're doing what you mean to do, and not just making a mistake.
- lmm 6y agoI think that's the point: requiring the user to explicitly pass "self" rather than making it a language keyword mostly just gives the user an unnecessary opportunity to make mistakes.
- airstrike 6y agoExcept in Pythonland, "explicit is better than implicit" https://www.python.org/dev/peps/pep-0020/ https://www.python.org/dev/peps/pep-0020/
- Sandman 6y agoWouldn't it be more explicit if there was a designated keyword that objects could use to access their own members instead of implicitly assuming that any first argument to a method is a reference to them, only called 'self' by convention?
- joshuamorton 6y ago> Wouldn't it be more explicit if there was a designated keyword that objects could use to access their own members Not really. You end up implicitly injecting some value into local namespaces instead of having a function that takes an argument. The implicitness of methods working differently than normal functions > the implicitness of classes passing a first argument to methods.
- Sandman 6y agoShould super then also be a method argument?
- joshuamorton 6y agoHonestly, I think it would have made some amount of sense to make super a method defined on the base object so that def __init__(self, x, y): self.super(x, y) would be the convention. There may be some infra issue with this (and in general, `super` has to be kind of magical no matter how you handle it). But yes, in general I can vibe with "super is too implicit".
- Joker_vD 6y agoRuby generally (I think? I haven't seen much of Ruby code) uses "@" instead of "self.", and "@@" instead of "ParticularClassName." (btw, "self.__class__" doesn't cut it), and it seems to produce no namespace pollution.