尝试存储类变量以供以后使用

Question

I'm trying to make a game, and I want to save the position of the player before he moves (oldPosition), so that I can use it later. The problem is that by the time World.UpdateContents() runs, oldPosition is updated along with self.position. How can I keep oldPosition from changing when self.position does?

def Move(self, direction):
    oldPosition = self.position
    print oldPosition
    if direction == "Up":
        if self.position[0] - 1 in World.worldMap[0]:
            self.position[0] -= 1
    if direction == "Down":
        if self.position[0] + 1 in World.worldMap[0]:
            self.position[0] += 1
    if direction == "Left":
        if self.position[1] - 1 in World.worldMap[1]:
            self.position[1] -= 1
    if direction == "Right":
        if self.position[1] + 1 in World.worldMap[1]:
            self.position[1] += 1
    print oldPosition
    World.UpdateContents(world, oldPosition, self.position, self.icon)

Answer 1

The attribute position is a list, when you assign it to oldPosition you're creating a reference to that list, but any modification you make on position will also be reflected on oldPosition - they're pointing to the same object. To solve this problem, make a copy of position at the beginning, like this:

oldPosition = self.position[:]

Now oldPosition is a new, different list and it won't be affected by the changes made to position .

Answer 2

you need to do oldPosition = list(self.position), assuming that self.position is a list. This way, oldPosition is not only a reference to self.position but a new list with same values.

Answer 3

Oscar Lopez is right, and his solution will work. The problem you're facing is due to the fact that lists in python are mutable. What does this mean?

Well, say we have some non-mutable variable, such as an integer. We can do, say,

x = 3
y = x
x = x + 1
print "x =", x, "y =", y

which, as expected, returns:

x = 4 y = 3

This happens because the line "y = x" creates a copy of the integer x inside of the variable y. We can do whatever we want now to x and y doesn't care, because it is not tied to the variable x after its declaration.

If we do similar operations to lists, we get different results.

x = [1,2,3]
y = x
x.append(4)
print "x =", x, "y =", y

returning

x = [1,2,3,4] y = [1,2,3,4]

So what just happened? Because lists are mutable, when we let y equal x here, instead of creating a copy of x in y, python makes y point to the same data that x points to. So, when we change x, y appears to have magically changed along with it, which makes sense, as the variable y is referring to the same thing that x does. The connection between x and y with mutable types like lists and dictionaries lasts beyond the line "y = x".

To counteract this, y = x[:] works, which is essentially the same as doing

y = [] # y is a brand new list!
for elem in x:
    y.append(elem)