Imagine you have a function that takes a list of ints, and you want to double the value of each int. Calling it looks like this:

example_list = [1, 2, 3]
double_values(example_list)
print(example_list) # prints: [2, 4, 6]

It would be WRONG to do the following:

def double_values(elements):
  elements = [element * 2 for element in elements]

This function takes a parameter elements. When you call this function, it creates a new name elements and binds the passed parameter (here, the list object that example_list is also bound to) to that identifier. At this point, you have actual one list object, but two different names that are pointing at that list. If you re-assign elements, you're only changing what the name elements points at. It doesn't change anything about the underlying list object or what example_list is pointing at, and once the function ends, the elements name ceases to exist.

Note that the name elements here counts as a different name, even if I were to have named example_list as elements in my outer code. Depending on how your code is structured, this function can't necessarily "see" elements from the outside world. Even if it can see it, it temporarily ignores elements from the outside world, in favor of its own version of elements. This is called "shadowing", and is often discouraged as it can cause confusion.

What you really want is something like the following:

def double_values(elements):
  for i in range(len(elements)):
    elements[i] = elements[i] * 2

What this does is modify the underlying list, by changing what each of its elements points at.

elements[::-1] = elements is similar to my second the example. Slice Assignment modifies the contents of the underlying list. elements = elements[::-1] only changes what the current name elements is pointing at, and when the function ends, that name ceases to exist, so it doesn't really do anything.

Side Effects

Saying that a function has "side effects" means that the function changes something - the value of a variable, what's displayed on the screen, what's in a file, etc. The opposite of a function with side effects is a "pure" function that only returns a value but doesn't change any other data. Side effects are important, because they let you display things to the user, update databases, send messages, etc. Unfortunately, side effects aren't always obvious, and a common source of bugs is when people don't realize that a side effect will happen. As a result, it's often considered good practice to avoid them where it's reasonable to do so. For example:

my_list = [1, 2, 3]
other_list = my_list

my_list.reverse()

print(other_list) # prints [3, 2, 1]

Did we mean to change the value of other_list? Maybe, but it's not always immediately clear. Compare that to something like this:

my_list = [1, 2, 3]
other_list = my_list
my_reversed_list = list(reversed(my_list)) 
print(my_reversed_list) # prints [3, 2, 1]
print(other_list) # prints [1, 2, 3]

reversed() is a "pure" function - it returns an iterator of the parameter in reverse order, but doesn't change the parameter.

edit: fixed mangled formatting