What I think you are asking is why after calling f(a), when f re-assigns the a you passed, a is still the "old" a you passed.

The reason for this is how Python treats variables and pass them to functions. They are passed by reference, but the reference is passed by value (meaning that a copy is created). This means that the reference you have inside f is actually a copy of the reference you passed. This again implies that if you reassign the variable inside the function. It is a local variable existing only inside the function; re-assigning it won't change anything in outside scopes.

Now, if you rather than reassigning the local variable/reference inside f (which won't work, since it's a copy) perform mutable operations on it, such as append(), the list you pass will have changed after f is done.

See also the question How do I pass a variable by reference? which treats the problem and possible solutions in further detail.

TL;DR: Reassigning a variable inside a function won't change the variable you passed as an argument outside the function. Performing mutable operations on the variable, however, will change it.

please goto http://www.pythontutor.com/visualize.html to visualize your code. It'll give you a more accurate explanation.

Here is a short explanation and two possible solutions for you question:

list1 = list1[2:]

This line creates a new list and assign it to local variable list1 in func namespace, while keeps the global one still.

If you want to change the original list:

1. Please use change in place methods(remove, pop etc) for list which can be found here.

2. Or you can return a new list like this:

   def func(list1):
       list1 = list1[2:]    
       print(list1)   # prints [2, 3]
       return list1
   
   list1 = [0, 1, 2, 3]
   list1 = func(list1)
   print(list1)       # prints [2, 3]
   

Hope it helps.

thisArray is re-assigned to a new list object by slicing, so any changes after that don't affect the original list passed into the function. Note the instance IDs of the lists:

def reverse_this(thisArray):
    
    saved_first = thisArray[0]
    print(f'thisArray pre-slice:  {id(thisArray):#x}')
    thisArray = thisArray[1:]
    print(f'thisArray post-slice: {id(thisArray):#x}')
    thisArray.reverse()
    thisArray.insert(0,saved_first)

myList = ['foo', 1,2,3,4,5]
print(f'myList pre-call:      {id(myList):#x}')
reverse_this(myList)
print(f'myList post-call:     {id(myList):#x}')
print('after:', myList)

myList pre-call:      0x1e2f5713500
thisArray pre-slice:  0x1e2f5713500  # parameter refers to original list
thisArray post-slice: 0x1e2f5753800  # thisArray refers to new list
myList post-call:     0x1e2f5713500  # original list isn't changed.
after: ['foo', 1, 2, 3, 4, 5]

In Python, variables are names of objects. If you mutate an object, all names of that object "see" the change. A slice makes a new object, and in this case the name was reassigned to the new object.

To fix it, assign the slice into the full range of the original list, which mutates the original list instead of creating a new one:

def reverse_this(thisArray):
    
    saved_first = thisArray[0]
    thisArray[:] = thisArray[1:]   # replace entire content of original list with slice.
    thisArray.reverse()            # thisArray still refers to original list here.
    thisArray.insert(0,saved_first)

myList = ['foo', 1,2,3,4,5]
reverse_this(myList)
print('after:', myList)

after: ['foo', 5, 4, 3, 2, 1]

When assigning to a slice, a section of a list is replaced in place with another list. It doesn't necessarily have to be the same size.

Another example:

>>> s = list(range(10))
>>> s
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> id(s)
2339680033664
>>> s[4:7] = [10,10]           # replace indices 4 up to but not including 7
>>> s
[0, 1, 2, 3, 10, 10, 7, 8, 9]
>>> id(s)                           # id didn't change
2339680033664

You can do that using a for loop, but it is much faster and more readable to use the bulit-in list comprehensions:

the_list=["Python", "Programming"]
the_list = [x.lower() for x in the_list]
print the_list

Hope this helps. The [:] retains the original list by making a copy or slice of the the original list to be used in the function being called. The exercises in the book are 8-9 to 8-11 on page 150 Crash course in Python.

def meta_mags(show_mags, great_mags):
    """(Change regular show magicians to Great magicians by moving them 
     to another list using a function meta_mags)"""
    while show_mags:
        change_mags = show_mags.pop()
        # show the change from one list show_mags to great_mags
        print("Great magicians: " + change_mags.title())
        great_mags.append(change_mags)


def show_great_mags(great_mags):
    """Print --The Great--- after each great_mags magicians name"""
    for great_mag in great_mags:
        print(great_mag.title() +" The Great will be performing tonight !") 


show_mags = ['alice', 'david', 'carolina']
great_mags = []
meta_mags(show_mags[:], great_mags)
show_great_mags(great_mags) 
print(show_mags)

you can do it very easy with list comprehension.

n = [3, 5, 7]

def double_list(x):
  return [y*2 for y in x]

print double_list(n)
'[6, 10, 14]'

lis=[[1,2],[3,4,5]]

def zu(l):
    import copy
    lcop=copy.deepcopy(l)
    while True:
        for i in range(len(lcop)):
            lcop=copy.deepcopy(l)
            for k in range(len(l[i])):
            lcop[i].pop()
    l=copy.deepcopy(lcop)
        break
    print l
    return l


lis = zu(lis) # Here is the changes
print lis

But list is mutable in python so if you wanna modify the original list, just access the list inside the function without making a copy of it then it will change the original list you have outside, too.

for example

lis=[1,2,3]
print lst # print [1,2,3]
def zu(l):
    l[0] = [5]
zu(lis)
print lis # print [5,2,3]

There are many reason why it is not working.

First, in the function read_occupation, you are changing the binding of a local variable. The original object is left untouched. On the contrary, in get_p_values, you are modifying the object (the [] operator call the __setitem__ function of the object that change the internal representation). A better idea in this case would be to use a proper object.

If you want to change the whole content of the list in read_occupation, you can use the list splicing operator to assign to the whole list:

def read_occupation(matrix):
    matrix[:] = [ [1, 2, 3] ]

BTW, if you call you function read_occupation the caller will probably expect it not to change its parameter. You should probably rename it update_occupation or something like that.

Second, when you create your variables, via multiplication, you get a list where every index contains a reference to the same item. The code p = [ [0] ] * 3 is equivalent to:

>>> l = [0]          # Naming the list for more clarity
>>> p = [ l, l, l ]  # Each index points to the same list `l`

Third, the Process class expect a tuple (or in fact an object following the iterable protocol) for its args parameter. You are not passing a tuple, but a single item that happens to be a list of one int (which is why you get a TypeError exception). You need to use the following syntax to pass a tuple:

# Please note the comma after the closing bracket, it is important
p1 = Process( target=read_occupation, args=( matrix[ index     ], ) )

# In python, the syntax for a tuple is weird for tuple of size < 2
#  . tuple of 0 item:  ()
#  . tuple of 1 item:  (1,)
#  . tuple of 2 items: (1, 2)

Fourth, you use multiprocessing.Process that spawn a new process in which your code is executed. There is no communication back in your code (I don't know if it is possible to communicate back from this process to the original one). So the variable in the original code is not modified.