[KanZen]
def __getitem__(self, *args):
print len(args)
For __getitem__() the arguments become a tuple. I can't seem to find this
in the language spec. Can anybody explain this to me?
Hello, KanZen.
When you write an argument list as `*args', you _always_ get a tuple
of all arguments. Normally, one writes:
def __getitem__(self, argument):
...
as `__getitem__' only accepts one argument besides `self'. Of course,
you may well write:
def __getitem__(self, *arguments):
...
but then, `arguments' will always be a 1-tuple in practice, and
`arguments[0]' will contain the actual argument.
This being said, consider the call `a[1, 2, 3]' (it does not look like a
call, but we both know that under the scene, this is calling `__getitem__').
We may be tempted to think that it works a bit the same as an explicit
function call would work, like if it was written `a(1, 2, 3)', and the
confusion might come from there. Indeed, in `a(1, 2, 3)', there are three
arguments. `a[1, 2, 3]' is not the same, it calls the `__getattr__' of `a'
with a _single_ argument `1, 2, 3'. That single argument is really a tuple
itself.
Many Python users like to write tuples as `(1, 2, 3)', using superfluous
parentheses for strange reasons.
They would likely write `a[(1, 2, 3)]'
as a way to over-stress that `a[]' accepts only one value within the
brackets. The writing `a[1, 2, 3]' is very legible because it is less
noisy, and you are right in preferring it. Yet you have to remember that
`1', `2' and `3' are not to become separate arguments for `__getitem__'.
The single argument will be what was within brackets, that is, a tuple.