up vote 1 down vote favorite

I've recently run into issues when creating Numpy object arrays using e.g.

a = np.array([c], dtype=np.object)

where c is an instance of some complicated class, and in some cases Numpy tries to access some methods of that class. However, doing:

a = np.empty((1,), dtype=np.object)
a[0] = c

solves the issue. I'm curious as to what the difference is between these two internally. Why in the first case might Numpy try and access some attributes or methods of c?

EDIT: For the record, here is example code that demonstrates the issue:

import numpy as np

class Thing(object):

    def __getitem__(self, item):
        print "in getitem"

    def __len__(self):
        return 1

a = np.array([Thing()], dtype='object')

This prints out getitem twice. Basically if __len__ is present in the class, then this is when one can run into unexpected behavior.

share|improve this question
Not related, but why np.object and not just object? – JBernardo Oct 5 '11 at 21:17
The two are equivalent (object == np.object returns True) so this is not related to the issues I'm seeing. – astrofrog Oct 5 '11 at 21:21
@astrofog That's why I asked and said it wasn't related. – JBernardo Oct 5 '11 at 21:22
BTW, I don't think one can solve your problem without seeing the class and some error messages. – JBernardo Oct 5 '11 at 21:24
Possible duplicate – John Y Oct 5 '11 at 21:33

1 Answer

up vote 1 down vote accepted

In the first case a = np.array([c], dtype=np.object), numpy knows nothing about the shape of the intended array.

For example, when you define

d = range(10)
a = np.array([d])

Then you expect numpy to determine the shape based on the length of d.

So similarly in your case, numpy will attempt to see if len(c) is defined, and if it is, to access the elements of c via c[i].

You can see the effect by defining a class such as

class X(object):
    def __len__(self): return 10
    def __getitem__(self, i): return "x" * i

Then

print numpy.array([X()], dtype=object)

produces

[[ x xx xxx xxxx xxxxx xxxxxx xxxxxxx xxxxxxxx xxxxxxxxx]]

In contrast, in your second case

a = np.empty((1,), dtype=np.object)
a[0] = c

Then the shape of a has already been determined. Thus numpy can just directly assign the object.

However to an extent this is true only since a is a vector. If it had been defined with a different shape then method accesses will still occur. The following for example will still call ___getitem__ on a class

a = numpy.empty((1, 10), dtype=object)
a[0] = X()
print a

returns

[[ x xx xxx xxxx xxxxx xxxxxx xxxxxxx xxxxxxxx xxxxxxxxx]]
share|improve this answer
This is exactly what I needed - basically if __len__ is defined then that is when I run into issues! – astrofrog Oct 5 '11 at 21:44

Your Answer

 
or
required, but never shown
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.