List comprehension and copies of types

Question

I am often tempted not to create a new list when using list comprehensions, because if the list is huge, it would mean more space needed to compute (the way I understand it the list is not bieng aliased int his case, a new memory space is created for the new list)

As an illustrative example (this could be done in one line):

def average_list(lst):
    lst = [x for x in lst if x > 0]
    return np.average(lst)

Is it dangerous to use lst in this way, both in right and left part of the assignment? If so, what situations would cause a problem by reusing lst?

If so why is this "safer"?

def average_list(lst):
    clean_lst = [x for x in lst if x > 0]
    return np.average(clean_lst )

Answer 1

def average_list(lst):
    lst = [x for x in lst if x > 0]
    return np.average(lst)

caller_list = [1,4,-5]
average_list(caller_list)
# caller_list is unchanged

here you're reusing the lst name only in the function, but you're not changing lst in the caller context (and garbage collection doesn't work since the caller still holds a reference on the data)

So reassigning a variable name is perfectly safe but sometimes considered as bad practice because one should not change the values or references of passed arguments.

Note: in the case of list a way to change the data itself (which would surprise your function users so don't do it) would be (only applies to lists & more generally mutable objects)

    lst[:] = [x for x in lst if x > 0]

With this slice assignment, the name isn't reused, the object itself is reused & modified. The original contents of the list is replaced by the new contents, here shrunk as there is less data in the new, filtered version. It's cool on local & global variables, but should be avoided in lists passed as parameters (like append, pop should be avoided too in the general case, always to follow the principle of least astonishment)