In [234]:

    

import numpy as np


    

In [235]:

    

### Creating ndarrays


    

In [236]:

    

data = {i : np.random.randn() for i in range(6)}


    

In [237]:

    

data


    

    
Out[237]:





{0: -0.08730089878649104,
 1: -0.24144139630183212,
 2: 1.0494958953335303,
 3: -0.9562884089145647,
 4: -0.49534433469939876,
 5: 0.4534923168092112}

In [238]:

    

data2 = [[1,2,3,4],[1,4,9,16]]


    

In [239]:

    

arr2 = np.array(data2)


    

In [240]:

    

arr2


    

    
Out[240]:





array([[ 1,  2,  3,  4],
       [ 1,  4,  9, 16]])

In [241]:

    

print(arr2)


    

    




[[ 1  2  3  4]
 [ 1  4  9 16]]

In [242]:

    

arr2.ndim


    

    
Out[242]:





2

In [243]:

    

arr2.shape


    

    
Out[243]:





(2, 4)

In [244]:

    

arr2.dtype


    

    
Out[244]:





dtype('int32')

In [245]:

    

a = np.zeros(10)


    

In [246]:

    

a


    

    
Out[246]:





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

In [247]:

    

b = np.ones(10)


    

In [248]:

    

b


    

    
Out[248]:





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

In [249]:

    

a1 = np.zeros((3, 6))


    

In [250]:

    

a1


    

    
Out[250]:





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

In [251]:

    

c = np.empty((2, 3, 2))


    

In [252]:

    

c


    

    
Out[252]:





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

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

In [253]:

    

c.dtype


    

    
Out[253]:





dtype('float64')

In [254]:

    

d = np.arange(15)


    

In [255]:

    

d


    

    
Out[255]:





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

In [256]:

    

e = np.ones_like(c)


    

In [257]:

    

e


    

    
Out[257]:





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

       [[ 1.,  1.],
        [ 1.,  1.],
        [ 1.,  1.]]])

In [258]:

    

f = np.eye(10)


    

In [259]:

    

f


    

    
Out[259]:





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

In [260]:

    

### Data Types for ndarrays


    

In [261]:

    

array1 = np.array([1, 2, 3, 4], dtype = np.float64)


    

In [262]:

    

array2 = np.array([1, 2, 3, 4], dtype = np.int32)


    

In [263]:

    

array1.dtype


    

    
Out[263]:





dtype('float64')

In [264]:

    

array2.dtype


    

    
Out[264]:





dtype('int32')

In [265]:

    

arr_string = np.array(['1.32','6.87','5.0'], dtype = np.string_)


    

In [266]:

    

arr_float = arr_string.astype(np.float64)


    

In [267]:

    

arr_float


    

    
Out[267]:





array([ 1.32,  6.87,  5.  ])

In [268]:

    

### Operations between Arrays and Scalars


    

In [269]:

    

arr = np.array([[1., 2. ,3.], [4., 5., 6.]], dtype=float)


    

In [270]:

    

arr


    

    
Out[270]:





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

In [271]:

    

arr*arr


    

    
Out[271]:





array([[  1.,   4.,   9.],
       [ 16.,  25.,  36.]])

In [272]:

    

arr-arr


    

    
Out[272]:





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

In [273]:

    

1/arr


    

    
Out[273]:





array([[ 1.        ,  0.5       ,  0.33333333],
       [ 0.25      ,  0.2       ,  0.16666667]])

In [274]:

    

arr**0.5


    

    
Out[274]:





array([[ 1.        ,  1.41421356,  1.73205081],
       [ 2.        ,  2.23606798,  2.44948974]])

In [275]:

    

### Basic Indexing and Slicing


    

In [276]:

    

arr = np.arange(15)


    

In [277]:

    

arr[3:8]


    

    
Out[277]:





array([3, 4, 5, 6, 7])

In [278]:

    

'''
An important first distinction from lists is that array slices are views on the original array. This means that
the data is not copied, and any modifications to the view will be reflected in the source array
'''


    

    
Out[278]:





'\nAn important first distinction from lists is that array slices are views on the original array. This means that\nthe data is not copied, and any modifications to the view will be reflected in the source array\n'

In [279]:

    

slice = arr[3:8]


    

In [280]:

    

slice[2] = 112


    

In [281]:

    

arr


    

    
Out[281]:





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

In [282]:

    

slice[3:6] = 12


    

In [283]:

    

arr


    

    
Out[283]:





array([  0,   1,   2,   3,   4, 112,  12,  12,   8,   9,  10,  11,  12,
        13,  14])

In [284]:

    

### If you want a copy of a slice of an ndarray instead of a view, you will need to explicitly copy the array


    

In [285]:

    

array = np.arange(15)


    

In [286]:

    

slice = array[3:8].copy()


    

In [287]:

    

slice[:] = 12


    

In [288]:

    

slice


    

    
Out[288]:





array([12, 12, 12, 12, 12])

In [289]:

    

array


    

    
Out[289]:





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

In [290]:

    

### higher dimensional arrays


    

In [291]:

    

arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])


    

In [292]:

    

arr2d[2][1]


    

    
Out[292]:





8

In [293]:

    

arr2d[2,1]


    

    
Out[293]:





8

In [294]:

    

arr2d[1, :2]


    

    
Out[294]:





array([4, 5])

In [295]:

    

arr2d[1, :2].shape


    

    
Out[295]:





(2,)

In [296]:

    

arr2d[1:2, :2]


    

    
Out[296]:





array([[4, 5]])

In [297]:

    

arr2d[1:2, :2].shape


    

    
Out[297]:





(1, 2)

In [298]:

    

arr3d = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])


    

In [299]:

    

arr3d[0]


    

    
Out[299]:





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

In [300]:

    

arr3d[0,1]


    

    
Out[300]:





array([4, 5, 6])

In [301]:

    

arr3d[0,1,0]


    

    
Out[301]:





4

In [302]:

    

old_values = arr3d[0].copy()


    

In [303]:

    

old_values


    

    
Out[303]:





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

In [304]:

    

arr3d[0] = 42


    

In [305]:

    

arr3d


    

    
Out[305]:





array([[[42, 42, 42],
        [42, 42, 42]],

       [[ 7,  8,  9],
        [10, 11, 12]]])

In [306]:

    

arr3d[0] = old_values


    

In [307]:

    

arr3d


    

    
Out[307]:





array([[[ 1,  2,  3],
        [ 4,  5,  6]],

       [[ 7,  8,  9],
        [10, 11, 12]]])

In [308]:

    

arr2d


    

    
Out[308]:





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

In [309]:

    

arr2d[:2]


    

    
Out[309]:





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

In [310]:

    

arr2d[:2,:2]


    

    
Out[310]:





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

In [311]:

    

### Boolean Indexing


    

In [312]:

    

names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])


    

In [313]:

    

data = np.random.randn(7,4)


    

In [314]:

    

data


    

    
Out[314]:





array([[ 0.10289297,  2.90246559,  2.27300433, -0.87664228],
       [ 0.28073289, -0.36370018,  0.59231769, -0.67343579],
       [-0.79142045,  0.89950742,  0.60077744, -0.77022984],
       [ 0.03157877, -1.28593835,  0.13791617, -0.81559219],
       [ 0.6814858 ,  1.55010797,  0.6058013 , -1.34349395],
       [-1.66586023, -1.56269374,  0.94419005,  0.58805994],
       [ 0.63490795,  1.43822816,  2.55016348,  0.34348943]])

In [315]:

    

names == 'Bob'


    

    
Out[315]:





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

In [316]:

    

data[names == 'Bob']


    

    
Out[316]:





array([[ 0.10289297,  2.90246559,  2.27300433, -0.87664228],
       [ 0.03157877, -1.28593835,  0.13791617, -0.81559219]])

In [317]:

    

data[names == 'Bob', 2:]


    

    
Out[317]:





array([[ 2.27300433, -0.87664228],
       [ 0.13791617, -0.81559219]])

In [318]:

    

data[names == 'Bob', 2]


    

    
Out[318]:





array([ 2.27300433,  0.13791617])

In [319]:

    

data[names != 'Bob']


    

    
Out[319]:





array([[ 0.28073289, -0.36370018,  0.59231769, -0.67343579],
       [-0.79142045,  0.89950742,  0.60077744, -0.77022984],
       [ 0.6814858 ,  1.55010797,  0.6058013 , -1.34349395],
       [-1.66586023, -1.56269374,  0.94419005,  0.58805994],
       [ 0.63490795,  1.43822816,  2.55016348,  0.34348943]])

In [320]:

    

data[~(names == 'Bob')]


    

    
Out[320]:





array([[ 0.28073289, -0.36370018,  0.59231769, -0.67343579],
       [-0.79142045,  0.89950742,  0.60077744, -0.77022984],
       [ 0.6814858 ,  1.55010797,  0.6058013 , -1.34349395],
       [-1.66586023, -1.56269374,  0.94419005,  0.58805994],
       [ 0.63490795,  1.43822816,  2.55016348,  0.34348943]])

In [321]:

    

data[(names == 'Bob') | (names == 'Will')]


    

    
Out[321]:





array([[ 0.10289297,  2.90246559,  2.27300433, -0.87664228],
       [-0.79142045,  0.89950742,  0.60077744, -0.77022984],
       [ 0.03157877, -1.28593835,  0.13791617, -0.81559219],
       [ 0.6814858 ,  1.55010797,  0.6058013 , -1.34349395]])

In [322]:

    

data[data < 0] = 0


    

In [323]:

    

data


    

    
Out[323]:





array([[ 0.10289297,  2.90246559,  2.27300433,  0.        ],
       [ 0.28073289,  0.        ,  0.59231769,  0.        ],
       [ 0.        ,  0.89950742,  0.60077744,  0.        ],
       [ 0.03157877,  0.        ,  0.13791617,  0.        ],
       [ 0.6814858 ,  1.55010797,  0.6058013 ,  0.        ],
       [ 0.        ,  0.        ,  0.94419005,  0.58805994],
       [ 0.63490795,  1.43822816,  2.55016348,  0.34348943]])

In [324]:

    

data[names != 'Joe'] = 7


    

In [325]:

    

data


    

    
Out[325]:





array([[ 7.        ,  7.        ,  7.        ,  7.        ],
       [ 0.28073289,  0.        ,  0.59231769,  0.        ],
       [ 7.        ,  7.        ,  7.        ,  7.        ],
       [ 7.        ,  7.        ,  7.        ,  7.        ],
       [ 7.        ,  7.        ,  7.        ,  7.        ],
       [ 0.        ,  0.        ,  0.94419005,  0.58805994],
       [ 0.63490795,  1.43822816,  2.55016348,  0.34348943]])

In [326]:

    

### Fancy Indexing


    

In [327]:

    

arr = np.empty((8, 4))


    

In [328]:

    

arr


    

    
Out[328]:





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.]])

In [329]:

    

for i in range(8):
    arr[i] = i


    

In [330]:

    

arr


    

    
Out[330]:





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

In [331]:

    

arr[[4, 3, 2, 5]]


    

    
Out[331]:





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

In [332]:

    

arr[[-3, -5, -7]]


    

    
Out[332]:





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

In [333]:

    

arr = np.arange(32).reshape(8, 4)


    

In [334]:

    

arr


    

    
Out[334]:





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]])

In [335]:

    

arr[[1, 5, 7, 2], [0, 3, 1, 2]]


    

    
Out[335]:





array([ 4, 23, 29, 10])

In [336]:

    

arr[[1, 5, 7, 2]][:, [0, 3, 1, 2]]


    

    
Out[336]:





array([[ 4,  7,  5,  6],
       [20, 23, 21, 22],
       [28, 31, 29, 30],
       [ 8, 11,  9, 10]])

In [337]:

    

arr[np.ix_([1, 5, 7, 2], [0, 3, 1, 2])]


    

    
Out[337]:





array([[ 4,  7,  5,  6],
       [20, 23, 21, 22],
       [28, 31, 29, 30],
       [ 8, 11,  9, 10]])

In [338]:

    

np.ix_([1, 5, 7, 2], [0, 3, 1, 2])


    

    
Out[338]:





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

In [339]:

    

### Transposing Arrays and Swapping Axes


    

In [340]:

    

arr = np.arange(15).reshape((3,5))


    

In [341]:

    

arr


    

    
Out[341]:





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

In [342]:

    

arr.T


    

    
Out[342]:





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

In [343]:

    

np.dot(arr.T, arr)


    

    
Out[343]:





array([[125, 140, 155, 170, 185],
       [140, 158, 176, 194, 212],
       [155, 176, 197, 218, 239],
       [170, 194, 218, 242, 266],
       [185, 212, 239, 266, 293]])

In [344]:

    

np.dot(arr, arr.T)


    

    
Out[344]:





array([[ 30,  80, 130],
       [ 80, 255, 430],
       [130, 430, 730]])

In [345]:

    

arr = np.arange(16).reshape(2, 2, 4)


    

In [346]:

    

arr


    

    
Out[346]:





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

       [[ 8,  9, 10, 11],
        [12, 13, 14, 15]]])

In [347]:

    

arr.transpose(1, 0, 2)


    

    
Out[347]:





array([[[ 0,  1,  2,  3],
        [ 8,  9, 10, 11]],

       [[ 4,  5,  6,  7],
        [12, 13, 14, 15]]])

In [348]:

    

arr.swapaxes(1, 2)


    

    
Out[348]:





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

       [[ 8, 12],
        [ 9, 13],
        [10, 14],
        [11, 15]]])

In [349]:

    

arr


    

    
Out[349]:





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

       [[ 8,  9, 10, 11],
        [12, 13, 14, 15]]])

In [350]:

    

### Universal Functions: Fast Element-wise Array Functions


    

In [351]:

    

arr = np.arange(10)


    

In [352]:

    

np.sqrt(arr)


    

    
Out[352]:





array([ 0.        ,  1.        ,  1.41421356,  1.73205081,  2.        ,
        2.23606798,  2.44948974,  2.64575131,  2.82842712,  3.        ])

In [353]:

    

np.exp(arr)


    

    
Out[353]:





array([  1.00000000e+00,   2.71828183e+00,   7.38905610e+00,
         2.00855369e+01,   5.45981500e+01,   1.48413159e+02,
         4.03428793e+02,   1.09663316e+03,   2.98095799e+03,
         8.10308393e+03])

In [360]:

    

x, y = np.random.randn(8), np.random.randn(8)


    

In [361]:

    

np.maximum(x, y)


    

    
Out[361]:





array([ 1.56990835,  2.27947146,  0.30208168,  1.16897605,  1.65010192,
        0.84616608,  0.52930149,  1.29454268])

In [364]:

    

arr = np.random.randn(7)*5
arr


    

    
Out[364]:





array([ 7.22846789, -8.46133524,  3.5496447 , -8.61704727, -4.40502151,
       -3.77209693,  4.00360582])

In [365]:

    

np.modf(arr)


    

    
Out[365]:





(array([ 0.22846789, -0.46133524,  0.5496447 , -0.61704727, -0.40502151,
        -0.77209693,  0.00360582]), array([ 7., -8.,  3., -8., -4., -3.,  4.]))

In [367]:

    

np.floor(arr)


    

    
Out[367]:





array([ 7., -9.,  3., -9., -5., -4.,  4.])

In [368]:

    

np.ceil(arr)


    

    
Out[368]:





array([ 8., -8.,  4., -8., -4., -3.,  5.])

In [369]:

    

np.rint(arr)


    

    
Out[369]:





array([ 7., -8.,  4., -9., -4., -4.,  4.])

In [370]:

    

np.isnan(arr)


    

    
Out[370]:





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

In [372]:

    

a, b = np.arange(10), np.arange(10,20)
a, b


    

    
Out[372]:





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

In [373]:

    

np.multiply(a, b)


    

    
Out[373]:





array([  0,  11,  24,  39,  56,  75,  96, 119, 144, 171])

In [ ]:

    




    

In [ ]:

    




    

In [ ]: