numpy is implemented as a mix of C code and Python code. The source is available for browsing on github, and can be downloaded as a git repository. But digging your way into the C source takes some work. A lot of the files are marked as .c.src, which means they pass through one or more layers of perprocessing before compiling.

And Python is written in a mix of C and Python as well. So don't try to force things into C++ terms.

It's probably better to draw on your MATLAB experience, with adjustments to allow for Python. And numpy has a number of quirks that go beyond Python. It is using Python syntax, but because it has its own C code, it isn't simply a Python class.

I use Ipython as my usual working environment. With that I can use foo? to see the documentation for foo (same as the Python help(foo), and foo?? to see the code - if it is writen in Python (like the MATLAB/Octave type(foo))

Python objects have attributes, and methods. Also properties which look like attributes, but actually use methods to get/set. Usually you don't need to be aware of 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 completions for a ndarray. There are 4*18. Some are methods, some attributes. x._<tab> shows a bunch more that start with __. These are 'private' - not meant for public consumption, but that's just semantics. You can look at them and use them if needed.

Off hand x.shape is the only ndarray property that I set, and even with that I usually use reshape(...) instead. Read their docs to see the difference. ndim is the number of dimensions, and it doesn't make sense to change that directly. It is len(x.shape); change the shape to change ndim. Likewise x.size shouldn't be something you change directly.

Some of these properties are accessible via functions. np.shape(x) == x.shape, similar to MATLAB size(x). (MATLAB doesn't have . attribute syntax).

x.__array_interface__ is a handy property, that gives a dictionary with a number of the 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), the __new__ method lists these attributes:

`Attributes
----------
T : ndarray
    Transpose of the array.
data : buffer
    The array's 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's 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.

All of these should be treated as properties, though I don't think numpy actually uses the property mechanism. In general they should be considered to be 'read-only'. Besides shape, I only recall changing data (pointer to a data buffer), and strides.

The shape of an array is a tuple of its dimensions. An array with one dimension has a shape of (n,). A two dimension array has a shape of (n,m) (like your case 2 and 3) and a three dimension array has a shape of (n,m,k) and so on.

Therefore, whilst the shape of your second and third example are different, the no. dimensions is two in both cases:

>>> a= np.array([[1,2,3],[4,5,6]])
>>> a.shape
(2, 3)

>>> b=np.arange(15).reshape(3,5)
>>> b.shape
(3, 5)

If you wanted to add another dimension to your examples you would have to do something like this:

a= np.array([[[1,2,3]],[[4,5,6]]])

or

np.arange(15).reshape(3,5,1)

You can keep adding dimensions in this way:

One dimension:

>>> a = np.zeros((2))
array([ 0.,  0.])
>>> a.shape
(2,)
>>> a.ndim
1

Two dimensions:

>>> b = np.zeros((2,2))
array([[ 0.,  0.],
       [ 0.,  0.]])
>>> b.shape
(2,2)
>>> b.ndim
2

Three dimensions:

>>> c = np.zeros((2,2,2))
array([[[ 0.,  0.],
        [ 0.,  0.]],

       [[ 0.,  0.],
        [ 0.,  0.]]])
>>> c.shape
(2,2,2)
>>> c.ndim
3

Four dimensions:

>>> d = np.zeros((2,2,2,2))
array([[[[ 0.,  0.],
         [ 0.,  0.]],

        [[ 0.,  0.],
         [ 0.,  0.]]],


       [[[ 0.,  0.],
         [ 0.,  0.]],

        [[ 0.,  0.],
         [ 0.,  0.]]]])
>>> d.shape
(2,2,2,2)
>>> d.ndim
4

The tuple you give to zeros and other similar functions gives the 'shape' of the array (and is available for any array as a.shape). The number of dimensions is the number of entries in that shape.

If you were instead printing len(a.shape) and len(b.shape) you would expect the result you get. The ndim is always equal to this (because that's how it's defined).

The link you give shows the same behavior, except that the reshape method takes arbitary numbers of positional arguments rather than a tuple. But in the tutorial's example:

>>> a = arange(15).reshape(3, 5)
>>> a
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])
>>> a.shape
(3, 5)
>>> a.ndim
2

The number of arguments given to reshape, and the number of elements in the tuple given back by a.shape, is 2. If this was instead:

>>> a = np.arange(30).reshape(3, 5, 2)
>>> a.ndim
3

Then we see the same behavior: the ndim is the number of shape entries we gave to numpy.

Dimensionality of NumPy arrays must be understood in the data structures sense, not the mathematical sense, i.e. it's the number of scalar indices you need to obtain a scalar value.(*)

E.g., this is a 3-d array:

>>> X = np.arange(24).reshape(2, 3, 4)
>>> X
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]],

       [[12, 13, 14, 15],
        [16, 17, 18, 19],
        [20, 21, 22, 23]]])

Indexing once gives a 2-d array (matrix):

>>> X[0]
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

Indexing twice gives a 1-d array (vector), and indexing three times gives a scalar.

The rank of X is its number of dimensions:

>>> X.ndim
3
>>> np.rank(X)
3

Axis is roughly synonymous with dimension; it's used in broadcasting operations:

>>> X.sum(axis=0)
array([[12, 14, 16, 18],
       [20, 22, 24, 26],
       [28, 30, 32, 34]])
>>> X.sum(axis=1)
array([[12, 15, 18, 21],
       [48, 51, 54, 57]])
>>> X.sum(axis=2)
array([[ 6, 22, 38],
       [54, 70, 86]])

To be honest, I find this definition of "rank" confusing since it matches neither the name of the attribute ndim nor the linear algebra definition of rank.

Now regarding np.dot, what you have to understand is that there are three ways to represent a vector in NumPy: 1-d array, a column vector of shape (n, 1) or a row vector of shape (1, n). (Actually, there are more ways, e.g. as a (1, n, 1)-shaped array, but these are quite rare.) np.dot performs vector multiplication when both arguments are 1-d, matrix-vector multiplication when one argument is 1-d and the other is 2-d, and otherwise it performs a (generalized) matrix multiplication:

>>> A = np.random.randn(2, 3)
>>> v1d = np.random.randn(2)
>>> np.dot(v1d, A)
array([-0.29269547, -0.52215117,  0.478753  ])
>>> vrow = np.atleast_2d(v1d)
>>> np.dot(vrow, A)
array([[-0.29269547, -0.52215117,  0.478753  ]])
>>> vcol = vrow.T
>>> np.dot(vcol, A)
Traceback (most recent call last):
  File "<ipython-input-36-98949c6de990>", line 1, in <module>
    np.dot(vcol, A)
ValueError: matrices are not aligned

The rule "sum product over the last axis of a and the second-to-last of b" matches and generalizes the common definition of matrix multiplication.

(*) Arrays of dtype=object are a bit of an exception, since they treat any Python object as a scalar.

As the NumPy documentation says, numpy.ndim(a) returns:

The number of dimensions in a. Scalars are zero-dimensional

E.g.:

a = np.array(111)
b = np.array([1,2])
c = np.array([[1,2], [4,5]])
d = np.array([[1,2,3,], [4,5]])
print a.ndim, b.ndim, c.ndim, d.ndim
#outputs: 0 1 2 1

Note that the last array, d, is an array of object dtype, so its dimension is still 1.

What you want to use could be a.shape (or a.size for a one-dimensional array):

print a.size, b.size
print c.size # == 4, which is the total number of elements in the array
# Outputs:
1 2
4

Method .shape returns you a tuple, and you should get your dimension using [0]:

print a.shape, b.shape, b.shape[0]
() (2L,) 2