0

I'm in a slightly tricky situation with a list subclass.

The list class I'm using has overridden __iter__ and __getitem__ in order to return something slightly different from what's actually stored internally (this is because this requires processing time which was wanted to be only done when the item is first directly accessed)

My issue comes up in the following use case. Let's say, for the use of this example, that the overridden methods turn the internal values into strings.

>>> myList = MyList([1, 2, 3])
>>> standardList = list(["a", "b", "c"])
>>>
>>> for item in myList:
>>>     print item
"1"
"2"
"3"
>>> newList = standardList + myList
>>> for item in newList:
>>>     print item
"a"
"b"
"c"
1
2
3

So what I'm after here is how the values are pulled from myList when standardList + myList is run, so that I can ensure that newList has had the relevant modifications made.

Incidentally, I'm well aware that I could get this working if I overrode MyList.__add__ and then did myList + standardList, but this is in a module that is used elsewhere, and I'd rather ensure that it works the right way in both directions.

Thanks

Hugh
  • 726
  • 1
  • 6
  • 25

2 Answers2

2

To ensure if works in both directions you should define both override both __add__ and __radd__ in your MyList class. Quoting from data model page(7th bullet point)*:

Exception to the previous item: if the left operand is an instance of a built-in type or a new-style class, and the right operand is an instance of a proper subclass of that type or class and overrides the base’s __rop__() method, the right operand’s __rop__() method is tried before the left operand’s __op__() method.

So, your code will look like:

class MyList(list):

    def __radd__(self, other):
        return MyList(list.__add__(other, self))

*Note that the proper subclass thing mentioned in Python 2 docs is actually a documentation bug and they fixed it in Python 3:

If the right operand’s type is a subclass of the left operand’s type and that subclass provides the reflected method for the operation, this method will be called before the left operand’s non-reflected method. This behavior allows subclasses to override their ancestors’ operations.

Community
  • 1
  • 1
Ashwini Chaudhary
  • 244,495
  • 58
  • 464
  • 504
  • I did a bit of looking into it - `__radd__` only works if the left operand doesn't support `__add__`, which, in this case, it does. I could just make `MyList` not be a subclass of list, though, and just re-implement the list functions... – Hugh Dec 03 '14 at 13:08
0

You can simply pass the result of list addition as in the constructor of MyList, like:

newList = MyList(standardList + myList)
Dev-an
  • 462
  • 2
  • 6
  • Except I'm fine with the resulting list being a list, the elements of myList just need to be modified first. – Hugh Dec 03 '14 at 13:09