size comes from numpy (on which pandas is based).

It gives you the total number of elements in the array. However, you can also query the sizes of specific axes with np.size (see below).

In contrast, len gives the length of the first dimension.

For example, let's create an array with 36 elements shaped into three dimensions.

In [1]: import numpy as np                                                      

In [2]: a = np.arange(36).reshape(2, 3, -1)                                     

In [3]: a                                                                       
Out[3]: 
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],
        [24, 25, 26, 27, 28, 29],
        [30, 31, 32, 33, 34, 35]]])

In [4]: a.shape                                                                 
Out[4]: (2, 3, 6)

size

size will give you the total number of elements.

In [5]: a.size                                                        
Out[5]: 36

len

len will give you the number of 'elements' of the first dimension.

In [6]: len(a)                                                                  
Out[6]: 2

This is because, in this case, each 'element' stands for a 2-dimensional array.

In [14]: a[0]                                                                   
Out[14]: 
array([[ 0,  1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10, 11],
       [12, 13, 14, 15, 16, 17]])

In [15]: a[1]                                                                   
Out[15]: 
array([[18, 19, 20, 21, 22, 23],
       [24, 25, 26, 27, 28, 29],
       [30, 31, 32, 33, 34, 35]])

These arrays, in turn, have their own shape and size.

In [16]: a[0].shape                                                             
Out[16]: (3, 6)

In [17]: len(a[0])                                                              
Out[17]: 3

np.size

You can use size more specifically with np.size.

For example you can reproduce len by specifying the first ('0') dimension.

In [11]: np.size(a, 0)                                                          
Out[11]: 2

And you can also query the sizes of the other dimensions.

In [10]: np.size(a, 1)                                                          
Out[10]: 3

In [12]: np.size(a, 2)                                                          
Out[12]: 6

Basically, you reproduce the values of shape.

I wouldn't worry about performance here - any differences should only be very marginal.

I'd say the more pythonic alternative is probably the one which matches your needs more closely:

a.shape may contain more information than len(a) since it contains the size along all axes whereas len only returns the size along the first axis:

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

If you actually happen to work with one-dimensional arrays only, than I'd personally favour using len(a) in case you explicitly need the array's size.

    def time_compare(self):
        loops = 100000000
        start = time.time()
        for i in range(loops):
            self.value_map.shape[0]
            self.value_map[0].shape[0]
            self.value_map[0][0].shape[0]
            self.value_map[0][0][0].shape[0]
        end = time.time()
        timed = (end - start)
        print("shape={}".format(timed))

        start = time.time()
        for i in range(loops):
            len(self.value_map)
            len(self.value_map[0])
            len(self.value_map[0][0])
            len(self.value_map[0][0][0])
        end = time.time()
        timed = (end - start)
        print("len={}".format(timed))

shape=102.26551818847656
len=87.99720764160156

len is faster than shape