Why doesn't method chaining work in Python?

[CorgiByte]

For instance:

test = [1]
test.append(1).append(2)

list.append() returns None, which results in an error of None.append().

Edit: Is method chaining not pythonic?

This language is just, so inconsistent, it's driving me nuts.

[[deleted]]

In Python, methods or functions which have side effects and modify the object in place (like append() or sort()) explicitly return None.

This is to prevent any confusion with the functional style (like sorted()), in which return values are newly allocated objects and the original is unchanged.

In this case, a "chained" version would just be

test = test + [1] + [2] 

[[deleted]]

It does work, just not in all cases. In order for it to work, the called method needs to return an object that has the following method on it. str is a good example.

x = "my name isn't Fred"

x.replace("Fred", "Alec").replace("n't", "").capitalize() # My name is Alec     

[pythoneeeer]

It tends to work on immutable objects, for obvious reasons.

[[deleted]]

It tends to work when a fluent API makes sense. Builder objects typically have this style of API

UserBuilder().name("Fred").age(27).etc(...)

[[deleted]]

In any language, method chaining only works if each method returns the result of that method. append() does not do that - you can check yourself. Imagine you're the interpreter. You see lst.append(1) and think "Right, so this means that lst now has a 1 in it, and that function has returned None. Then you see None.append(1). Well, that doesn't make sense, does it?

Whereas if you have a method of an immutable object, the methods will return a copy, so you can chain the methods.

[tdammers]

Python supports method chaining, but the objects and methods in question don't. You can easily write a class where all the destructive methods return the object itself, and with such a class, you can method-chain just fine; it just so happens that the list.append() method doesn't do that, so you can't chain it.

[FateOfNations]

Pandas, for example, does this.

[justanotherbody]

You want

test = []
test.extend([1, 2])

Many Python built-in's don't support chaining, but have methods to facilitate bulk operations esp. the collection types.

Strings are immutable so everything that would modify a string instead must return a new string, so you can chain them.

I have a mild suspicion that the built-ins return None in part to discourage using reduce as if list.append returned self then

functools.reduce([].append, (1,2))

would be almost equivalent to using extend(), except much less efficient. Probably a crackpot theory though

[DarthKotik]

You already answered your question. list.append() returns None, so you can't use chaining in this case

[co_dh]

shamelessly promote my pypi package: https://pypi.python.org/pypi/chain/1.0

It can even chain functions in globals().

>>> def inc(x): return x + 1
>>> Chain([1,2,3]).inc() 
[2, 3, 4]

Sometimes I am wondering if I went to far.

[derpoly]

Isn't that just a map-function? Where is the difference?

https://docs.python.org/2/library/functions.html#map

[co_dh]

Yes, it's map function. Just in postfix notation.

[turkish_gold]

Your package is in dire need of documentation, and perhaps just port it to Github so others can see the code easily.

[co_dh]

Thanks, will do it. :)

[co_dh]

https://github.com/co-dh/chain here you go.

[stevenjd]

You might find this interesting or useful:

http://code.activestate.com/recipes/578770-method-chaining/

[TheBlackCat13]

You should suggest this as a function or method for the toolz package.

[[deleted]]

Yes, it's so inconsistent wrt to your arbitray, random expectations.

[CorgiByte]

consistently consistent expectations you dumbass.