Question about the @staticmethod decorator
On 17Mar2019 20:24, Paul Moore <p.f.moore at gmail.com> wrote:
>On Sun, 17 Mar 2019 at 18:18, Arup Rakshit <ar at zeit.io> wrote:
>> I am reading a book where the author says that:
>> In principle, it would also be possible to implement any @staticmethod completely outside of the class at module scope without any loss of functionality ? so you may want to consider carefully whether a particular function should be a module scope function or a static method. The @staticmethod decorator merely facilitates a particular organisation of the code allowing us to place what could otherwise be free functions within classes.
>> I didn?t get quiet well this block of text. My first question is how would I make a module level function as static method of a class. Can anyone give me an example of this? What are the contexts that would let you to think if they are good fit inside the class or module level scope functions?
>The point the author is trying to make is that there's no practical
> print("Hello,", name)
> def say_hello(name):
> print("Hello,", name)
>You refer to the first as "say_hello", and the second as
>"Talker.say_hello", but otherwise they are used identically. The
>static method has no access to the class or instance variables, so it
>has no special capabilities that the standalone "say_hello" function
>has. So, to rephrase the words you used, @staticmethod lets you
>organise your code in a certain way, but doesn't offer any extra
>capabilities over module-level functions.
This is true in the narrow sense that the function itself has no access
to any class of instance implicit context.
However, the method's _name_ is in the class namespace and findable from
the class or any instance.
This means that in your example above, if I have a Talker instance:
talker = Talker(....)
I can access the class _appropriate_ say_hello() function from the
Compare this with another class:
global_pen.transcribe_text("Hello " + name)
If I've got a Writer instead of a talker, or better still a mix of them,
I can call their .say_hello() methods without caring what their backend
leader = "Arup"
for member in social_group:
So to Arup's question, a @staticmethod does not need any access to the
instance or class context. However, there are still good reasons for
putting it in the class definition:
- code organisation: you find this function in the class definition with
all the other methods
- instance access to the _appropriate_ version of the method because the
instance finds the method name in its own class.
Now, to the converse question: if you've a potential @staticmethod, why
would you bother?
Aside from accessing it via an instance (or class), marking a method as
a staticmethod has at least 2 other advantages:
It means you can call it via an instance or a class:
# use speech
# use writing
# use whatever "someone" prefers
Importantly, if it were an ordinary method:
def say_hello(self, name):
then you _couldn't_ use the Talker.say_hello() or Writer.say_hello()
forms because you've got nothing for the "self" parameter.
It also makes linters happier.
What's a linter? It is a tool to inspect code and complain about all
sorts of dubious things. They're incredibly useful. Complaint vary from
cosmetic, such as poor style (which tends to correlate with hard to
ready and maintain code) to semntic, such as variables which are used
before they are initialised (which usually indicates a bug in the code,
often as simple as a misspelt variable name but also frequently geniuine
In the case of a static method, if cosider these two:
def say_hello(self, name):
You can call either from an instance:
and get the same result. However, a linter will complain about the
former say_hello() method because the parameter "self" is unused. It
won't complain about the latter because there isn't a "self" method.
You might not care here, but if you use linters you will find complaints
about unused parameters useful. They generally indicate things like:
- you misspelt the parameter name inside the function (or conversely in
the header) so that it isn't correct. This is a bug and the linter is
helping you here.
- your function genuinely isn't using the parameter. This often
indicates that the function is not completely implemented, because
changing the value of the parameters does not affect what the function
does: that parameter is useless.
So you can see that usually these lint complaints help you find bugs in
your code before it runs; that is almost always faster and easier.
Finding bugs when the code runs requires you to actually use it in a way
that triggers the bug, which isn't always the case - it sometimes isn't
even easy if the bug is something that rarely occurs.
So, once you start using linters what is your goal? To make their
complaint output empty, because thatt makes new problems in you code
A good linter has two basic ways to remove a complaint: change the code
to conform to the linter's rule (the usual case) _or_ mark the code in
some way to indicate that the rule should not apply here (infrequent,
but sometimes necessary - often this involves special type of comment
recognised by the linter).
However, you can consider the @staticmethod decorator to be a way to
tell linters that this method does not use "self", because (a) you're
not using "self" and (b) it lets you omit "self" from the function
The third method of these two is to adjust the linter's rules,
particularly around style; I use 2 space indents in my personal code and
run my linters with a special setting for that, as 4 spaces is the
Cameron Simpson <cs at cskk.id.au>