[Numpy-discussion] Problem with concatenate and object arrays
Travis Oliphant
oliphant.travis at ieee.org
Thu Sep 7 01:54:41 CDT 2006
Charles R Harris wrote:
> On 9/6/06, *Charles R Harris* <charlesr.harris at gmail.com
> <mailto:charlesr.harris at gmail.com>> wrote:
>
>
>
> On 9/6/06, *Travis Oliphant* < oliphant.travis at ieee.org
> <mailto:oliphant.travis at ieee.org>> wrote:
>
> Charles R Harris wrote:
> >
> > Where is array at this point?
> Basically it supports the old Numeric behavior wherein object
> array's
> are treated as before *except* for when an error would have
> occurred
> previously when the "new behavior" kicks in. Anything that
> violates
> that is a bug needing to be fixed.
>
> This leaves the new object-array constructor used less
> often. It could
> be exported explicitly into an oarray constructor, but I'm not
> sure
> about the advantages of that approach. There are benefits to
> having
> object arrays constructed in the same way as other arrays. It
> turns out
> many people actually like that feature of Numeric, which is
> the reason I
> didn't go the route of numarray which pulled object arrays out.
>
> At this point, however, object arrays can even be part of
> records and so
> need to be an integral part of the data-type description.
> Pulling that
> out is not going to happen. A more intelligent object-array
> constructor, however, may be a useful tool.
>
>
> OK. I do have a couple of questions. Let me insert the docs for
> array and asarray :
>
> """array(object, dtype=None, copy=1,order=None, subok=0,ndmin=0)
>
> Return an array from object with the specified date-type.
>
> Inputs:
> object - an array, any object exposing the array interface, any
> object whose __array__ method returns an array, or any
> (nested) sequence.
> dtype - The desired data-type for the array. If not given,
> then
> the type will be determined as the minimum type
> required
> to hold the objects in the sequence. This
> argument can only
> be used to 'upcast' the array. For downcasting,
> use the
> .astype(t) method.
> copy - If true, then force a copy. Otherwise a copy will
> only occur
> if __array__ returns a copy, obj is a nested
> sequence, or
> a copy is needed to satisfy any of the other
> requirements
> order - Specify the order of the array. If order is 'C',
> then the
> array will be in C-contiguous order (last-index
> varies the
> fastest). If order is 'FORTRAN', then the
> returned array
> will be in Fortran-contiguous order (first-index
> varies the
> fastest). If order is None, then the returned
> array may
> be in either C-, or Fortran-contiguous order or even
> discontiguous.
> subok - If True, then sub-classes will be passed-through,
> otherwise
> the returned array will be forced to be a
> base-class array
> ndmin - Specifies the minimum number of dimensions that the
> resulting
> array should have. 1's will be pre-pended to the
> shape as
> needed to meet this requirement.
>
> """)
>
> asarray(a, dtype=None, order=None)
> Returns a as an array.
>
> Unlike array(), no copy is performed if a is already an array.
> Subclasses
> are converted to base class ndarray.
>
> 1) Is it true that array doesn't always return a copy except by
> default? asarray says it contrasts with array in this regard.
> Maybe copy=0 should be deprecated.
>
> 2) Is asarray is basically array with copy=0?
>
> 3) Is asanyarray basically array with copy=0 and subok=1?
>
> 4) Is there some sort of precedence table for conversions? To me
> it looks like the most deeply nested lists are converted to arrays
> first, numeric if they contain all numeric types, object
> otherwise. I assume the algorithm then ascends up through the
> hierarchy like traversing a binary tree in postorder?
>
> 5) All nesting must be to the same depth and the deepest nested
> items must have the same length.
>
> 6) How is the difference between lists and "lists" determined, i.e.,
>
> In [3]: array([list([1,2,3]),list([1,2])], dtype = object)
> Out[3]: array([[1, 2, 3], [1, 2]], dtype=object)
>
> In [8]: array([array([1,2,3]),array([1,2])], dtype = object)
> Out[8]: array([[1 2 3], [1 2]], dtype=object)
>
>
> In [9]: array([1,2,3],[1,2]], dtype = object)
> ------------------------------------------------------------
> File "<ipython console>", line 1
> array([1,2,3],[1,2]], dtype = object)
> ^
> SyntaxError: invalid syntax
>
> Is the difference that list(...) and array(...) are passed as
> functions (lazy evaluation), but a list is just a list?
>
> Sorry to be asking all these questions, but I would like to try
> making the documentation be a bit of a reference. I am sure I will
> have more questions ;)
>
> -Travis
>
>
> And, voila, ragged arrays:
>
> In [9]: a = array([array([1,2,3]),array([1,2])], dtype = object)
>
> In [10]: a*2
> Out[10]: array([[2 4 6], [2 4]], dtype=object)
>
> In [11]: a + a
> Out[11]: array([[2 4 6], [2 4]], dtype=object)
Now I remember that this was my original motivation for futzing with the
object-array constructor in the first place. So, now you get there only
after an attempt to make a "rectangular" array first.
-Travis
More information about the Numpy-discussion
mailing list