def ravel(a, order='<STR_LIT:C>'):
return asarray(a).ravel(order)<EOL>
Return a flattened array.

A 1-D array, containing the elements of the input, is returned.  A copy is
made only if needed.

Parameters
----------
a : array_like
    Input array.  The elements in `a` are read in the order specified by
    `order`, and packed as a 1-D array.
order : {'C','F', 'A', 'K'}, optional
    The elements of `a` are read using this index order. 'C' means to
    index the elements in C-like order, with the last axis index changing
    fastest, back to the first axis index changing slowest.   'F' means to
    index the elements in Fortran-like index order, with the first index
    changing fastest, and the last index changing slowest. Note that the 'C'
    and 'F' options take no account of the memory layout of the underlying
    array, and only refer to the order of axis indexing.  'A' means to read
    the elements in Fortran-like index order if `a` is Fortran *contiguous*
    in memory, C-like order otherwise.  'K' means to read the elements in
    the order they occur in memory, except for reversing the data when
    strides are negative.  By default, 'C' index order is used.

Returns
-------
1d_array : ndarray
    Output of the same dtype as `a`, and of shape ``(a.size,)``.

See Also
--------
ndarray.flat : 1-D iterator over an array.
ndarray.flatten : 1-D array copy of the elements of an array
                  in row-major order.

Notes
-----
In C-like (row-major) order, in two dimensions, the row index varies the
slowest, and the column index the quickest.  This can be generalized to
multiple dimensions, where row-major order implies that the index along the
first axis varies slowest, and the index along the last quickest.  The
opposite holds for Fortran-like, or column-major, index ordering.

Examples
--------
It is equivalent to ``reshape(-1, order=order)``.

>>> x = np.array([[1, 2, 3], [4, 5, 6]])
>>> print np.ravel(x)
[1 2 3 4 5 6]

>>> print x.reshape(-1)
[1 2 3 4 5 6]

>>> print np.ravel(x, order='F')
[1 4 2 5 3 6]

When ``order`` is 'A', it will preserve the array's 'C' or 'F' ordering:

>>> print np.ravel(x.T)
[1 4 2 5 3 6]
>>> print np.ravel(x.T, order='A')
[1 2 3 4 5 6]

When ``order`` is 'K', it will preserve orderings that are neither 'C'
nor 'F', but won't reverse axes:

>>> a = np.arange(3)[::-1]; a
array([2, 1, 0])
>>> a.ravel(order='C')
array([2, 1, 0])
>>> a.ravel(order='K')
array([2, 1, 0])

>>> a = np.arange(12).reshape(2,3,2).swapaxes(1,2); a
array([[[ 0,  2,  4],
        [ 1,  3,  5]],
       [[ 6,  8, 10],
        [ 7,  9, 11]]])
>>> a.ravel(order='C')
array([ 0,  2,  4,  1,  3,  5,  6,  8, 10,  7,  9, 11])
>>> a.ravel(order='K')
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])