I am trying to use
__getitem__(self, x, y):
on my Matrix class, but it seems to me it doesn't work (I still don't know very well to use python). I'm calling it like this:
print matrix[0,0]
Is it possible at all to use more than one argument? Thanks. Maybe I can use only one argument but pass it as a tuple?
__getitem__() is a magic method in Python, which when used in a class, allows its instances to use the [] (indexer) operators. Say x is an instance of this class, then x[i] is roughly equivalent to type(x). __getitem__(x, i) .
We pass arguments in a function, we can pass no arguments at all, single arguments or multiple arguments to a function and can call the function multiple times.
The varargs functionality allows you to pass any number of arguments to a method. The method must be set up with the type of data and a variable name to hold the elements. You can add more parameters to the method, but the varargs statement must be the last one.
__getitem__
only accepts one argument (other than self
), so you get passed a tuple.
You can do this:
class matrix: def __getitem__(self, pos): x,y = pos return "fetching %s, %s" % (x, y) m = matrix() print m[1,2]
outputs
fetching 1, 2
See the documentation for object.__getitem__
for more information.
Indeed, when you execute bla[x,y]
, you're calling type(bla).__getitem__(bla, (x, y))
-- Python automatically forms the tuple for you and passes it on to __getitem__
as the second argument (the first one being its self
). There's no good way[1] to express that __getitem__
wants more arguments, but also no need to.
[1] In Python 2.*
you can actually give __getitem__
an auto-unpacking signature which will raise ValueError
or TypeError
when you're indexing with too many or too few indices...:
>>> class X(object): ... def __getitem__(self, (x, y)): return x, y ... >>> x = X() >>> x[23, 45] (23, 45)
Whether that's "a good way" is moot... it's been deprecated in Python 3 so you can infer that Guido didn't consider it good upon long reflection;-). Doing your own unpacking (of a single argument in the signature) is no big deal and lets you provide clearer errors (and uniform ones, rather than ones of different types for the very similar error of indexing such an instance with 1 vs, say, 3 indices;-).
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With