# Why does a^=b throw an error when a=a^b does not?

My class’ xor function is working as intended but when doing a^=b, I get ‘TypeError: unsupported operand type(s) for ^=: ‘NoneType’ and ‘Multiset.” Relevant code below:

``````def __xor__(self,o):
d=Multiset() #subclass of dict
for x in self|o: #for each item in both multisets
m=abs((self[x] if x in self else 0) - (o[x] if x in o else 0)) #determines absolute difference of multiplicities of each element
if m>0:
return d

def __ixor__(self,o):
self=self^o
``````

I have confirmed that a^b returns a Multiset and that setting a=a^b does not throw an error. I have tried commenting out the ixor definition as well as rewriting it as follows:

``````def __ixor__(self,o):
buffer=self^o
self=buffer
``````

At this point, I’m just about out of ideas of what the problem could be.

### >Solution :

The implementation of `__ixor__` method is wrong the assignment `self = buffer` cannot be correctly assigned as it is not passed by reference.

In Python you can try perform an assignment like `self = buffer` and so you’re actually rebinding the local variable `self` to a new object (in this case, the `buffer` object). However, this doesn’t modify the instance itself, and that’s why you’re not seeing the expected changes outside of the method.

So try to modify the attributes of the instance itself to reflect the changes made by the XOR operation. Here’s the corrected implementation:

``````def __ixor__(self, o):
result = self ^ o  # Calculate the XOR result using __xor__
self.clear()  # Clear the current instance
self.update(result)  # Update the instance with the new result
return self  # Return the modified instance
``````

In this implementation, we first calculate the XOR result using the `__xor__` method. Then, we clear the current instance using the `clear` method (assuming `Multiset` has this method) to remove all existing items. Finally, we update the instance with the new result using the `update` method.

By returning `self` at the end, we ensure that the method conforms to the expected behavior of an in-place operation and that the instance is properly modified.