I'm trying to use the reverse() method in the following way:
>>> L=[1,2,3]
>>> R=L
>>> L.reverse()
>>> L
[3, 2, 1]
>>> R
[3, 2, 1]
Why does it reverse R as well? How do I keep the original list and create a reversed on?
Thanks!
-
1nedbatchelder.com/text/names.htmlKarl Knechtel– Karl Knechtel2017-01-21 09:19:50 +00:00Commented Jan 21, 2017 at 9:19
Add a comment
|
6 Answers
you need to make a copy of your list
L=[1,2,3]
# R=L
R = L[:]
L.reverse()
or more directly (reversing using slice notation):
R = L[::-1]
if you just write R = L then R is just a new reference on the same list L.
if you also need to copy the elements in your list, use copy.deepcopy; R = L[:] only produces a shallow copy (which is fine in your case where there are only ints in the list).
Comments
To avoid reversing R, you need a copy of L
To make a copy, change
R=L <---- this is not copying L in to R
to
R= L[:] <---- this will create a copy of L in to R
Comments
>>> L=[1,2,3]
>>> R=list(reversed(L))
>>> R
[3, 2, 1]
>>> L
[1, 2, 3]
Comments
This will do
R = L[:]
Read about copying and deep copying to understand why this is happening. In short, it is because when you do R = L, both point to the "same" list in memory so reversing one will reverse the other.
Alternately you can use deepcopy
Comments
The operation
R=L
means that the variable R stores whatever L is storing i.e R references to whatever value L is refering. Now, when you reverse L, it means the list L is refering to is reversed.As R is also refereing same address, you are seeing R as reversed.
Comments
You have been bitten by the fact that Python assigns references, not copies.
Python uses reference exclusively in order to prevent unneeded copies. It uses references also when passing function arguments, and even with default function arguments. It only makes a copy when you explicitly tell it to, e.g. by doing
L = list(R)
or
from copy import copy
L = copy(R)
The difference between the two is that list(R) always returns a list, where copy returns an object of the same type as the original. Also, copy does not work with iterators, but list does.
Note that these are 'shallow' copies. If the list contains objects, the new list contains references to the same objects. For 'deep' copies, it has the function deepcopy in the module copy.
from copy import deepcopy
L = deepcopy(R)
But in practise there is rarely a need to make explicit copies. Python provides e.g. the reversed built-in that can be used to iterate through the list.
for l in reversed(L):
# do stuff
It returns an iterator, so it is efficient. No need to duplicate the list. Other cases where a copy might be needed can be handled by e.g. generator functions. A valid case for a copy might be when pasing data past thread boundaries.
3 Comments
Hana
Thanks. I tried that but I get: >>> L=[1,2,3] >>> R=reversed(L) >>> R <list_reverseiterator object at 0x02DB0E10> >> What do I do wrong?
EvertW
The result of
reversed is not for storing in a variable, but for use in a for loop (or list comprehension). No need to store duplicate data... I have updated my answer.
campeterson
@Hana you need
R=list(reversed(L))