Pass a List into Python Function

Question

As a new python programmer, I have two questions about list and really appreciate your advice:

Question 1:

For the following code:

nums1 = [1,2,3,8,0,0,0]
m = 3
nums2 = [2,5,6]
n = 3
def merge(nums1, m, nums2, n):
    nums1[:] = sorted(nums1[:m]+nums2)
merge(nums1, m, nums2, n)
nums1

What it does is: pass list nums1 and list nums2 into merge function, and merge them into list nums1 with the first m items in nums1 and n items in nums2, and sort list nums1. So the results are: [1, 2, 2, 3, 5, 6] So my question is: since list nums1 was defined outside the scope of function merge, how come it has the ability to update nums1? And in the following example:

x = 10
def reassign(x):
    x = 2
reassign(x)
x

Variable x was defined outside of function reassign, and the reassign function was not able to update x defined outside of reassign, which is why x returns 10.

Question 2:

In the above code I provided, if I write it like the following:

Note: I just modified nums1[:] into nums1 when assigning sorted(nums1[:m]+nums2)

nums1 = [1,2,3,8,0,0,0]
m = 3
nums2 = [2,5,6]
n = 3
def merge(nums1, m, nums2, n):
    nums1 = sorted(nums1[:m]+nums2)
merge(nums1, m, nums2, n)
nums1

nums1 returns [1,2,3,8,0,0,0], so my question is: after adding [:] after nums1, how come the function has the ability to nums1? What does [:] in that example?

Does https://stackoverflow.com/questions/32448414/what-does-colon-at-assignment-for-list-do-in-python help? — Andrej Kesely, Dec 04 '19 at 23:16
*variables* have scope, not objects. Different variables in different scopes can refer to the same object, which is what happens when you pass an argument — juanpa.arrivillaga, Dec 05 '19 at 00:37
So, simply put, using `nums[:] = whatever` is a *mutator method*, and sinve both your local and global variables are referring to the *same list* then you see the effect in your local variable. Read the following: https://nedbatchelder.com/text/names.html — juanpa.arrivillaga, Dec 05 '19 at 00:49

felipe · Accepted Answer · 2019-12-05T03:19:20.140

To replicate what you are saying, take the following:

var = 10
lst = [1, 2, 3]

def func():
    var = 11
    lst[:] = [1, 2, 3, 4]

func()
print(var, lst)

The above will output 10 [1, 2, 3, 4]. Now notice the following:

var = 10
lst = [1, 2, 3]

def func():
    print(var)
    print(lst)

func()

Outputs 10 [1, 2, 3] -- so we know that functions can access global variables, but in most cases cannot modify them. Now let us look at both cases (int and list): The two cases are followed:

The var variable is not being modified due to the difference of reference between local and global scope (while we can access the global scope, we can't modify it). I recommend playing around with printing globals() and locals() for fun. This case can be fixed if we do:

def func():
    global var
    var = 11

The lst variable is being modified with the [:] notation because as referenced here, the slice assignment [:] utilizes the operator function setitem(). Therefore, technically, lst[:] = is the equivalent of doing:

from operator import setitem

lst = [1, 2, 3]

# Both of these are equivalent. 
lst[:] = [1, 2, 3, 4] 
setitem(a, slice(0, len(a)), [1, 2, 3, 4])

setitem does not discriminate between local or global scopes.

This is *slice assignment* no copy is made. This is totally wrong: "Therefore, for the case of the lst variable the addition of the operator [:] returns a copy of the global lst, but with reference attached to the original lst." Note, *objects* are neither local not global, variables have scope, not objects — juanpa.arrivillaga, Dec 05 '19 at 00:38
You are completely right @juanpa.arrivillaga -- did further research on the topic (got myself originally mixed up) and fixed above, thank you for pointing this out. — felipe, Dec 05 '19 at 00:50

score 0 · Answer 2 · answered Dec 04 '19 at 23:37

(Don't use the [:] thing. That's horrible.)

My informal answer

When you say nums1[:] Python is finding the GLOBAL list called nums1. However, inside of a function, Python pays attention to new variables first. Why?
- it would suck if any variable name you ised outisde of a function, was now restricted from being used as DIFFERENT variable inside the function

H = True # some variable.pretend it means "High"

def euro_height(inches):
    H = inches # since H is a nice abbrev for height in inches
    return H*2.54 # Centimeters

I don't want my H inside the function to overwrite something I already stored. Therefore, within euro_height, H is considered a different local variable, which only that function can see and use. If I want to use the H from outside of the function, I'd have to first tell Python to access it. Then I can use it.

H = True # some variable.pretend it means "High"

def euro_height(inches):
    global H
    print(H) # will say true

    renamed_var = inches # since H is a nice abbrev for height in inches
    return renamed_var*2.54 # Centimeters

If I were to assign H = inches inside the function now, it would overwrite the True value for the global H. So instead, I rename it, because there is already an H I want to use.

The name for all this is called namespaces. Hopefully, you are doing a Python tutorial. You will understand this when they teach functions. I highyl suggest doing a tutorial if you aren't.

For more about this answer related to what happened to you, look at the interactive examples here https://www.programiz.com/python-programming/global-local-nonlocal-variables

Also, never use mylist[:] again. =) It's poor syntax. It just returns the entire list. so just use the name of the list mylist. By adding the brackets, you forced finding og the global var, and created your problem

You aren't slicing the list, that is *slice assignment* and it isn't poor syntax, although, many consider it bad practice to mutate arguments to functions. And it *didn't* find the global variable because of the slice assignment, it was using a local variable — juanpa.arrivillaga, Dec 05 '19 at 00:40
Thanks for the clarification. As for the slice assignment, it's useless to us `[:]` if you are using the entire object anyway. If you aren't using any indices, then you aren't assigning to any particular slice, just the entire list ` nums1[:] = sorted(nums1[:m]+nums2)` doesn't need the `[:]` after nums1 on the left. That's what I was talking about. — VISQL, Dec 05 '19 at 01:39
Yeah, that's simply wrong. It's not useless, it's the idiomatic way of modifying the entire list. If you didn't use slice assignment, then it wouldn't modify the list. It's two totally different things — juanpa.arrivillaga, Dec 05 '19 at 01:55

score 0 · Answer 3 · answered Dec 05 '19 at 00:01

If you are confused, take the following.

Firstly placement and change are not the same things

nums1 = [1,2,3,8,0,0,0]
lst = None
m = 3
nums2 = [2,5,6]
n = 3
def merge(nums1, m, nums2, n):
    global lst 
    lst = sorted(nums1[:m]+nums2)
merge(nums1, m, nums2, n)
print(lst)

nums1[:] means your whole list. If you use nums1[:] instead of nums1 You can change your former nums1[:] list using sorted(nums1[:m]+nums2). When you do this change what both your former and latest list, so you in the nums1 array list changing new with new attached variables place each other. But if you use only nums1 instead of nums1[:] the latest nums1 now refers to a different list from the former.

Pass a List into Python Function

3 Answers3

My informal answer