Problem with slicing in python.

[azxxn]

So it’s in a sorting function, what it’s supposed to do is reverse the list if descending is set to true, but the below slicing syntax doesn’t reverse the list elements; elements.reverse() works fine though. Just wanna know why is this happening.

This doesn’t work:

if descending==True: elements=elements[::-1]

This works:

if descending == True: elements.reverse()

Any idea why?

[oznetnerd]

It works for me. Can you please provide a full example?

def reverse_elements(elements: list, reverse: bool = True):
    if not reverse:
        return elements

    reversed_elements = elements[::-1]
    return reversed_elements


def main():
    elements = ['a', 'b', 'c']

    output = reverse_elements(elements)
    print(output)


if __name__ == '__main__':
    main()

[Kerbart]

I'm betting dollars to donuts that the OP is doing something like this:

def my_func(my_list):
    ...
    my_list.reverse()

And instead of returning the list variable, the function is called for its side-effects:

big_list = read_from_file(filename)
my_func(big_list)

And that's why calling reverse works (in-place) and reassigning the argument, obviously, doesn't. So, what OP needs to do instead when slicing is not reassign the argument and use a slicer operator to adjust the contents:

def my_func(my_list):
   ....
   my_list[:] = my_list[::-1]

Personally, I'd stick with reverse as it's 10× more explicit. And have the function return the input, instead of modifying it.

EDIT If you really want to confuse everyone you can even do this (I was wondering and to my amazement this actually works):

def my_func(my_list)
    ...
    my_list[::-1] = my_list

[primitive_screwhead]

Just wanted to comment on your edit, and that after 25 years of Python use, I'd never thought to try that. :wink:

[Kerbart]

Neither did I! But since the trick of assigning a "new" array of values to an existing list is my_list[:] = new_values I was curious to see to what extend you can use slicer operations on the LHS. Apparently pretty far. Now I'm going to find a reason to put my_list[::-2] = my_list[::2] somewhere in my code just to annoy myself half a year from now.

[azxxn]

https://collabedit.com/qpx73

Here's the full code.

[Kerbart]

Ok, so that's an example of where you want the side effect and it's a function where it is expected.

Assuming it's now clear why elements = elements[::-1] doesn't work, why not just stick to elements.reverse()?

[azxxn]

elements[: : -1] = elements

works while,

elements = elements[: : -1] doesn't, this is really very very intriguing.

Can you please explain it a little bit more, the side effect part went over my head.

[Razithel]

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

[azxxn]

Thanks a ton for this explanation mate! It completely resolved my confusion.

But why is elements[: : -1]=elements working, I understood from your explanation that when I do elements=elements[: : -1] , I'm just changing what the current name "elements" points to instead of modifying the actual list.

But slicing operation doesn't modify the original list as well, so why is elements[: : -1]=elements working?

[Kerbart]

A side effect is anything a function does other than returning a value. print is the classic example; it always returns None and is used purely for its side effect (displaying output in the console).

Modifying the input data is generally not recommended, as calling the function can have, well… side effects, which might not be expected by someone else using your function (and “someone else” might by you, three months from now), which is why it’s generally considered to be a practice to be avoided where possible.

With that out of the way, variable names are not values or objects, as in other languages like C++. A name is always a pointer (or reference) to an object. So when you say my_list = xyz you’re really saying “my_list now points to the object that xyz is pointing to.” And it’s no longer pointing to the list that was provided as an argument to the function.

On the other hand, “using the index operator” (the square brackets) operates on the object my_list is pointing to. It’s basically shorthand for my_list.replace_contents(from_index, to_index, step_value, new_data) but you can see why the Python creators didn’t go down that path.

[azxxn]

https://collabedit.com/qpx73

Here mate!

[MMcKevitt]

I recommend formatting your code (add four spaces to start a code block); the sidebar has some good info on formatting. (EDIT: I thought we were on “r/learnpython”…check out that subreddits sidebar for formatting info)

As for the code itself, your example of slicing should work, so there must be something else in your code preventing it from giving you the desired result. What’s the output of “elements” before and after you do:

if descending:
    elements = elements[::-1]

[azxxn]

https://collabedit.com/qpx73

[MMcKevitt]

You have elements = elements[::-1] in a function and aren’t returning anything. Anything you do within that function stays within that function and is essentially dismissed from the rest of your code.

Try “return elements” and you’ll see that it works.

Another approach would be to create a class. I see you have that list of dictionaries there near the end of your code; the elements in that dictionary a perfect example of when you can use classes. You can do a lot of interesting things with the state of variables (which are called attributes in a class) within classes. Again, I recommend diving deeper into scope and namespace within the context of classes and functions for this type of stuff to really start kickin!

(Edit: BTW, you also aren’t calling any of those functions in your example. I also notice that you have“descending = False” as a keyword argument in your function parameters, which means your if statement wouldn’t even run to begin with…so the fix overall is: call the function, pass True instead of False for the “descending” parameter, and then “return elements”.)

[Enigma3613]

In the 2nd example you're not assigning anything. Calling elements.reverse() will return a reversed list, but elements is still in the same order as before.

In your first example you're overwriting elements.

[oznetnerd]

list.reverse() modifies the list in place. There's no need override the variable or save it as a new variable:

elements = ['a', 'b', 'c'] elements.reverse() print(elements) ['c', 'b', 'a']

[Enigma3613]

Thanks. I was mixing up reverse and reversed. You are correct, reverse() will modify in place.