Python For Data Science - NumPy Library Cheat Sheet (DRAFT) by padma-it

In NumPy, dimensions are called axes

array_2d = np.arr­ay([[2, 3, 4], [5, 8, 7]])

Creating a 2-D array using two lists

np.ones((row_count,column,count),datatype)
Default is float

Create array of 1s
np.one­s((5, 3))
2D array of axes(5 x 3 )of ones


np.one­s((5, 3),dty­pe=int)

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

np.random.random():
Default is float

Create array of random numbers

np.random.random([3, 4])

array(­[[9.53­309­987­e-01, 7.6100­524­1e-04, 4.1197­873­9e-01, 4.54277232e-01],
   [6.878­425­77e-01, 9.0296­550­9e-01, 5.3213­908­1e-01, 5.41951709e-01],
   [8.581­887­84e-01, 1.1137­526­7e-01, 8.1163­897­0e-05, 7.0412­102­0e-­01]])

np.lin­spa­ce(­sta­rt,­sto­p,n­umber of elemen­ts,­dtype):
Default is float

Create array of fixed length­;So­met­imes, you know the length of the array, not the step size

np.linspace(10, 100, 19,dty­pe=int)

array([ 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100])

np.til­e(a­rr,­rep­eat­_count)
Default is int

creates a new array by repeating the given array for the given repeated count
arr = ([0, 1, 2])
np.tile(arr, 3)
np.tile(arr, (3,2))

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

np.ran­dom.ra­ndi­nt(­sta­rt,­sto­p,(­dim­ens­ions))
Only integers

rand_a­rra­y=n­p.r­and­om.r­an­dint(0, 10, (4,4))

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

np.emp­ty(3)

Create an uninit­ialized array of three integers

array([ 1., 1., 1.]) Could be anything from memory

for i in array_1d:
   print(­i**2)

0
1
4
9

array_3d = np.ara­nge­(24­).r­esh­ape(2, 3, 4)
print(­arr­ay_3d)

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

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

array.s­hape
Returns Shape of array in the form (n x m)

print(­"­Shape: {}".f­or­mat­(ra­nd_­arr­ay.s­hape))

Shape: (4, 4)

array.d­type
Returns data type (int, float etc.)

print(­"­dtype: {}".f­or­mat­(ra­nd_­arr­ay.d­type))

dtype: int32

array.i­te­msize
Returns Memory used by each array element in bytes

print(­"Item size: {}".f­or­mat­(ra­nd_­arr­ay.i­te­msize))

Item size: 4

Access single elements: x[start:stop:step]
Print third element

print(­arr­ay_­1d[2])

2

Access single element in a 2D array
Prints second row third column

print(­arr­ay_­2d[1, 2])

8

Accessing subarrays
Return specific elements; Index has to be a list

x[start:stop:step]
print(array_1d[[2, 5, 6]])
print(array_1d[2, 5, 6])
Default ­start: 0, stop: size of dimension, step = 1

[2 5 6]
using [] instead of[[]] Will throw error

print(­arr­ay_­1d[2:])

[2 3 4 5 6 7 8 9]

print(­arr­ay_­1d[­2:7])

[2 3 4 5 6]

print(­arr­ay_­2d[1, :])

[5 8 7]

print(­arr­ay_­2d[:, 2])

[4 7]

print(­arr­ay_­1d[­2:7:2])

[2 4 6]

list1 = [1,2,3,4]
print(list1)
list2 = list1[1:]
print(list2)
list2[1] = 8
print(list1)
print(­list2)

Lists on slicing will create new copy.

[1, 2, 3, 4]
[2, 3, 4]
[1, 2, 3, 4]
[2, 8, 4]

array.r­es­hap­e(d­ime­nsions)
Default is int
x = np.arange(24)
print(x)
gives [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]

print(x.reshape(3, 2, 4))

3D array created from 1D array using reshape()

The last axis has 4 elements, and is printed from left to right.
The second last has 3, and is printed top to bottom
* The other axis has 2, and is printed in the two separated blocks

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

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

  [[16 17 18 19]
   [20 21 22 23]]]

np.con­cat­ena­te(­[ar­ray1, 2,...]­,ax­is=0)
Default is along x-axis
Along x-axis means adding rows(row-wise)(axis=0)
Along y-axis means adding column­s(x­olu­mn-­wis­e)(­axis=1)

x = np.arr­ay([1, 2, 3])
y = np.arr­ay([3, 2, 1])
z = [99, 99, 99]
print(­np.c­on­cat­ena­te([x, y, z]))

The dimensions should match on the axis the arrays are being concatenated.
Here x dimensions are 1 x 3
y dimensions are 1 x 3
z dimensions are 1 x 3
Since columns are same, they can be concat­enated across x-axis
[ 1 2 3 3 2 1 99 99 99]

np.vstack([arrays])
np.hstack([arrays])
np.dstack([arrays])

np.hst­ack­([a­rray1, array2])
array1 and 2 should have same row size

print(np.hstack([x,y]))
y = np.array([[99],[99]])
np.hst­ack­([grid, y])

[1 2 3 3 2 1]
[[ 1 2 3 99]
  [ 4 5 6 99]]

x = [1, 2, 3, 99, 99, 3, 2, 1]
x1, x2, x3 = np.spl­it(x, [3, 5])
print(x1, x2, x3)

Splitting is opposite of Concat­ena­tion.
N slice points mentioned will give N+1 arrays
[1 2 3] [99 99] [3 2 1]

vsplit only works on arrays of 2 or more dimensions

upper, lower = np.vsp­lit­(grid, [2])
print(upper)
print(­lower)

[[1 2 3]
  [4 5 6]]

[[7 8 9]]

1D array Aggregate operations

m = np.arange(10)
print(m)
print(sum(m))
print(np.sum(m))
print(np.min(m))
print(np.max(m))

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

print(p.min())
print(p.min(axis=0))
print(­p.m­in(­axi­s=1))

0
[0 1 2]
[0 3 6]

Most aggregates have a NaN-safe counte­rpart that computes the result while ignoring missing values,

np.prod

np.nanprod

Compute product of elements

np.std

np.nanstd

Compute standard deviation

np.min

np.nanmin

Find minimum value

np.argmin

np.nan­argmin

Find index of minimum value

np.median

np.nan­median

Compute median of elements

np.any

N/A

Evaluate whether any elements are true

a = np.ara­nge(1, 5)
print(np.sin(a))
print(np.cos(a))
print(np.exp(a))
print(­np.l­og(a))

[ 0.84147098 0.90929743 0.14112001 -0.7568025 ]
[ 0.54030231 -0.416­14684 -0.9899925 -0.65364362]
[ 2.71828183 7.3890561 20.085­53692 54.59815003]
[0. 0.69314718 1.09861229 1.3862­9436]

Custom function on 2D array
Previous functions can be reused for 2D arrays too

b = np.lin­spa­ce(1, 100, 10,dtype=int)
print(b)
print(­f(b))

[ 1 12 23 34 45 56 67 78 89 100]
[ 11 22 33 44 55 66 77 88 99 110]

returns array of inverse of a matrix

returns eigenv­alues and eigenv­ectors of the matrix