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.

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

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

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]