[Python-ideas] Accepting keyword arguments for __getitem__

[Joseph Martinot-Lagarde]

Le 23/06/2014 14:06, Stefano Borini a écrit :
> Dear all,
>
> At work we use a notation like LDA[Z=5] to define a specific level of accuracy for our evaluation. This notation is used
> just for textual labels, but it would be nice if it actually worked at the scripting level, which led me to think to the following:
> at the moment, we have the following
>
>>>> class A:
> ...     def __getitem__(self, y):
> ...         print(y)
> ...
>>>> a=A()
>>>> a[2]
> 2
>>>> a[2,3]
> (2, 3)
>>>> a[1:3]
> slice(1, 3, None)
>>>> a[1:3, 4]
> (slice(1, 3, None), 4)
>>>>
>
> I would propose to add the possibility for a[Z=3], where y would then be a
> dictionary {"Z": 3}. In the case of a[1:3, 4, Z=3, R=5], the value of y would
> be a tuple containing (slice(1,3,None), 4, {"Z": 3}, {"R": 5}). This allows to
> preserve the ordering as specified (e.g. a[Z=3, R=4] vs a[R=4, Z=3]).
>
> Do you think it would be a good/useful idea? Was this already discussed or proposed in a PEP?
> Google did not help on this regard.
>
> Thank you,
>
> Stefano Borini
>
> _______________________________________________
> Python-ideas mailing list
> Python-ideas at python.org
> https://mail.python.org/mailman/listinfo/python-ideas
> Code of Conduct: http://python.org/psf/codeofconduct/
>
Actually I proposed a similar functionnality a few months ago: 
http://thread.gmane.org/gmane.comp.python.ideas/27584

The main point is not saving a few keystrokes but increase readability. 
It is indeed possible to use __call__ (that's what I'm doing in some 
cases), but then the indexing part is lost. Using a dictionnary is not 
clear either. Compare:

table[x=8, y=11]
table[{x: 8}, {y: 11}]

You could argue that keyword arguments are useless since you can always 
add a dictionary as last argument...

Before using python I was using Matlab. One very annoying thing in 
Matlab is that both indexing and function call use parenthesis. Code 
mixing both is really hard to understand. Coming to python was a relief 
on this aspect, where [] and () makes really clear whether the operation 
is a call or indexing.

Now that I know python better, it bothers me that indexing doesn't have 
the same semantics a a function call. To me their intentions are 
different but their use should be the same. I guess that the equivalence 
between a[1, 2] and a[(1, 2)] is for backward compatibility, but it 
shouldn't stop from adding keywords arguments.

Using a preprocessor seems fine when building a full application, but is 
really impracticable when crunching numbers from scripts or ipython. 
Also, using a preprocessor for something as simple as indexing seems 
really overkill.

Now, I don't understand why you need to know the ordering of keyword 
arguments, since they are clearly labeled ? I'd hate to have to manually 
parse (slice(1,3,None), 4, {"Z": 3}, {"R": 5}).

Joseph