Python – Why is this warning “Expected type ‘int’ (matched generic type ‘_T’), got ‘Dict[str, None]’ instead”

Please watch carefully the question and carefully the answers of this and you'll see it's not a duplicate , especially because they dont answer my question.

Try to make a new empty project, and add this code. It works fine without warnings:

game_data = {'boats': [], }
game_data['boats'].append({'name': None})
Now change it to:
game_data = {'boats': [], 'width': None, 'height': None, }
game_data['boats'].append({'name': None})
Still no warnings.

And change again to:
w = 12
game_data = {'boats': [], 'width': None, 'height': w, }
game_data['boats'].append({'name': None})
And now you'll get:
Expected type 'int' (matched generic type '_T'), got 'Dict[str, None]' instead
Am I the only one to have this? And why is this? Is there a solution to make this warning go away?
My guess would be the analytics that give this warning are not sharp enough.
The value type for 
game_data = {'boats': [], 'width': None, 'height': None} 
can not be determined.  
The first "real" value you put in is an int:
w = 12
game_data = {'boats': [], 'width': None, 'height': w}
So PyCharm assumes that this is a dict(string->int). 
Then you add a inner dict as value to your empty list:
game_data['boats'].append({'name': None})
So now it has a dict(string->int) that suddenly gets to be a mixed thing and warns you. 
Thats about the same as what What does this warning in PyCharm mean? is about: adding int into a list of strings using pycharm as IDE.
As to how to get rid of the warning: Jetbrains Resharper is very configurable, I guess pycharm will be as well. This documentation https://www.jetbrains.com/help/pycharm/configuring-inspection-severities.html#severity might help you configure the severity down - if not I am sure the support of Jetbrains is eager to help you out - they were whenever I had problems using resharper.
Related Solutions
Python – Why dict.get(key) instead of dict[key]

It allows you to provide a default value if the key is missing:
dictionary.get("bogus", default_value)
returns default_value (whatever you choose it to be), whereas
dictionary["bogus"]
would raise a KeyError.  
If omitted, default_value is None, such that
dictionary.get("bogus")  # <-- No default specified -- defaults to None
returns None just like 
dictionary.get("bogus", None)
would. 
    
Python – Pycharm: Expected type ‘Integral’, got ‘str’ instead

Based on the 'more...' screenshot, it looks like Pycharm might be interpreting the map() as though the two terms around the comma are both part of the lambda, i.e. the lambda just returns a 2-tuple instead of treating it as two parameters to the map() function.
Things to try:
Add parentheses inside the map()
look for redefinitions of the map() builtin itself that might be confusing Pycharm
You inspired me to go learn more about Python and Pycharm. :)
It looks like Pycharm is happier with using a list comprehension than with map().  Using this sample data:
data = {
    'data': {
        'children': [
            {'data': {'url': 'http://1.com/', }, },
            {'data': {'url': 'http://2.com/', }, },
if you write the code like you did, then you get the error:
items = map(lambda children: children['data'], data['data']['children'])
for item in items:
    print item['url']  # Pycharm shows warning on 'url'
But if you use a list comprehension instead, then Pycharm is happy:
items = [x['data'] for x in data['data']['children']]
for item in items:
    print item['url']  # No warning from Pycharm
And the output is the same for both.
ISTR reading that list comprehensions are preferred over map() nowadays anyway, so maybe Pycharm is nudging us in that direction?