Function changes list values and not variable values in Python

Question

Let's take a simple code:

y = [1,2,3]

def plusOne(y):
    for x in range(len(y)):
        y[x] += 1
    return y

print plusOne(y), y


a = 2

def plusOne2(a):
    a += 1
    return a

print plusOne2(a), a

Values of 'y' change but value 'a' stays the same. I have already learned that it's because one is mutable and the other is not. But how to change the code so that the function doesn't change the list?

For example to do something like that (in pseudocode for simplicity):

a = [1,2,3,...,n]

function doSomething(x):
    do stuff with x
    return x

b = doSomething(a)

if someOperation(a) > someOperation(b):
    do stuff

EDIT: Sorry, but I have another question on nested lists. See this code:

def change(y):
    yN = y[:]
    for i in range(len(yN)):
        if yN[i][0] == 1:
            yN[i][0] = 0
        else:
            yN[i][0] = 1
    return yN

data1 = [[1],[1],[0],[0]]
data2 = change(data1)

Here it doesn't work. Why? Again: how to avoid this problem? I understand why it is not working: yN = y[:] copies values of y to yN, but the values are also lists, so the operation would have to be doubled for every list in list. How to do this operation with nested lists?

In general, the easiest way to avoid confusion caused by mutation is to avoid mutation. When that isn't appropriate, the answer is to make a copy and mutate that. There really aren't any other options. — abarnert, Jul 16 '13 at 20:52
Since you accepted @kindall's answer, perhaps you will find [this blog post](http://nedbatchelder.com/text/names.html) helpful. It explains things in greater detail and (in my opinion) greater clarity. — John Y, Jul 18 '13 at 16:45

kindall · Accepted Answer · 2015-04-08T19:15:47.787

Python variables contain pointers, or references, to objects. All values (even integers) are objects, and assignment changes the variable to point to a different object. It does not store a new value in the variable, it changes the variable to refer or point to a different object. For this reason many people say that Python doesn't have "variables," it has "names," and the = operation doesn't "assign a value to a variable," but rather "binds a name to an object."

In plusOne you are modifying (or "mutating") the contents of y but never change what y itself refers to. It stays pointing to the same list, the one you passed in to the function. The global variable y and the local variable y refer to the same list, so the changes are visible using either variable. Since you changed the contents of the object that was passed in, there is actually no reason to return y (in fact, returning None is what Python itself does for operations like this that modify a list "in place" -- values are returned by operations that create new objects rather than mutating existing ones).

In plusOne2 you are changing the local variable a to refer to a different integer object, 3. ("Binding the name a to the object 3.") The global variable a is not changed by this and continues to point to 2.

If you don't want to change a list passed in, make a copy of it and change that. Then your function should return the new list since it's one of those operations that creates a new object, and the new object will be lost if you don't return it. You can do this as the first line of the function: x = x[:] for example (as others have pointed out). Or, if it might be useful to have the function called either way, you can have the caller pass in x[:] if he wants a copy made.

This is a little confusing for novices (because nobody learning programming through Python has any idea what a pointer is), and misleading for anyone else (because variables _aren't_ pointers, they're names, and the issue is about binding vs. mutation, not pointers variables vs. normal variables). — abarnert, Jul 16 '13 at 20:51

Sukrit Kalra · Answer 2 · 2013-07-16T20:54:00.180

6

Create a copy of the list. Using testList = inputList[:]. See the code

>>> def plusOne(y):
        newY = y[:]
        for x in range(len(newY)):
            newY[x] += 1
        return newY

>>> y = [1, 2, 3]
>>> print plusOne(y), y
[2, 3, 4] [1, 2, 3]

Or, you can create a new list in the function

>>> def plusOne(y):
        newList = []
        for elem in y:
            newList.append(elem+1)
        return newList

You can also use a comprehension as others have pointed out.

>>> def plusOne(y):
        return [elem+1 for elem in y]

edited Jul 16 '13 at 20:54

answered Jul 16 '13 at 20:45

Sukrit Kalra

33,167
7
69
71

Wow, thanks for a rapid responses!! I tried newY = y and it didn't work, while should have been simple newY = y[:]. – Tim Jul 16 '13 at 20:52
`newY = y` just creates another reference to it, while `newY = y[:]` creates a new list. – Sukrit Kalra Jul 16 '13 at 20:55
Yes, now I understand and everything becomes clear! Thanks! – Tim Jul 17 '13 at 05:16

Rohit Jain · Answer 3 · 2013-07-16T20:51:22.233

4

You can pass a copy of your list, using slice notation:

print plusOne(y[:]), y

Or the better way would be to create the copy of list in the function itself, so that the caller don't have to worry about the possible modification:

def plusOne(y):
    y_copy = y[:]

and work on y_copy instead.

Or as pointed out by @abarnet in comments, you can modify the function to use list comprehension, which will create a new list altogether:

return [x + 1 for x in y]

edited Jul 16 '13 at 20:51

answered Jul 16 '13 at 20:45

Rohit Jain

209,639
45
409
525

2

Or, even better, rewrite the code so it builds the copy on the fly: `y = [x+1 for x in y]`. – abarnert Jul 16 '13 at 20:49

score 3 · Answer 4 · answered Jul 16 '13 at 20:50

3

Just create a new list with the values you want in it and return that instead.

def plus_one(sequence):
    return [el + 1 for el in sequence]

answered Jul 16 '13 at 20:50

Jon Clements

138,671
33
247
280

score 2 · Answer 5 · answered Jul 16 '13 at 20:52

As others have pointed out, you should use newlist = original[:] or newlist = list(original) to copy the list if you do not want to modify the original.

def plusOne(y):
    y2 = list(y)  # copy the list over, y2 = y[:] also works
    for i, _ in enumerate(y2):
        y2[i] += 1
    return y2

However, you can acheive your desired output with a list comprehension

def plusOne(y):
    return [i+1 for i in y]

This will iterate over the values in y and create a new list by adding one to each of them

John Y · Answer 6 · 2013-07-17T21:28:44.823

2

To answer your edited question:

Copying nested data structures is called deep copying. To do this in Python, use deepcopy() within the copy module.

edited Jul 17 '13 at 21:28

answered Jul 17 '13 at 21:21

John Y

14,123
2
48
72

score 1 · Answer 7 · edited Feb 05 '19 at 13:13

1

You can do that by make a function and call this function by map function , map function will call the add function and give it the value after that it will print the new value like that:

def add(x):
    return x+x
print(list(map(add,[1,2,3])))

Or you can use (*range) function it is very easy to do that like that example :

print ([i+i for i in [*range (1,10)]])

edited Feb 05 '19 at 13:13

Tom Dee

2,516
4
17
25

answered Feb 05 '19 at 12:31

Abdulkalek

67
3

Function changes list values and not variable values in Python

7 Answers7

Linked

Related