python Modifying slice of list in function

If you slice the list, you modify only a copy, so what you want to do doesn't work in the form you want.

But you could pass an optional slice object to func1 and if it's not None, use it to perform the slice assignment (else use [:])

I would do the following (used a lambda to avoid copy/paste of the formula and a generator expression to avoid creating a useless temporary list:

def func1(a,the_slice=None):
    e = lambda y : (x**2 for x in y)
    if the_slice:
        a[the_slice] = e(a[the_slice])
    else:
        a[:] = e(a)

testing:

a = list(range(10))
func1(a)
print(a)
a = list(range(10))
func1(a,slice(5))   # stop at 5
print(a)
a = list(range(10))
func1(a,slice(5,len(a),2))  # start at 5 / stop at the end, stride/step 2
print(a)

result:

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
[0, 1, 4, 9, 16, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 25, 6, 49, 8, 81]

• in the first case, the totality of the list was changed
• in the second case, it only changed the first half.
• in the third case, it changed the second half, but 1 value out of 2 (stride=2)

This will work:

a = range(10)

a[:5] = [c**2 for c in a[:5]]

a[:5] creates a new list. Hence, the changes that func1 applies to it are not mirrorred in a. You could add the slicing to the function:

def func1(a, start=None, stop=None, step=None):
    start = start if start is not None else 0
    stop = stop if stop is not None else len(a)
    step = step if step is not None else 1
    a[start:stop:step] = [x**2 for x in a[start:stop:step]]

func1(a, stop=5)

Your issue was overlapping variables and incorrect slicing. The solution:

def func1(b):
  n = len(b)
  a[:n] = [x**2 for x in b[:n]]

a = list(range(10))
func1(a[:3].copy())
print(a)
[0, 1, 4, 3, 4, 5, 6, 7, 8, 9, 10]
    

I also noticed that in the function, the b[:n] is redundant. You can simply put it as b.

The above solution is only if it sliced from the start. I also coded a solution for it to be sliced from the middle, was waiting for the weekend to post it.

def func1(b):
    n1 = len(b)
    n2 = len(a)
    if n1<=n2:
        first_element = b[0]
        last_element = b[n1-1]
        first_element_index = a.index(b[0],0,n2)
        last_element_index = a.index(b[n1-1],0,n2)
        if last_element_index - first_element_index==n1-1:
            a[first_element_index+1:last_element_index+1] = [x**2 for x in b]
        
        def rec(first,last,start,end,n1,n2):
            while start<=n2 and end<=n2:
                if a.index(last,start,end)-a.index(first,start,end)==n1-1:
                    a[a.index(first)+1:a.index(last)+1] = [x**2 for x in b]
                else:
                    return rec(first,last,a.index(first)+1,a.index(last)+1,n1,n2)
            a[:]=[x**2 for x in b]
    else:
          a[:] = [x**2 for x in b]

a = [1,8,9,4,5,7,2,6]

func1(a[6:8])

print(a)
                
[1, 8, 9, 4, 5, 7, 2, 4, 36]


The code is longer than usual because I confirm subset of a ..it can be shortened if subset is guaranteed. Similarly, it can be lengthened and made more robust by adding more checks and validations.