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.

What is the practical reason for that? Some kind of micro-performance(-or-memory)-optimization?

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.

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.

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

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]

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!

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.

When initializing a dictionary with d = {} Pycharm’s code inspector generates a warning, saying

This dictionary creation could be rewritten as a dictionary literal.

If I rewrite it d = dict() the warning goes away. Since {} already is a dictionary literal, I’m pretty sure the message is erroneous. Furthermore, it seems like both d = {} and d = dict() are valid and Pythonic.

This related question seems to conclude that the choice is just a matter of style/preference: differences between “d = dict()” and “d = {}”

Why would Pycharm complain about d = {}?

UPDATE:

Mac nailed it. The warning actually applied to multiple lines, not just the one that was flagged.

Pycharm seems to look for a sequence of consecutive statements where you initialize a dictionary and then set values in the dictionary. For example, this will trigger the warning:

d = {}
d['a'] = 1

But this code will not:

d = {}
pass
d['a'] = 1

What is the following code to your dictionary declaration?

I think pycharm will trigger the error if you have something like:

dic = {}
dic['aaa'] = 5

as you could have written

dic = {'aaa': 5}

BTW: The fact that the error goes away if you use the function doesn’t necessarily mean that pycharm believes dict() is a literal. It could just mean that it doesn’t complain for:

dic = dict()
dic['aaa'] = 5

HTH!

This can be disabled in the Project Settings or Default Settings.

• Navigate to Settings -> Inspections -> Python
• Uncheck “Dictionary creation could be rewritten by dictionary literal”

for those who like (just like me) to initialize dictionaries with single operation

d = {
  'a': 12,
  'b': 'foo',
  'c': 'bar'
}

instead of many lines like

d = dict()
d['a'] = 12
d['b'] = ....

in the end I ended up with this:

d = dict()
d.update({
  'a': 12,
  'b': 'foo',
  'c': 'bar'
})

Pycharm is not complaining on this

mydict = {
  a: 5,
  b:z+c/2
}

The dictionary could have been created directly without initialising them first and then reassigning new values.

I have a situation where this warning is bugging the hell out of me. In my case, I’m populating my dict partially as literals and partially from a tuple output by a function, like so:

def get_other_values():
    return 3, 4

foo = {
    "a": 1,
    "b": 2
}
foo["c"], foo["d"] = get_other_values()

So, unless I create interim vars for the output of get_other_values, PEP8 generates this warning even though I’m creating the dict with literals. And I can’t assign the c and d keys in the literal, since the values are output as a tuple.

I have an integer value x, and I need to check if it is between a start and end values, so I write the following statements:

if x >= start and x <= end:
    # do stuff

This statement gets underlined, and the tooltip tells me that I must

simplify chained comparison

As far as I can tell, that comparison is about as simple as they come. What have I missed here?

In Python you can “chain” comparison operations which just means they are “and”ed together. In your case, it’d be like this:

if start <= x <= end:

Reference: https://docs.python.org/3/reference/expressions.html#comparisons

It can be rewritten as:

start <= x <= end:

Or:

r = range(start, end + 1) # (!) if integers
if x in r:
    ....

Simplification of the code

if start <= x <= end: # start x is between start and end 
# do stuff

I am using PyCharm to work on a project. The project is opened and configured with an interpreter, and can run successfully. The remote interpreter paths are mapped properly. This seems to be the correct configuration, but PyCharm is highlighting my valid code with “unresolved reference” errors, even for built-in Python functions. Why don’t these seem to be detected, even though the code runs? Is there any way to get PyCharm to recognize these correctly?

This specific instance of the problem is with a remote interpreter, but the problem appears on local interpreters as well.

File | Invalidate Caches… and restarting PyCharm helps.

Dmitry’s response didn’t work for me.

I got mine working by going to Project Interpreters, Selecting the “Paths” tab, and hitting the refresh button in that submenu. It auto-populated with something called “python-skeletons”.

edit: screenshot using PyCharm 3.4.1 (it’s quite well hidden)

There are many solutions to this, some more convenient than others, and they don’t always work.

Here’s all you can try, going from ‘quick’ to ‘annoying’:

• Do File -> Invalidate Caches / Restart and restart PyCharm.
  • You could also do this after any of the below methods, just to be sure.
• First, check which interpreter you’re running: Run -> Edit Configurations -> Configuration -> Python Interpreter.
• Refresh the paths of your interpreter:
  • File -> Settings
  • Project: [name] -> Project Interpreter -> ‘Project Interpreter’: Gear icon -> More...
  • Click the ‘Show paths’ button (bottom one)
  • Click the ‘Refresh’ button (bottom one)
• Remove the interpreter and add it again:
  • File -> Settings
  • Project: [name] -> Project Interpreter -> ‘Project Interpreter’: Gear icon -> More...
  • Click the ‘Remove’ button
  • Click the ‘Add’ button and re-add your interpeter
• Delete your project preferences
  • Delete your project’s .idea folder
  • Close and re-open PyCharm
  • Open your project from scratch
• Delete your PyCharm user preferences (but back them up first).
  • ~/.PyCharm50 on Mac
  • %homepath%/.PyCharm50 on Windows
• Switch to another interpreter, then back again to the one you want.
• Create a new virtual environment, and switch to that environments’ interpreter.
• Switch to another interpreter altogether, don’t switch back.

In my case it was the directories structure. My project looks like this:

+---dir_A
    +---dir_B
        +app
        |
        \-run.py

So right click on dir_b > “mark directory as” > “project root”

I find myself removing and re-adding the remote interpreter to fix this problem when Invalidating Caches or Refreshing Paths does not work.

I use vagrant and every once and awhile if I add a new VM to my multi-vm setup, the forwarded port changes and this seems to confuse PyCharm when it tries to use the wrong port for SSH. Changing the port doesn’t seem to help the broken references.

If none of the other solutions work for you, try (backing up) and deleting your ~/.PyCharm40 folder, then reopening PyCharm. This will kill all your preferences as well.

On Mac you want to delete ~/Library/Caches/Pycharm40 and ~/Library/Preferences/PyCharm40.

And on Windows: C:\Users\$USER.PyCharm40.

Tested with PyCharm 4.0.6 (OSX 10.10.3) following this steps:

1. Click PyCharm menu.
2. Select Project Interpreter.
3. Select Gear icon.
4. Select More button.
5. Select Project Interpreter you are in.
6. Select Directory Tree button.
7. Select Reload list of paths.

Problem solved!

very easy

you just have to mark your root directory as: SOURCE ROOT (red), and your applications: EXCLUDED ROOT (blue),

then the unresolved reference will disappear.

• if you use PyChram pro it do this for you automaticlly.

Sorry to bump this question, however I have an important update to make.

You may also want to revert your project interpreter to to Python 2.7.6 if you’re using any other version than that This worked for me on my Ubuntu installation of PyCharm 4.04 professional after none of the other recommendations solved my problem.

You might try closing Pycharm, deleting the .idea folder from your project, then starting Pycharm again and recreating the project. This worked for me whereas invalidating cache did not.

I finally got this working after none of the proposed solutions worked for me. I was playing with a django rest framework project and was using a virtualenv I had setup with it. I was able to get Pycharm fixed by marking the root folder as the sources root, but then django’s server would throw resolve exceptions. So one would work when the other wouldn’t and vice versa.

Ultimately I just had to mark the subfolder as the sources root in pycharm. So my structure was like this

-playground
     -env
     -playground

That second playground folder is the one I had to mark as the sources root for everything to work as expected. That didn’t present any issues for my scenario so it was a workable solution.

Just thought I’d share in case someone else can use it.

It could also be a python version issue. I had to pick the right one to make it work.

If you want to ignore only some “unresolved reference” errors, you can also tell it PyCharm explicitly by placing this in front of your class/method/function:

# noinspection PyUnresolvedReferences

I closed all the other projects and run my required project in isolation in Pycharm. I created a separate virtualenv from pycharm and added all the required modules in it by using pip. I added this virtual environment in project’s interpreter. This solved my problem.

Geeze what a nightmare, my amalgamation of different StackOVerflow answers:

1. Switch to local interpreter /usr/bin/pythonX.X and apply
2. View paths like above answer
3. Find skeletons path. Mine was (/home/tim/Desktop/pycharm-community-2016.2.3/helpers/python-skeletons)
4. Switch back to virt interpreter and add the skeletons path manually if it didn’t automatically show up.

None of the above solutions worked for me!
If you are using virtual environment for your project make sure to apply the python.exe file that is inside your virtual environment directory as interpreter for the project (Alt + Ctrl + Shift + S) this solved the issue for me.

In my case the inspection error shows up due to a very specific case of python code. A min function that contains two numpy functions and two list accesses makes my code inspection give this kind of errors.

Removing the ‘d=0’ line in the following example gives an unresolved reference error as expected, but readding doesn’t make the error go away for the code inspector. I can still execute the code without problems afterwards.

import numpy as np
def strange(S, T, U, V):
    d = 0
    print min(np.abs(S[d]), np.abs(T[d]), U[d], V[d])

Clearing caches and reloading list of paths doesn’t work. Only altering the code with one of the following example patches does work:

• Another ordering of the ‘min’ parameters: schematically S U T V but not S T U V or T S U V
• Using a method instead of the function: S[d].abs() instead of np.abs(S[d])
• Using the built-in abs() function
• Adding a number to a parameter of choice: U[d] + 0.

None of the answers solved my problem.

What did it for me was switching environments and going back to the same environment. File->Settings->Project interpreter

I am using conda environments.

Worked for me with much simplier action:

File > Settings > Project > Project Interpreter 
> Select "No interpreter" in the "Project interpreter" list 
> Apply > Set your python interpreter again > Click Apply

Profit – Pycharm is updating skeletons and everything is fine.

If you are using vagrant the error can be caused by wrong python interpreter. In our vagrant we are using pyenv so I had to change Python Interpreter path path from /usr/bin/python to /home/vagrant/.pyenv/versions/vagrant/bin/python

I have a project where one file in src/ imports another file in the same directory. To get PyCharm to recognize I had to to go to File > Settings > Project > Project Structure > select src folder and click “Mark as: Sources”

From https://www.jetbrains.com/help/pycharm/configuring-folders-within-a-content-root.html

Source roots contain the actual source files and resources. PyCharm uses the source roots as the starting point for resolving imports

My problem is that Flask-WTF is not resolved by PyCharm. I have tried to re-install and then install or Invalidate Cache and Restart PyCharm, but it’s still not working.

Then I came up with this solution and it works perfectly for me.

1. Open Project Interpreter by Ctrl+Alt+S (Windows) and then click Install (+) a new packgage.

2. Type the package which is not resolved by PyCharm and then click Install Package. Then click OK.

Now, you’ll see your library has been resolved.

Are you using virtualenv?

if so, you need to notify PyCharm for every change in the location of the the desired python.exe (merely ./activate is not enough for PyCharm)

Make sure Pycharm points to the correct interpetor and packages: File -> Settings -> Project -> Project Interpreter. Click the gear and choose python.exe under virtualenv’s Scripts folder