Python：为什么从对象检索列表后，列表会发生变化

Question

Simple question, I've scaled down a problem I'm having where a list which I've retrieve from an object is changing when I append more data to the object. Not to the list.

Can anyone help my understand the behavior of python?

class a():
    def __init__(self):
        self.log = []
    def clearLog(self):
        del self.log[:]
    def appendLog(self, info):
        self.log.append(str(info))
    def getLog(self):
        return self.log

if __name__ == '__main__':
    obj = a()
    obj.appendLog("Hello")

    # get an instance as of this moment....
    list = obj.getLog()
    print list

    obj.appendLog("World")

    # print list, BUT we want the instance that was obtained
    # before the new appendage.   
    print list

OutPut:

['Hello']
['Hello', 'World']

Answer 1

When you code

`list = obj.getLog()`

(ignoring -- just for a second -- what a terrible idea it is to use identifiers that shadow builtins!!!) you're saying: "make name list refer to exactly the same object that obj.getLog() returns" -- which as we know from the code for class a is obj.log . So of course since now you have one list object with two names, when you alter that object through either name, all alterations will be fully visible from both names, of course -- remember, there is just one object, you're just using multiple names for it! You never asked for a copy, so of course Python made no copies.

When you want a copy, instead of the original, ask for one ! When you know the type you require (here, a list), the best way is to call the type, ie:

mylist = list(obj.getLog())

This of course becomes impossible if you choose to trample all over the builtins with your identifiers -- -- which is a good part of why such identifier choice is a BAD idea (I can't stress that enough: it's hard to think of any worse style choice, to use in your Python coding, than such naming). So, I've renamed the identifier to mylist (and of course you need to rename it in the two print statements).

You could use highly unreadable or slower approaches to make up for the wanton destruction of the normal functionality of built-in identifier list , of course -- eg:

import copy
list = copy.copy(obj.getLog())   # somewhat slower

or

list = obj.getLog()[:]           # traditional, but ECCH

or

temp = obj.getLog()
list = type(temp)(temp)          # abstruse

but BY FAR the simplest, cleanest, most recommended approach is to NOT name your identifiers the same as Python built-ins (it's also a nice idea to avoid naming them just like modules in the standard Python library, for similar though a bit weaker reasons).

Answer 2

The only place you create a new list is in the constructor, with the statement:

self.log = []

Later, when you do:

list = obj.getLog()

just puts a reference to the same list in a new variable (note, don't use list as a variable name, since it shadows the type). It does not create or clone a list in any way. If you want to clone it, do:

def getLog(self):
    return list(self.log)

You can also use a tuple (read-only sequence), if that's appropriate:

def getLog(self):
    return tuple(self.log)

This may help minimize confusion about which should be modified.

Answer 3

Look at this method:

def getLog(self):
        return self.log

You've returned a reference to self.log and assigned it to list. Now they both point to the same list on the heap. When you change self.log, list points to the same location in memory.

You'd have to make a clone and assign that to list for the two to be independent.

Answer 4

Objects are passed around in Python by reference - Python doesn't make copies for you. The line

return self.log

returns a reference to the list object used internally by obj . This means that after the line

list = obj.getLog()

your list variable refers to the same object as obj.log . To acquire a copy instead, use Python's slice syntax:

list = obj.getLog()[:]

Answer 5

What this boils down to is that languages like python and ruby try to make it easy for people to refer to arbitrary, complex objects - associative containers of lists of associative containers and such like. These get too complex to index into repeatedly (and it would be slow), so scripters want to be able to say

galleries = world['asia']['japan'][3]['Tokyo']['Galleries']

then make queries against or updates to the galleries in Tokyo. That is sometimes convenient (when doing updates), sometimes - as in your case where you think you've made a private copy of some data and want to massage one without affecting the other - very confusing and inconvenient. But, most scripting languages will adopt this same strategy because to make full independent copies of the data each time would be hideously slow for the common case of just wanting a "handle" through which to inspect some part of the larger data structure. It's ugly and inconsistent with the way they handle basic types like numbers and textual strings. As others have said, you need to use:

new_list = original_list[:] # slice off a complete copy of a list
new_dictionary = original_dictionary.copy()  # for dictionaries