numpy.vectorize takes a function f:a->b and turns it into g:a[]->b[].

This works fine when a and b are scalars, but I can't think of a reason why it wouldn't work with b as an ndarray or list.

For example:

```
import numpy as np
def f(x): return np.array([1,1,1,1,1], dtype=np.float32) * x
g = np.vectorize(f, otypes=[np.ndarray])
a = np.arange(4)
print(a)
array([[ 0. 0. 0. 0. 0.], [ 1. 1. 1. 1. 1.], [ 2. 2. 2. 2. 2.],
[ 3. 3. 3. 3. 3.]], dtype=object)
```

gives the right answer values, but the wrong dtype. And even worse:

```
x.shape
(4,)
```

So this array is pretty much useless. I know I can convert it like this:

`np.array(map(list, a), dtype=np.float32)`

to give me what I want,

```
array([[ 0., 0., 0., 0., 0.],
[ 1., 1., 1., 1., 1.],
[ 2., 2., 2., 2., 2.],
[ 3., 3., 3., 3., 3.]], dtype=float32)
```

but that is neither efficient nor pythonic. Can any of you guys find a cleaner way to do this?

Thanks in advance!