How can I achieve this in python

Question

Here's some code:

li=[1,2,3]
def change(l):
    l[2]=10
change(li)
print li
[1, 2, 10]

But I want this:

li=[1,2,3]
def change(l):
    l=[1,2,10]
change(li)
print li
[1,2,3]

For some reason,I have to change whole list in method,how can I achieve this?Anything wrong or my mistake?

Answer 1

When you want to change the entire list inside a method, you'll probably want to create a copy and return it:

def change(li):
   new_list = li[:] #copy
   new_list[2] = 10
   return new_list

li = [1,2,3]
new_lst = change(li) #new_lst = [1,2,10]

---

If you don't want to return the list, but want to modify in place, you can use slice assignment (*warning: This is not common practice):

def change(li):
    li[:] = [1,2,10]

li = [4,5,6]
change(li)
print(li) #[1, 2, 10]

Answer 2

Like this:

li = [1, 2, 3]

def change(l):
    l[:] = [1, 2, 10]

change(li)
print li  # [1, 2, 10]

The reason your approach does not work is that in python, variables are simply names that reference objects. When you write l = [1, 2, 10] you're re-binding the name l to refer to the new list you've just created, the old list is unchanged and still referred to by the global variable li.

The above code instead modifies the object pointed to by l by using slice assignment.

As mgilson indicates in his answer, you should make it very clear that the function actually modifies the passed argument in-place. If not, an unsuspecting programmer might pass it a list he intends to use as-is later, only to discover that everything in it has been lost. Giving your function a name indicating modification (like you've done) and not returning anything from it are both common indicators of such functions, like for instance random.shuffle.

To achieve the same effect for a dict, the documentation tells us that this will do:

def change_dict(d):
    d.clear()  # Empty dict
    d.update({"a": 3, "b": 9})

Answer 3

Using aliasing

Documentation: List Aliasing — How to Think like a Computer Scientist (2^nd editon)

You can take advantage of Python's list aliasing (which is common gotcha for beginners).

When you pass li to the change function, l aliases to li, i.e., they both point to the same object in memory and changing one changes the other. But when you do l = [1, 2, 10], l is pointing to another list and you lose the aliasing magic. To resolve that, you can use the slice operation to replace to full list as so:

li = [1, 2, 3]
def change(l):
    l[:] = [1, 2, 10]  # doesn't make a new list
change(li)             # preserves aliasing
print li               # returns [1, 2, 10]

Using globals

Documentation: The global statement — Python Docs

The changes you're making to l inside the function are not applied to the li list outside. You can use a global to affect the li list you're trying to change:

li = [1, 2, 3]
def change():
    global li
    li = [1, 2, 10]  # use this
    li[2] = 10       # or this, up to you
change()
print li             # returns [1, 2, 10]

Answer 4

When you do the following:

def change(l):
    l=[1,2,10]

You are actually changing which list l points to. You need to change the list instance passed in to change. You can append to it, you can pop from it, etc and your changes will be made to the list you passed in. If you change your change function to what I have, your example will work.

def change(l):
    l[:] = [1,2,10]

Answer 5

In this code the l is work as common object to whole so you can check by the id() that provide the object memory location. so that's why you got the last output [1,2,10]

l = [1, 2, 3]
print id(l)
def change(l):
    l[:] = [1, 2, 10]
    print id(l)
change(l)
print l
print id(l)

if you want your desired output than you use the deepcopy that provide the diffident object to function.

from  copy  import deepcopy
l = [1, 2, 3]
print id(l)
def change(l):
    l[:] = [1, 2, 10] 
    print id(l)
change(deepcopy(l)) 
print l
print id(l)