What is the identity of "ndim, shape, size, .. etc" ndarray in numpy

numpy

implemented as a combination of code C

and code Python

. The source is viewable at github

and can be downloaded as a repository git

. But paving the way to the source C

takes some work. Many files are marked as .c.src

, which means they go through one or more levels of processing before being compiled.

And Python is written in combination with C and Python. So don't try to force things into C ++ terms.

It is probably best to use MATLAB expertise, with settings to allow Python. And it numpy

has a number of quirks outside of Python. It uses Python syntax, but since it has its own C code, it is not just a Python class.

I use it Ipython

as a normal work environment. With this I can use foo?

to see the documentation for foo

(same as Python help(foo)

and foo??

to see the code - if written in Python (like MATLAB / Octave type(foo)

))

Python objects have attributes and methods. Also properties

, which look like attributes but actually use get / set methods. You usually don't need to know the difference between attributes and properties.

 x.ndim   # as noted, has a get, but no set; see also np.ndim(x)
 x.shape   # has a get, but can also be set; see also np.shape(x)

      

        
        
        
      

    

x.<tab>

in Ipython shows me all the completion for a ndarray

. There are 4 * 18. Some of them are methods, some are attributes. x._<tab>

also shows the bundle that starts with __

. These are 'private' - not intended for public consumption, just semantics. You can look at them and use them as needed.

Off hand x.shape

is the only property ndarray

I have set and even with this I usually use reshape(...)

. Read their docs to see the difference. ndim

is the number of dimensions, and there is no point in changing it directly. It is len(x.shape)

; change the form to change ndim

. Likewise, x.size

it shouldn't be what you change directly.

Some of these properties are available through functions. np.shape(x) == x.shape

, similar to MATLAB size(x)

. (MATLAB has no attribute syntax .

).

x.__array_interface__

- a convenient property that gives a dictionary with a number of attributes

In [391]: x.__array_interface__
Out[391]: 
{'descr': [('', '<f8')],
 'version': 3,
 'shape': (50,),
 'typestr': '<f8',
 'strides': None,
 'data': (165646680, False)}

      

        
        
        
      

    

The docs for ndarray(shape, dtype=float, buffer=None, offset=0, strides=None, order=None)

, method __new__

lists these attributes:

`Attributes
----------
T : ndarray
    Transpose of the array.
data : buffer
    The array elements, in memory.
dtype : dtype object
    Describes the format of the elements in the array.
flags : dict
    Dictionary containing information related to memory use, e.g.,
    'C_CONTIGUOUS', 'OWNDATA', 'WRITEABLE', etc.
flat : numpy.flatiter object
    Flattened version of the array as an iterator.  The iterator
    allows assignments, e.g., ``x.flat = 3`` (See `ndarray.flat` for
    assignment examples; TODO).
imag : ndarray
    Imaginary part of the array.
real : ndarray
    Real part of the array.
size : int
    Number of elements in the array.
itemsize : int
    The memory use of each array element in bytes.
nbytes : int
    The total number of bytes required to store the array data,
    i.e., ``itemsize * size``.
ndim : int
    The array number of dimensions.
shape : tuple of ints
    Shape of the array.
strides : tuple of ints
    The step-size required to move from one element to the next in
    memory. For example, a contiguous ``(3, 4)`` array of type
    ``int16`` in C-order has strides ``(8, 2)``.  This implies that
    to move from element to element in memory requires jumps of 2 bytes.
    To move from row-to-row, one needs to jump 8 bytes at a time
    (``2 * 4``).
ctypes : ctypes object
    Class containing properties of the array needed for interaction
    with ctypes.
base : ndarray
    If the array is a view into another array, that array is its `base`
    (unless that array is also a view).  The `base` array is where the
    array data is actually stored.

      

        
        
        
      

    

They should all be considered properties, although I don't think they numpy

actually use the mechanism property

. In general, they should be considered read-only. Besides shape

, I only remember changing data

(pointer to data buffer) and strides

.