CODEWITHSUNDEEP
python-3.xlistslicemutable
Aguy
Aguy

Reputation: 169

Why is taking a slice of a list which is assigned to another list not changing the original?

I have a class that is a representation of a mathematical tensor. The tensor in the class, is stored as a single list, not lists inside another list. That means [[1, 2, 3], [4, 5, 6]] would be stored as [1, 2, 3, 4, 5, 6].

I've made a __setitem__() function and a function to handle taking slices of this tensor while it's in single list format. For example slice(1, None, None) would become slice(3, None, None) for the list mentioned above. However when I assign this slice a new value, the original tensor isn't updated.

Here is what the simplified code looks like

class Tensor:
    def __init__(self, tensor):
        self.tensor = tensor # Here I would flatten it, but for now imagine it's already flattened.

    def __setitem__(self, slices, value):
        slices = [slices] 
        temp_tensor = self.tensor # any changes to temp_tensor should also change self.tensor.

        for s in slices: # Here I would call self.slices_to_index(), but this is to keep the code simple.
            temp_tensor = temp_tensor[slice]

        temp_tensor = value # In my mind, this should have also changed self.tensor, but it hasn't.

Maybe i'm just being stupid and can't see why this isn't working. Maybe my actual questions isn't just ' why doesn't this work?' but also 'is there a better way to do this?'. Thanks for any help you can give me.

NOTES:

Each 'dimension' of the list must have the same shape, so [[1, 2, 3], [4, 5]] isn't allowed.

This code is massively simplified as there are many other helper functions and stuff like that.

in __init__() I would flatten the list but as I just said to keep things simple I left that out, along with self.slice_to_index().

Upvotes: 1

Views: 34

Answers (1)

Netwave
Netwave

Reputation: 42678

You should not think of python variables as in c++ or java. Think of them as labels you place on values. Check this example:

>>> l = []
>>> l.append
<built-in method append of list object at 0x7fbb0d40cf88>
>>> l.append(10)
>>> l
[10]
>>> ll = l
>>> ll.append(10)
>>> l
[10, 10]
>>> ll
[10, 10]
>>> ll = ["foo"]
>>> l
[10, 10]

As you can see, ll variable first points to the same l list but later we just make it point to another list. Modifying the later ll won't modify the original list pointed by l.

So, in your case if you want self.tensor to point to a new value, just do it:

class Tensor:
    def __init__(self, tensor):
        self.tensor = tensor # Here I would flatten it, but for now imagine it's already flattened.

    def __setitem__(self, slices, value):
        slices = [slices] 
        temp_tensor = self.tensor # any changes to the list pointed by temp_tensor will be reflected in self.tensor since it is the same list

        for s in slices: 
            temp_tensor = temp_tensor[slice]

        self.tensor = value

Upvotes: 1

Related Questions