In [1]:

    

import numpy as np


    

In [2]:

    

np.array([6, 28, 496, 8128])


    

    
Out[2]:





array([   6,   28,  496, 8128])

In [3]:

    

np.arange(6)


    

    
Out[3]:





array([0, 1, 2, 3, 4, 5])

In [4]:

    

np.zeros(4)


    

    
Out[4]:





array([ 0.,  0.,  0.,  0.])

In [5]:

    

np.ones((2, 3))


    

    
Out[5]:





array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.]])

In [6]:

    

np.empty(4)


    

    
Out[6]:





array([ 0.,  0.,  0.,  0.])

In [7]:

    

np.linspace(1, 2, 5)


    

    
Out[7]:





array([ 1.  ,  1.25,  1.5 ,  1.75,  2.  ])

In [8]:

    

np.logspace(1, -1, 3)


    

    
Out[8]:





array([ 10. ,   1. ,   0.1])

In [9]:

    

a = np.arange(4)
a


    

    
Out[9]:





array([0, 1, 2, 3])

In [10]:

    

a.shape = (2, 2)
a


    

    
Out[10]:





array([[0, 1],
       [2, 3]])

In [11]:

    

a = np.array([6, 28, 496, 8128])
a.dtype


    

    
Out[11]:





dtype('int64')

In [12]:

    

b = np.array([6, 28.0, 496, 8128])
b.dtype


    

    
Out[12]:





dtype('float64')

In [13]:

    

a = np.array([6, 28.0, 496, 8128],
             dtype=np.int8)
a


    

    
Out[13]:





array([  6,  28, -16, -64], dtype=int8)

In [14]:

    

b = np.array([6, 28.0, 496, 8128],
             dtype='f')
b


    

    
Out[14]:





array([  6.00000000e+00,   2.80000000e+01,   4.96000000e+02,
         8.12800000e+03], dtype=float32)

In [15]:

    

np.array(['I will have length six', 'and so will I!'], dtype='S6')


    

    
Out[15]:





array([b'I will', b'and so'], 
      dtype='|S6')

In [16]:

    

a = np.arange(8)


    

In [17]:

    

a[::-1]


    

    
Out[17]:





array([7, 6, 5, 4, 3, 2, 1, 0])

In [18]:

    

a[2:6]


    

    
Out[18]:





array([2, 3, 4, 5])

In [19]:

    

a[1::3]


    

    
Out[19]:





array([1, 4, 7])

In [20]:

    

a = np.arange(16)
a.shape = (4, 4)
a


    

    
Out[20]:





array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])

In [21]:

    

a[::2, 1::2]


    

    
Out[21]:





array([[ 1,  3],
       [ 9, 11]])

In [22]:

    

a[1:3, 1:3]


    

    
Out[22]:





array([[ 5,  6],
       [ 9, 10]])

In [23]:

    

a[2::-1, :3]


    

    
Out[23]:





array([[ 8,  9, 10],
       [ 4,  5,  6],
       [ 0,  1,  2]])

In [24]:

    

a = np.arange(6)
b = a[1::2]
b[1] = 42
a


    

    
Out[24]:





array([ 0,  1,  2, 42,  4,  5])

In [25]:

    

b.base is a


    

    
Out[25]:





True

In [26]:

    

a = np.arange(16)
b = np.array(a[1::11])


    

In [27]:

    

a = np.arange(6, dtype=np.int64)
a


    

    
Out[27]:





array([0, 1, 2, 3, 4, 5])

In [28]:

    

a.view('i4')


    

    
Out[28]:





array([0, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0], dtype=int32)

In [29]:

    

a = np.arange(6)
a


    

    
Out[29]:





array([0, 1, 2, 3, 4, 5])

In [30]:

    

a - 1


    

    
Out[30]:





array([-1,  0,  1,  2,  3,  4])

In [31]:

    

a + a


    

    
Out[31]:





array([ 0,  2,  4,  6,  8, 10])

In [32]:

    

2*a**2 + 3*a + 1


    

    
Out[32]:





array([ 1,  6, 15, 28, 45, 66])

In [33]:

    

a = np.arange(4)
a.shape = (2, 2)
a


    

    
Out[33]:





array([[0, 1],
       [2, 3]])

In [34]:

    

b = np.array([[42], [43]])
b


    

    
Out[34]:





array([[42],
       [43]])

In [35]:

    

a * b


    

    
Out[35]:





array([[  0,  42],
       [ 86, 129]])

In [36]:

    

np.dot(a, b)


    

    
Out[36]:





array([[ 43],
       [213]])

In [37]:

    

np.array([[ 43],
      [213]])


    

    
Out[37]:





array([[ 43],
       [213]])

In [38]:

    

a = np.arange(12)
a.shape = (4, 3)
a


    

    
Out[38]:





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

In [39]:

    

b = np.array([16, 17, 18])
b


    

    
Out[39]:





array([16, 17, 18])

In [40]:

    

a + b


    

    
Out[40]:





array([[16, 18, 20],
       [19, 21, 23],
       [22, 24, 26],
       [25, 27, 29]])

In [41]:

    

a.shape = (3, 4)
a


    

    
Out[41]:





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

In [42]:

    

a + b


    

    




---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-42-f96fb8f649b6> in <module>()
----> 1 a + b

ValueError: operands could not be broadcast together with shapes (3,4) (3,) 

In [43]:

    

b.shape = (3, 1)
b


    

    
Out[43]:





array([[16],
       [17],
       [18]])

In [44]:

    

a + b


    

    
Out[44]:





array([[16, 17, 18, 19],
       [21, 22, 23, 24],
       [26, 27, 28, 29]])

In [45]:

    

a = np.arange(6)
a.shape = (2, 3)
a


    

    
Out[45]:





array([[0, 1, 2],
       [3, 4, 5]])

In [46]:

    

b = np.array([2, 3])
b


    

    
Out[46]:





array([2, 3])

In [47]:

    

a - b


    

    




---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-47-a5f966a4b1f4> in <module>()
----> 1 a - b

ValueError: operands could not be broadcast together with shapes (2,3) (2,) 

In [48]:

    

b[:, np.newaxis] - a


    

    
Out[48]:





array([[ 2,  1,  0],
       [ 0, -1, -2]])

In [49]:

    

b[(slice(None),) + 31* (np.newaxis,)] - a


    

    
Out[49]:





array([[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[ 2,  1,  0],
                                     [-1, -2, -3]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]],






























       [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[ 3,  2,  1],
                                     [ 0, -1, -2]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]])

In [50]:

    

b[(slice(None),) + 30 * (np.newaxis,)] - a


    

    
Out[50]:





array([[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[ 2,  1,  0],
                                    [-1, -2, -3]]]]]]]]]]]]]]]]]]]]]]]]]]]]]],





























       [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[ 3,  2,  1],
                                    [ 0, -1, -2]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]])

In [51]:

    

a = 2*np.arange(8)**2 + 1
a


    

    
Out[51]:





array([ 1,  3,  9, 19, 33, 51, 73, 99])

In [52]:

    

# pull out the fourth, last, and
# second indices
a[[3, -1, 1]]


    

    
Out[52]:





array([19, 99,  3])

In [53]:

    

# pull out the Fibonacci sequence
fib = np.array([0, 1, 1, 2, 3, 5])
a[fib]


    

    
Out[53]:





array([ 1,  3,  3,  9, 19, 51])

In [54]:

    

# pull out a 2x2 array
a[[[[2, 7], [4, 2]]]]


    

    
Out[54]:





array([[ 9, 99],
       [33,  9]])

In [55]:

    

a = np.arange(16) - 8
a.shape = (4, 4)
a


    

    
Out[55]:





array([[-8, -7, -6, -5],
       [-4, -3, -2, -1],
       [ 0,  1,  2,  3],
       [ 4,  5,  6,  7]])

In [56]:

    

# pull out the third, last, and
# first columns
a[:, [2, -1, 0]]


    

    
Out[56]:





array([[-6, -5, -8],
       [-2, -1, -4],
       [ 2,  3,  0],
       [ 6,  7,  4]])

In [57]:

    

# pull out a Fibonacci sequence of
# rows for every other column, starting
# from the back
fib = np.array([0, 1, 1, 2, 3])
a[fib, ::-2]


    

    
Out[57]:





array([[-5, -7],
       [-1, -3],
       [-1, -3],
       [ 3,  1],
       [ 7,  5]])

In [58]:

    

# get the diagonal with a range
i = np.arange(4)
a[i, i]


    

    
Out[58]:





array([-8, -3,  2,  7])

In [59]:

    

# lower diagonal by subtracting one to 
# part of the range
a[i[1:], i[1:] - 1]


    

    
Out[59]:





array([-4,  1,  6])

In [60]:

    

# upper diagonal by adding one to part 
# of the range
a[i[:3], i[:3] + 1]


    

    
Out[60]:





array([-7, -2,  3])

In [61]:

    

# anti-diagonal by reversal
a[i, i[::-1]]


    

    
Out[61]:





array([-5, -2,  1,  4])

In [62]:

    

# create an array
a = np.arange(9)
a.shape = (3,3)
a


    

    
Out[62]:





array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])

In [63]:

    

# create an all True mask
m = np.ones(3, dtype=bool)
m


    

    
Out[63]:





array([ True,  True,  True], dtype=bool)

In [64]:

    

# take the diagonal
a[m, m]


    

    
Out[64]:





array([0, 4, 8])

In [65]:

    

# create a mask
m = np.array([[1, 0, 1], 
              [False, True, False], 
              [0, 0, 1]], dtype=bool)

a[m]


    

    
Out[65]:





array([0, 2, 4, 8])

In [66]:

    

a < 5


    

    
Out[66]:





array([[ True,  True,  True],
       [ True,  True, False],
       [False, False, False]], dtype=bool)

In [67]:

    

m = (a >= 7)


    

In [68]:

    

a[m]


    

    
Out[68]:





array([7, 8])

In [69]:

    

a[a < 5]


    

    
Out[69]:





array([0, 1, 2, 3, 4])

In [70]:

    

np.array([0, 1, 2, 3, 4])


    

    
Out[70]:





array([0, 1, 2, 3, 4])

In [71]:

    

a[(a < 5) | (a >= 7)]


    

    
Out[71]:





array([0, 1, 2, 3, 4, 7, 8])

In [72]:

    

np.array([0, 1, 2, 3, 4, 7, 8])


    

    
Out[72]:





array([0, 1, 2, 3, 4, 7, 8])

In [73]:

    

np.where(a < 5)


    

    
Out[73]:





(array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1]))

In [74]:

    

a[np.where(a >= 7)]


    

    
Out[74]:





array([7, 8])

In [75]:

    

a[:, np.where(a < 2)[1]]


    

    
Out[75]:





array([[0, 1],
       [3, 4],
       [6, 7]])

In [76]:

    

# a simple flat dtype
fluid = np.dtype([
    ('x', int),
    ('y', np.int64),
    ('rho', 'f8'),
    ('vel', 'f8'),
    ])

# a dtype with a nested dtype
# and a subarray
particles = np.dtype([
    ('pos', [('x', int), 
             ('y', int), 
             ('z', int)]),
    ('mass', float), 
    ('vel', 'f4', 3)
    ])


    

In [77]:

    

particles.names


    

    
Out[77]:





('pos', 'mass', 'vel')

In [78]:

    

fluid.fields


    

    
Out[78]:





mappingproxy({'rho': (dtype('float64'), 16), 'y': (dtype('int64'), 8), 'x': (dtype('int64'), 0), 'vel': (dtype('float64'), 24)})

In [79]:

    

np.zeros(4, dtype=particles)


    

    
Out[79]:





array([((0, 0, 0), 0.0, [0.0, 0.0, 0.0]),
       ((0, 0, 0), 0.0, [0.0, 0.0, 0.0]),
       ((0, 0, 0), 0.0, [0.0, 0.0, 0.0]), ((0, 0, 0), 0.0, [0.0, 0.0, 0.0])], 
      dtype=[('pos', [('x', '<i8'), ('y', '<i8'), ('z', '<i8')]), ('mass', '<f8'), ('vel', '<f4', (3,))])

In [80]:

    

# note that the rows are tuples
f = np.array([(42, 43, 6.0, 2.1), 
              (65, 66, 128.0, 3.7), 
              (127, 128, 3.0, 1.5)],
             dtype=fluid)
f


    

    
Out[80]:





array([(42, 43, 6.0, 2.1), (65, 66, 128.0, 3.7), (127, 128, 3.0, 1.5)], 
      dtype=[('x', '<i8'), ('y', '<i8'), ('rho', '<f8'), ('vel', '<f8')])

In [81]:

    

f[1]


    

    
Out[81]:





(65, 66, 128.0, 3.7)

In [82]:

    

f[::2]


    

    
Out[82]:





array([(42, 43, 6.0, 2.1), (127, 128, 3.0, 1.5)], 
      dtype=[('x', '<i8'), ('y', '<i8'), ('rho', '<f8'), ('vel', '<f8')])

In [83]:

    

f['rho']


    

    
Out[83]:





array([   6.,  128.,    3.])

In [84]:

    

f[['vel', 'x', 'rho']]


    

    
Out[84]:





array([(2.1, 42, 6.0), (3.7, 65, 128.0), (1.5, 127, 3.0)], 
      dtype=[('vel', '<f8'), ('x', '<i8'), ('rho', '<f8')])

In [85]:

    

x = np.linspace(0.0, np.pi, 5)


    

In [86]:

    

np.sin(x)


    

    
Out[86]:





array([  0.00000000e+00,   7.07106781e-01,   1.00000000e+00,
         7.07106781e-01,   1.22464680e-16])

In [87]:

    

a = np.arange(9)
a.shape = (3, 3)
a


    

    
Out[87]:





array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])

In [88]:

    

np.sum(a)


    

    
Out[88]:





36

In [89]:

    

np.sum(a, axis=0)


    

    
Out[89]:





array([ 9, 12, 15])

In [90]:

    

np.sum(a, axis=1)


    

    
Out[90]:





array([ 3, 12, 21])