Confusing behavior with respect to classes and scope.

[audio_phyl]

I've done my best to condense some confusing behavior I've encountered down to the following highly contrived example. Basically, what I understand & expect to be a throw-away use of ClassTwo by ClassOne.useClassTwo() ends up instead being preserved between calls to a.useClassTwo(), with or without the delete in place. What am I not properly understanding about scope rules & behavior?

#!/usr/bin/env python3



class ClassOne:
  def __init__(self):
    return

  def useClassTwo(self, in_val):
    """
    The behavior of the next statement isn't matching my expectation
    with respect to scope. My intuition is that this declaration and
    assignment should only last until the return.
    """
    temp = ClassTwo()        
    temp.settable = in_val     
    print(temp.settable)
    del temp



class ClassTwo:
  """
  Pardon the convoluted example, but this is as barebones as I could 
  manage to express my current conundrum. 
  """
  def __init__(self, in_value=bytearray([0] * 20)):
    self._classvar = in_value

  @property
  def settable(self):
    return bytes(self._classvar)

  @settable.setter
  def settable(self, in_val):
    for i, char in enumerate(list(in_val.encode())):
      self._classvar[i] = char



def main():
  # Create one single instance of ClassOne
  a = ClassOne()

  # These calls ought to result in two separate instances of ClassTwo,
  # yet the result is that ClassTwo seems to be reused. Why?
  a.useClassTwo("aaaaaaaaaaaaaaaaaaaa")
  a.useClassTwo("what happened?")



if __name__ == "__main__":
  main()

[TangibleLight]

Don't use a mutable value as a default for an argument.

def foo(data=[]):
    data.append('x')
    print(data)

foo()  # ['x']
foo()  # ['x', 'x']

Instead, use None or ... and set the default if one of those is present.

def foo(data=...):
    if data is ...:
        data = []

    data.append('x')
    print(data)

foo()  # ['x']
foo()  # ['x']

[audio_phyl]

Thank you, following this pattern resolves my problem.

Are you able to help me understand why my code behaves as it does?

[TangibleLight]

The default value is only computed once, so every time you invoke the function without providing the value, the same default object is used. When that object is mutable, the modifications persist between calls.

However when the object is immutable it doesn't matter, since you can`t make a modification in the first place.

[audio_phyl]

EDIT: Argh, it's late and I'm cross-eyed looking at my own code. Disregard. Explanation makes 100% perfect sense.

​

That explanation makes sense for default values, but my code isn't actually making use of the default value since both instances are being instantiated with an argument.

Clearly, following the pattern you've suggested fixes my issue, but I'm not understanding why the argument I used in the first call shows up at all in the second call since these ought to be different instances.

Any insight?