This is nothing to do with your originally requested issue, which I
can't see the cause of in your script there. But when you assign a
list, you just get another reference to the same list.

The usual reason for such a symptom is a nested list, where you have
multiple references to the same inner list inside the outer.  When you
change one of those, you change all of them.

alist = [1, 2, 3]
blist = [alist, alist, alist]   #  or blist = alist * 3
print blist
alist.append(49)
print blist

davea@think:~/temppython$ python jimbo.py
[[1, 2, 3], [1, 2, 3], [1, 2, 3]]
[[1, 2, 3, 49], [1, 2, 3, 49], [1, 2, 3, 49]]

Solution to this is to make sure that only copies of alist get into
blist.  One way is

blist = [alist[:], alist[:], alist[:]]

More generally, you can get into this type of trouble whenever you have
non-immutable objects inside the list.

Understand, this is NOT a flaw in the language.  It's perfectly
reasonable to be able to do so, in fact essential in many cases, when
you want it to be the SAME item.

--

py> first_list = [1, 2, 3]
py> second_list = first_list  # THIS IS NOT A COPY
py> second_list.append(9999)
py> print first_list
[1, 2, 3, 9999]

py> first_list = [1, 2, 3]
py> second_list = list(first_list)
py> second_list.append(9999)
py> print first_list
[1, 2, 3]

What aren't you telling us? My guess is that there are TWO lists
involved, and you're only copying ONE:

py> a = [1, 2, 3]
py> a.append(["ham", "spam", "cheese"])
py> print a
[1, 2, 3, ['ham', 'spam', 'cheese']]
py> b = list(a)  # make a copy of a, but not the contents of a
py> b.append(99)  # change b
py> b[-1].append("tomato")
py> print a
[1, 2, 3, ['ham', 'spam', 'cheese', 'tomato']]

Notice that b is a copy of a: changing b does not change a. But the
embedded list within a is *not* copied, so whether you append to that
list via a or b is irrelevant, both see the same change because there is
only one inner list in two places.

It might be more obvious if you give the shared sublist a name:

c = ['ham', 'spam', 'tomato']
a = [1, 2, 3, c]
b = [1, 2, 3, c]  # a copy of a, but not a copy of c

Now it should be obvious that any changes to c will show up in both a and
b, regardless of how you change it. All three of these will have the
exact same effect:

a[-1].append('eggs')
b[-1].append('eggs')
c.append('eggs')

The way to copy lists, and all their sublists, and their sublists, and so
on all the way down, is with the copy module:

import copy
b = copy.deepcopy(a)

but if you are doing this a lot, (1) your code will be slow, and (2) you
can probably redesign your code to avoid so many copies.

By the way, instead of dumping lots of irrelevant code on us, please take
the time to narrow your problem down to the smallest possible piece of
code. We're volunteers here, and you are not paying us to wade through
your code trying to determine where your problem lies. That is up to you:
you narrow down to the actual problem, then ask for help.

Please read http://sscce.org/ for more details of how, and why, you
should do this.

Thank you.

These sorts of issues only ever seem to crop up with nested arrays,
which strengthens this next point: Deep copying is a really REALLY
hairy concept. It seems so simple at first:

a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
b = deepcopy(a) # b is a new list with three new sublists

But then it gets messy.

a = [[1, 2, 3]]*2 + [[7, 8, 9]]

It's much better to make copying a very explicit thing; it's so
expensive that you really should make it very clear in your code when
this happens.

b = copy.deepcopy(a)

as in Steven's post. And in case I wasn't clear about it, the
deepcopy() function does deal with the issue I mention, but that's
part of why it's an expensive operation.

Pascal let's you pass arrays around either by value (which copies them,
and may be expensive) or by reference (which doesn't), neither of which
is what Python (or Java, Ruby, etc.) do. Passing pointers by value is not
the same as Python object semantics.