In [1]:
import numpy as np


### Arrays¶

In [2]:
# numpy array
arr = np.array([0,1,2,3])
arr

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

numpy calc is faster than native python

In [3]:
# testing the same

L = range(100000)
%timeit [i**2 for i in L]

10 loops, best of 3: 55.7 ms per loop

In [4]:
L = np.arange(100000)
%timeit L**2

The slowest run took 4.17 times longer than the fastest. This could mean that an intermediate result is being cached.
10000 loops, best of 3: 98.8 µs per loop


there are so many ways to create array in numpy, we will see them one by one

#### starting with 1-D array¶

In [5]:
a = np.array([1,2,5,3,5,9])
a

Out[5]:
array([1, 2, 5, 3, 5, 9])
In [6]:
a = np.arange(1, 20)    # start, end
a

Out[6]:
array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
18, 19])
In [7]:
a = np.arange(1, 20, 3)   # start, end, step
a

Out[7]:
array([ 1,  4,  7, 10, 13, 16, 19])
In [8]:
# check dimension and size
print("dimension - ", a.ndim)
print("size - ", a.shape)
print("length - ", len(a))

dimension -  1
size -  (7,)
length -  7


#### 2-D array¶

In [9]:
b = np.array([[1,2,3], [2,3,4], [3,4,5]])
b

Out[9]:
array([[1, 2, 3],
[2, 3, 4],
[3, 4, 5]])
In [10]:
# check dimension and size
print("dimension - ", b.ndim)
print("size - ", b.shape)
print("length - ", len(b))

dimension -  2
size -  (3, 3)
length -  3


3-D array

In [11]:
c = np.array([[[5,7], [8,9], [0,7]], [[1,2], [2,3], [6,7]], [[5,7], [8,9], [0,7]]])
c

Out[11]:
array([[[5, 7],
[8, 9],
[0, 7]],

[[1, 2],
[2, 3],
[6, 7]],

[[5, 7],
[8, 9],
[0, 7]]])
In [12]:
# check dimension and size
print("dimension - ", c.ndim)
print("size - ", c.shape)
print("length - ", len(c))

dimension -  3
size -  (3, 3, 2)
length -  3


Simplest way to create test array

In [13]:
# by no
a = np.arange(1, 10, 2)
print(a)
print(a.shape)

[1 3 5 7 9]
(5,)

In [14]:
# by number of points
a = np.linspace(1, 10, 4)  # pick any 4 no from 1 to 10
print(a)
print(a.shape)

[  1.   4.   7.  10.]
(4,)

In [15]:
# by number of points
a = np.linspace(1, 10, 6, endpoint=False)  # pick any 4 no from 1 to 10
print(a)
print(a.shape)

[ 1.   2.5  4.   5.5  7.   8.5]
(6,)


Common arrays to use :

In [16]:
np.ones(4)

Out[16]:
array([ 1.,  1.,  1.,  1.])
In [17]:
np.ones((2,4))

Out[17]:
array([[ 1.,  1.,  1.,  1.],
[ 1.,  1.,  1.,  1.]])
In [18]:
np.zeros((2,3))

Out[18]:
array([[ 0.,  0.,  0.],
[ 0.,  0.,  0.]])
In [19]:
np.eye((3))

Out[19]:
array([[ 1.,  0.,  0.],
[ 0.,  1.,  0.],
[ 0.,  0.,  1.]])
In [20]:
np.diag([1,2,3,4])

Out[20]:
array([[1, 0, 0, 0],
[0, 2, 0, 0],
[0, 0, 3, 0],
[0, 0, 0, 4]])

#### Random no generation¶

with help of numpy random library

In [21]:
np.random.rand(5)   # pick any 5 value between 0 and 1

Out[21]:
array([ 0.77109549,  0.92437055,  0.13376104,  0.00209447,  0.99861705])
In [22]:
np.random.randn(5)  # includes negative no as well (Gaussian)

Out[22]:
array([-0.26465512,  0.76965644,  0.61422423,  2.54456552, -0.99713591])
In [23]:
np.random.randint(9)  # this will pick any random no from 0 to 8 (integer)

Out[23]:
1
In [24]:
np.random.randint(10, 13)  # start, end    end exclusive

Out[24]:
11
In [25]:
np.random.randint(10, 13, 2)  # start, end, no of element    end exclusive

Out[25]:
array([11, 11])
In [26]:
np.random.randint(10, 13, 4)  # start, end, no of element    end exclusive

Out[26]:
array([11, 10, 10, 10])
In [27]:
np.random.randint(1, 20, (4, 3))

Out[27]:
array([[19, 11, 11],
[18,  5, 17],
[ 5, 13, 13],
[15, 19, 16]])

If you set the np.random.seed(a_fixed_number) every time you call the numpy's other random function, the result will be the same:

In [28]:
np.random.seed(123)
np.random.randint(1, 10, 2)

Out[28]:
array([3, 3])
In [29]:
np.random.seed(123)
np.random.randint(1, 10, 2)

Out[29]:
array([3, 3])

#### Data Type¶

In [30]:
a = np.random.randint(3,9, 3)
print(a)
print(a.dtype)

[4 6 5]
int32

In [31]:
a = np.random.rand(3)
print(a)
print(a.dtype)

[ 0.42310646  0.9807642   0.68482974]
float64


You can explicitly specify which data-type you want:

In [32]:
c = np.array([1, 2, 3], dtype=float)
c.dtype

Out[32]:
dtype('float64')
In [33]:
c = np.array([1, 2, 3])
c.dtype

Out[33]:
dtype('int32')
In [34]:
a = np.ones((3, 3))
a.dtype

Out[34]:
dtype('float64')
In [35]:
# complex data type
d = np.array([1+2j, 3+4j, 5+6*1j])
d.dtype

Out[35]:
dtype('complex128')
In [36]:
# Boolean
e = np.array([True, False, False, True])
e.dtype

Out[36]:
dtype('bool')
In [37]:
# String
f = np.array(['Bonjour', 'Hello', 'Hallo'])
f.dtype  # unicode string with max 7 letters

Out[37]:
dtype('<U7')

### Indexing and Slicing¶

In [38]:
a = np.arange(10)
print(a)

a[2], a[0], a[8], a[-1]

[0 1 2 3 4 5 6 7 8 9]

Out[38]:
(2, 0, 8, 9)
In [39]:
a[2:7]

Out[39]:
array([2, 3, 4, 5, 6])
In [40]:
# reversing the array
a[::-1]

Out[40]:
array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])
In [41]:
a[1:8:3]  #start, end, step

Out[41]:
array([1, 4, 7])
In [42]:
a[:4]  #start, 4

Out[42]:
array([0, 1, 2, 3])
In [43]:
a[6:]  #6, end

Out[43]:
array([6, 7, 8, 9])
In [44]:
a[:]  #start, end

Out[44]:
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

numpy array supports all python Indexing and Slicing operation

#### Numpy indexing and Slicing¶

In [45]:
a = np.arange(10)
a

Out[45]:
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [46]:
a[5:] = 11
a

Out[46]:
array([ 0,  1,  2,  3,  4, 11, 11, 11, 11, 11])
In [47]:
a[6:] = a[::-1][6:]
a

Out[47]:
array([ 0,  1,  2,  3,  4, 11,  3,  2,  1,  0])

### Array Copies and Views¶

In [48]:
a = np.arange(10)
a

Out[48]:
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [49]:
b = a[6:]
b

Out[49]:
array([6, 7, 8, 9])
In [50]:
a[7] =  13
print(a)
print(b)

[ 0  1  2  3  4  5  6 13  8  9]
[ 6 13  8  9]

In [51]:
print(np.may_share_memory(a,b))

True


#### Copy¶

In [52]:
b = a[6:].copy()
b

Out[52]:
array([ 6, 13,  8,  9])
In [53]:
a[8] =  16
print(a)
print(b)

[ 0  1  2  3  4  5  6 13 16  9]
[ 6 13  8  9]

In [54]:
print(np.may_share_memory(a,b))

False


#### Boolean indexing or Fancy indexing¶

In [55]:
a = np.arange(10)
a

Out[55]:
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [56]:
b = a%3==0
b   # boolean array

Out[56]:
array([ True, False, False,  True, False, False,  True, False, False,  True], dtype=bool)
In [57]:
# picking only those for which a%3==0 is TRUE
a[b]   # boolean indexing

Out[57]:
array([0, 3, 6, 9])
In [58]:
a[b] = a[b]+200
a

Out[58]:
array([200,   1,   2, 203,   4,   5, 206,   7,   8, 209])
In [59]:
b = np.random.randint(0, 6, 3)
b

Out[59]:
array([1, 0, 0])
In [60]:
a[b]

Out[60]:
array([  1, 200, 200])