On Mon, Feb 25, 2013 at 8:50 AM, Skipper Seabold <jsseabold@gmail.com> wrote:
On Mon, Feb 25, 2013 at 10:43 AM, Till Stensitzki <mail.till@gmx.de> wrote:
>
> First, sorry that i didnt search for an old thread, but because i disagree with
> conclusion i would at least address my reason:
>
>> I don't like
>> np.abs(arr).max()
>> because I have to concentrate to much on the braces, especially if arr
>> is a calculation
>
> This exactly, adding an abs into an old expression is always a little annoyance
> due to the parenthesis. The argument that np.abs() also works is true for
> (almost?) every other method. The fact that so many methods already exists,
> especially for most of the commonly used functions (min, max, dot, mean, std,
> argmin, argmax, conj, T) makes me missing abs. Of course, if one would redesign
> the api, one would drop most methods (i am looking at you ptp and byteswap). But
> the objected is already cluttered and adding abs is imo logical application of
> "practicality beats purity".
>

I tend to agree here. The situation isn't all that dire for the number of methods in an array. No scrolling at reasonably small terminal sizes.

[~/]
[3]: x.
x.T             x.copy          x.getfield      x.put           x.std
x.all           x.ctypes        x.imag          x.ravel         x.strides
x.any           x.cumprod       x.item          x.real          x.sum
x.argmax        x.cumsum        x.itemset       x.repeat        x.swapaxes
x.argmin        x.data          x.itemsize      x.reshape       x.take
x.argsort       x.diagonal      x.max           x.resize        x.tofile
x.astype        x.dot           x.mean          x.round         x.tolist
x.base          x.dtype         x.min           x.searchsorted  x.tostring
x.byteswap      x.dump          x.nbytes        x.setfield      x.trace
x.choose        x.dumps         x.ndim          x.setflags      x.transpose
x.clip          x.fill          x.newbyteorder  x.shape         x.var
x.compress      x.flags         x.nonzero       x.size          x.view
x.conj          x.flat          x.prod          x.sort          
x.conjugate     x.flatten       x.ptp           x.squeeze      


I find myself typing things like 

arr.abs()

and

arr.unique()

quite often.


Somehow, this reminds me of I. N. Hersteins book, Topics in Algebra, where he did function composition left-to-right instead of right-to-left. From a practical reading and typing point of view, left-to-right makes sense, to add a new function you don't need to go way back to the beginning of a line and you don't need to read right-to-left to see what is going on. However, the line eventually gets too long, line breaks are inconvenient, and you eventually forget what was at the beginning. I think short left-to-right sequences are very nice. OTOH, one call/line is a bit like left-to-right, only up-to-down, and there is no right margin, but you do save the output generated on the previous line.

Herstein's attempt to revolutionise old algebraic habits never caught on. But it was a bold attempt ;)

Chuck