Python List Functions Not Returning New Lists

I'm having an issue considering the built-in Python List-methods. As I learned Python, I always thought Python mutators, as any value class mutators should do, returned the new var

Solution 1:

Rather than both mutating and returning objects, the Python library chooses to have just one way of using the result of a mutator. From import this:

There should be one-- and preferably only one --obvious way to do it.

Having said that, the more usual Python style for what you want to do is using list comprehensions or generator expressions:

[xforxinrange(5)ifx!=2andx!=3]

You can also chain these together:

>>>[x for x in (x for x inrange(5) if x != 2) if x != 3]
[0, 1, 4]

The above generator expression has the added advantage that it runs in O(n) time because Python only iterates over the range() once. For large generator expressions, and even for infinite generator expressions, this is advantageous.

Solution 2:

In Python, essentially all methods that mutate the object return None.

That's so you don't accidentally think you've got a new object as a result.

You mention

I think even PHP allows these types of subsequent mutations with Strings.

While I don't remember about PHP, with string manipulations, you can chain method calls, because strings are immutable, so all string methods return a new string, since they don't (can't) change the one you call them on.

>>> "a{0}b".format(3).center(5).capitalize().join('ABC').swapcase()
'a A3B b A3B c'

Solution 3:

Many methods of list and other mutable types intentionally return None so that there is no question in your mind as to whether you are creating a new object or mutating an existing object. The only thing that could be happening is mutation since, if a new object were created, it would have to be returned by the method, and it is not returned.

As you may have noticed, the methods of str that edit the string do return the new string, because strings are immutable and a new string is always returned.

There is of course nothing at all keeping you from writing a list subclass that has the desired behavior on .append()et al, although this seems like rather a heavy hammer to swing merely to allow you to chain method calls. Also, most Python programmers won't expect that behavior, making your code less clear.

Solution 4:

Neither Python or php have built-in "mutators". You can simply write multiple lines, like

a = list(range(5))
a.remove(2)
a.remove(3)

If you want to generate a new list, copy the old one beforehand:

a = list(range(5))
b = a[:]
b.remove(2)

Note that in most cases, a singular call to remove indicates you should have used a set in the first place.

Solution 5:

To remove multiple mutations on lists as you want to do on your example, you can do :

a = range(5)
a = [i for j, i in enumerate(a) if j not in [2, 3]]

a will be [0, 1, 4]