3 ms·

Python's actual behavior in this case is far stranger than static methods, which are a standard feature of many object-oriented languages (albeit one that's fai

• joshuamorton 6y ago
  I'm not sure what you're saying here. If you want `def foo(a, b)` inside a class to be a static method, you need to define it as class Foo: @staticmethod def foo(a, b): ... Now `f = Foo(); f.foo(1, 2)` will work. However, you need to be explicit about this because it is much more common for this situation to arise because someone forgot a self somewhere than for it to have been intentional. Requiring @staticmethod serves to signal to humans that this odd behavior is intentional (but again I'd say that, stylistically, if you're using a staticmethod, just move it out of the class and into the module namespace, module namespaces in python don't bite).
  • 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 ago
      This 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 ago
        I 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 ago
          Except 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 ago
            Wouldn'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 ago
                Should super then also be a method argument?
                • joshuamorton 6y ago
                  Honestly, 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".