The new pycharm release (3.1.3 community edition) proposes to convert the methods that don't work with the current object's state to static.
https://i.stack.imgur.com/l0TgW.png
What is the practical reason for that? Some kind of micro-performance(-or-memory)-optimization?
return 1
as a single line implementation of the method. "More" doesn't contain anything useful
PyCharm "thinks" that you might have wanted to have a static method, but you forgot to declare it to be static (using the @staticmethod
decorator).
PyCharm proposes this because the method does not use self
in its body and hence does not actually change the class instance. Hence the method could be static, i.e. callable without passing a class instance or without even having created a class instance.
Agreed with @jolvi, @ArundasR, and others, the warning happens on a member function that doesn't use self
.
If you're sure PyCharm is wrong, that the function should not be a @staticmethod
, and if you value zero warnings, you can make this one go away two different ways:
Workaround #1
def bar(self):
self.is_not_used()
doing_something_without_self()
def is_not_used(self):
pass
Workaround #2 [Thanks @DavidPärsson]
# noinspection PyMethodMayBeStatic
def bar(self):
doing_something_without_self()
The application I had for this (the reason I could not use @staticmethod) was in making a table of handler functions for responding to a protocol subtype field. All handlers had to be the same form of course (static or nonstatic). But some didn't happen to do anything with the instance. If I made those static I'd get "TypeError: 'staticmethod' object is not callable".
In support of the OP's consternation, suggesting you add staticmethod whenever you can, goes against the principle that it's easier to make code less restrictive later, than to make it more -- making a method static makes it less restrictive now, in that you can call class.f() instead of instance.f().
Guesses as to why this warning exists:
It advertises staticmethod. It makes developers aware of something they may well have intended.
As @JohnWorrall's points out, it gets your attention when self was inadvertently left out of the function.
It's a cue to rethink the object model; maybe the function does not belong in this class at all.
# noinspection PyMethodMayBeStatic
above the method or class suppresses the warning, and is in my opinion better than calling an empty method.
self
is not removed in Python3 at all.
self
in Python 2 would not be necessary in Python 3. Can you give an example or link?
I think that the reason for this warning is config in Pycharm. You can uncheck the selection Method may be static in Editor->Inspection
I agree with the answers given here (method does not use self
and therefore could be decorated with @staticmethod
).
I'd like to add that you maybe want to move the method to a top-level function instead of a static method inside a class. For details see this question and the accepted answer: python - should I use static methods or top-level functions
Moving the method to a top-level function will fix the PyCharm warning, too.
self
is not a parameter.
self
and therefore could be top-level, however, this does not feel logical when looking at what this method does - as top-level it would look more of a global method, while it is in fact a small helper method for instances created from that class. So to keep my code logically organised, the decorator is the perfect solution.
I can imagine following advantages of having a class method defined as static one:
you can call the method just using class name, no need to instantiate it.
remaining advantages are probably marginal if present at all:
might run a bit faster
save a bit of memory
bit
running faster is not the point (cause they run in ram so its fast in both cases) and as you know computers now have bunch
of memory so that is not a problem anymore. Also note your first thought: That is a procedural behavior not an object oriented one.
It might be a bit messy, but sometimes you just don't need to access self
, but you would prefer to keep the method in the class and not make it static. Or you just want to avoid adding a bunch of unsightly decorators. Here are some potential workarounds for that situation.
If your method only has side effects and you don't care about what it returns:
def bar(self):
doing_something_without_self()
return self
If you do need the return value:
def bar(self):
result = doing_something_without_self()
if self:
return result
Now your method is using self
, and the warning goes away!
Since you didn't refer to self
in the bar
method body, PyCharm is asking if you might have wanted to make bar
static. In other programming languages, like Java, there are obvious reasons for declaring a static method. In Python, the only real benefit to a static method (AFIK) is being able to call it without an instance of the class. However, if that's your only reason, you're probably better off going with a top-level function - as note here.
In short, I'm not one hundred percent sure why it's there. I'm guessing they'll probably remove it in an upcoming release.
This error message just helped me a bunch, as I hadn't realized that I'd accidentally written my function using my testing example player
my_player.attributes[item]
instead of the correct way
self.attributes[item]
The reason why Pycharm make it as a warning because Python will pass self as the first argument when calling a none static method (not add @staticmethod). Pycharm knows it.
Example:
class T:
def test():
print "i am a normal method!"
t = T()
t.test()
output:
Traceback (most recent call last):
File "F:/Workspace/test_script/test.py", line 28, in <module>
T().test()
TypeError: test() takes no arguments (1 given)
I'm from Java, in Java "self" is called "this", you don't need write self(or this) as argument in class method. You can just call self as you need inside the method. But Python "has to" pass self as a method argument.
By understanding this you don't need any Workaround as @BobStein answer.
self
so what?
Rather than implementing another method just to work around this error in a particular IDE, does the following make sense? PyCharm doesn't suggest anything with this implementation.
class Animal:
def __init__(self):
print("Animal created")
def eat(self):
not self # <-- This line here
print("I am eating")
my_animal = Animal()
Success story sharing
NotImplementedError
.self
. In this case the warning is neglectable, and I mark it with# noinspection PyMethodMayBeStatic
. It's a pitty that IntelliJ IDEA doesn't offer adding this disabling comment in the context menus for this warning.