Warning about mutable default argument in PyCharm

问题:

I am using PyCharm (Python 3) to write a Python function which accepts a dictionary as an argument with attachment={}.

def put_object(self, parent_object, connection_name, **data):
    ...

def put_wall_post(self, message, attachment={}, profile_id="me"):
    return self.put_object(profile_id, "feed", message=message, **attachment)

In the IDE, attachment={} is colored yellow. Moving the mouse over it shows a warning.

Default arguments value is mutable

This inspection detects when a mutable value as list or dictionary is detected in a default value for an argument.

Default argument values are evaluated only once at function definition time, which means that modifying the default value of the argument will affect all subsequent calls of the function.

What does this mean and how can I resolve it?

回答1:

If you don't alter the "mutable default argument" or pass it anywhere where it could be altered just ignore the message, because there is nothing to be "fixed".

In your case you only unpack (which does an implicit copy) the "mutable default argument" - so you're safe.

If you want to "remove that warning message" you could use None as default and set it to {} when it's None:

def put_wall_post(self,message,attachment=None,profile_id="me"):
    if attachment is None:
        attachment = {}

    return self.put_object(profile_id,"feed",message = message,**attachment)

---

Just to explain the "what it means": Some types in Python are immutable (int, str, ...) others are mutable (like dict, set, list, ...). If you want to change immutable objects another object is created - but if you change mutable objects the object remains the same but it's contents are changed.

The tricky part is that class variables and default arguments are created when the function is loaded (and only once), that means that any changes to a "mutable default argument" or "mutable class variable" are permanent:

def func(key, value, a={}):
    a[key] = value
    return a

>>> print(func('a', 10))  # that's expected
{'a': 10}
>>> print(func('b', 20))  # that could be unexpected
{'b': 20, 'a': 10}

PyCharm probably shows this Warning because it's easy to get it wrong by accident (see for example “Least Astonishment” and the Mutable Default Argument and all linked questions). However, if you did it on purpose (Good uses for mutable function argument default values?) the Warning could be annoying.

回答2:

You can replace mutable default arguments with None. Then check inside the function and assign the default:

def put_wall_post(self, message, attachment=None, profile_id="me"):
    attachment = attachment if attachment else {}

    return self.put_object(profile_id, "feed", message=message, **attachment)

This works because None evaluates to False so we then assign an empty dictionary.

In general you may want to explicitly check for None as other values could also evaluate to False, e.g. 0, '', set(), [], etc, are all False-y. If your default isn't 0 and is 5 for example, then you wouldn't want to stomp on 0 being passed as a valid parameter:

def function(param=None):
    param = 5 if param is None else param

回答3:

To rephrase the warning: every call to this function, if it uses the default, will use the same value. So long as you never change that value, the fact that it is mutable won't matter. But if you do change it, then subsequent calls will start with the modified value, which is probably not what you want.

One solution to avoid this issue would be to have the default be a immutable value, and set the parameter to {} if that default is used:

def put_wall_post(self,message,attachment=None,profile_id="me"):
    if attachment==None:
        attachment={}
    return self.put_object(profile_id,"feed",message = message,**attachment)

回答4:

• Lists are mutable and as declaring default with def at declaration at compile time will assign a mutable list to the variable at some address

  def abc(a=[]):
      a.append(2)
      print(a)
  
  abc() #prints [2]
  abc() #prints [2, 2] as mutable thus changed the same assigned list at func delaration points to same address and append at the end
  abc([4]) #prints [4, 2] because new list is passed at a new address
  abc() #prints [2, 2, 2] took same assigned list and append at the end 
  

   

• To correct this:

  def abc(a=None):
       if not a:
           a=[]
       a.append(2)
       print(a)
  

   

  • This works as every time a new list is created and not referencing the old list as a value always null thus assigning new list at new address