numpy Library - basic operations (Part I)

Introduction of numpy Library:

import numpy as np

1. Build array

1.1 creating an array with array

1.1.1 establishment of one-dimensional array

>>> import numpy as np
>>> a1 = np.array([1,2,3,4,5,6])       #Parameter is list
>>> a1
array([1, 2, 3, 4, 5, 6])
>>> type(a1)
<class 'numpy.ndarray'>

>>> a2 = np.array((1,2,3,4,5,6))
>>> a2
array([1, 2, 3, 4, 5, 6])
>>> type(a2)
<class 'numpy.ndarray'>

1.1.2 establishment of two-dimensional array

>>> b1 = ([[1,2,3],[4,5,6]])
>>> b1
[[1, 2, 3], [4, 5, 6]]

>>> b2 = ([(0,0,0),(1,2,3),(4,5,6)])
>>> b2
[(0, 0, 0), (1, 2, 3), (4, 5, 6)]

1.1.3 establishment of 3D array

>>> c1 = np.array([[[1,2,3],
                [4,5,6]],
               [[1,1,1],
                [2,2,2]],
               [[4,4,4],
                [5,5,6]]])
>>> c1
array([[[1, 2, 3],
        [4, 5, 6]],

       [[1, 1, 1],
        [2, 2, 2]],

       [[4, 4, 4],
        [5, 5, 6]]])
>>> type(c1)
<class 'numpy.ndarray'>

1.1.4 precautions

In addition to integer, the types of array elements include string, Boolean, floating-point, complex, etc.

import numpy as np
d1 = np.array(['b', 'China', '100003600'])
d2 = np.array([True, False])
d3 = np.array([-1, 2, 10])
d4 = np.array([10.5, 6.2222, 7.248888])
d5 = np.array([10+2j, 8j, 2.1+3j])
print('d1:', d1,'\n','d2:', d2,'\n',
      'd3:', d3,'\n','d4:', d4,'\n','d5:', d5)
print('d1.dtype:',d1.dtype)    #Viewing array element types using dtytpe
print('d2.dtype:',d2.dtype)
print('d3.dtype:',d3.dtype)
print('d4.dtype:',d4.dtype)
print('d5.dtype:',d5.dtype)
print('d2.alltrue:', np.alltrue(d2))
print('d3.alltrue:', np.alltrue(d3))  #Use alltrue to test whether all array elements are True
>>> output:
    d1: ['b' 'China' '100003600'] 
 	d2: [ True False] 
 	d3: [-1  2 10] 
 	d4: [10.5       6.2222    7.248888] 
 	d5: [10. +2.j  0. +8.j  2.1+3.j]
	d1.dtype: <U9
	d2.dtype: bool
	d3.dtype: int32
	d4.dtype: float64
	d5.dtype: complex128
	d2.alltrue: False
	d3.alltrue: True

The array elements of numpy must be of the same type, that is, they cannot be both integer and string. If you accidentally enter elements of different types, the array function will automatically convert elements of other types.

import numpy as np
e1 = np.array(['OK?', 10, 'year', 0.3, False])   #The input value type is inconsistent
print('e1:', e1)
print('e1.dtype:', e1.dtype)
e2 = np.array([1, 0.2, 2.3333333])
print('e2:', e2)
print('e2.dtype:', e2.dtype)
e3 = np.array([1, 0.2, 2.3333333, 1+8j])
print('e3:', e3)
print('e3.dtype:', e3.dtype)
>>> output:
    e1: ['OK?' '10' 'year' '0.3' 'False']
	e1.dtype: <U32
	e2: [1.        0.2       2.3333333]
	e2.dtype: float64
	e3: [1.       +0.j 0.2      +0.j 2.3333333+0.j 1.       +8.j]
	e3.dtype: complex128

1.2 establishment methods of other common arrays

1.2.1 arange() function

Accumulates at the specified step size to produce an array of ordered elements in the specified range.
The function uses the format: numpy. Orange ([start,] stop [, step,], dtype = none), where start specifies the start number, stop specifies the end number, step is the incremental step size, and dtype can specify the numerical type of generating array elements.

import numpy as np
f1 = np.arange(1, 10, 2, dtype = 'float64')
# From 1 to 10 (excluding 10), take a number every 2, and convert all elements to 'float64'.
f2 = np.arange(5)
f3 = np.arange(0, 5)
f4 = np.arange(0, 5, 0.5)
f5 = np.arange(5, 0, -1)
print('f1:', f1)
print('f2:', f2)
print('f3:', f3)
print('f4:', f4)
print('f5:', f5)
>>> output:
    f1: [1. 3. 5. 7. 9.]
	f2: [0 1 2 3 4]
	f3: [0 1 2 3 4]
	f4: [0.  0.5 1.  1.5 2.  2.5 3.  3.5 4.  4.5]
	f5: [5 4 3 2 1]

1.2.2 linspace() function

Returns a sample array of uniform steps within the specified range.
Function format: numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0), where start specifies the start number and stop specifies the end number. These two parameters must be provided and others are optional. endpoint=True indicates that the specified stop is also included, and retstep=True indicates the number of steps in the returned array.

import numpy as np
g1 = np.linspace(0,1,2)
g2 = np.linspace(0,4,4)
g3 = np.linspace(0,4,10)
print('g1:', g1)
print('g2:', g2)
print('g3:', g3)
g4 = np.linspace(0,4,4,endpoint = False)
print('g4:', g4)
g5 = np.linspace(0,4,4,retstep = True)
print('g5:', g5)
g6 = np.linspace(0,4,4,endpoint = False,retstep = True)
print('g6:', g6)
>>> output:
    g1: [0. 1.]
	g2: [0.         1.33333333 2.66666667 4.        ]
	g3: [0.         0.44444444 0.88888889 1.33333333 1.77777778 2.22222222
 		 2.66666667 3.11111111 3.55555556 4.        ]
	g4: [0. 1. 2. 3.]
	g5: (array([0.        , 1.33333333, 2.66666667, 4.        ]), 1.3333333333333333)
	g6: (array([0., 1., 2., 3.]), 1.0)

1.2.3 zeros() function

Generate an array with a value of 0.
The function uses the format: numpy.zeros(shape, dtype =float, order = 'C'), where order specifies whether the storage format is C language style (c) or F language style (F).

import numpy as np
z1 = np.zeros(5)
z2 = np.zeros((3,3))
print('z1:',z1)
print('z2:',z2)
>>> output:
    z1: [0. 0. 0. 0. 0.]
	z2: [[0. 0. 0.]
 		[0. 0. 0.]
 		[0. 0. 0.]]

1.2.4 ones() function

Generate an array with a value of 1.
The function uses the format: numpy.oneos(shape, dtype =float, order = 'C').

import numpy as np
o1 = np.ones(5)
o2 = np.ones((2,3))
print('o1:',o1)
print('o2:',o2)
>>> output:
    o1: [1. 1. 1. 1. 1.]
	o2: [[1. 1. 1.]
 		[1. 1. 1.]]

1.2.5 empty() function

Generates an array with no specified value, and the values in the array are not specified.
The function uses the format: numpy.empty(shape, dtype =float, order = 'C').

import numpy as np
e1 = np.empty(5)
e2 = np.empty((4,4))
print('e1:',e1)
print('e2:',e2)
>>> output1:
    e1: [9.90263869e+067 8.01304531e+262 2.60799828e-310 0.00000000e+000
 		0.00000000e+000]
	e2: [[6.23042070e-307 4.67296746e-307 1.69121096e-306 1.29061074e-306]
 		 [1.89146896e-307 7.56571288e-307 3.11525958e-307 1.24610723e-306]
 		 [1.37962320e-306 1.29060871e-306 2.22518251e-306 1.33511969e-306]
 		 [1.78022342e-306 1.05700345e-307 1.11261027e-306 4.84184333e-322]]
>>> output2:
    e1: [ 6.23042070e-307  1.42417221e-306  1.37961641e-306 -2.65972661e-207
  		7.22947795e+223]
	e2: [[6.23042070e-307 4.67296746e-307 1.69121096e-306 1.29061074e-306]
         [1.89146896e-307 7.56571288e-307 3.11525958e-307 1.24610723e-306]
 		 [1.37962320e-306 1.29060871e-306 2.22518251e-306 1.33511969e-306]
 		 [1.78022342e-306 1.05700345e-307 3.11521884e-307 3.72363246e-317]]

1.2.6 logspace() function

Returns numbers evenly spaced on a logarithmic scale.
Function format: numpy.linspace(start, stop, num=50, endpoint=True, base=10, dtype=None, axis=0), where the base parameter is the base of the specified logarithm, and the default is 10

import numpy as np
h1 = np.logspace(2.0, 3.0, 5)
print('h1:', h1)
>>> output:
    h1: [ 100.          177.827941    316.22776602  562.34132519 1000.        ]

1.2.7 full() function

Returns an array of specified values.
The function uses the format: numpy.full(shape, fill_value, dtype=None, order='C '), where, fill_ Value specifies the value to fill in.

import numpy as np
f1 = np.full(5,10)
f2 = np.full((3,3), 8)
f3 = np.full((3,3), np.inf)    # inf is positive infinity
f4 = np.full((3,3), 'China')
print('f1:', f1)
print('f2:', f2)
print('f3:', f3)
print('f4:', f4)
>>> output:
    f1: [10 10 10 10 10]
	f2: [[8 8 8]
 		 [8 8 8]
 		 [8 8 8]]
	f3: [[inf inf inf]
 		 [inf inf inf]
 	 	 [inf inf inf]]
	f4: [['China' 'China' 'China']
 		 ['China' 'China' 'China']
		 ['China' 'China' 'China']]

1.2.8 eye() function

Returns a two-dimensional array with a diagonal of 1 and others of 0.
The function uses the format: numpy. Eye (N, M = none, k = 0, dtype = < class' float '>, order ='c'), where N specifies the number of rows returned from the array, m specifies the number of columns returned from the array (M=N by default), K is used to specify the diagonal position, 0 is the main diagonal, a positive number is the upper diagonal, and a negative number is the lower diagonal.

import numpy as np
e1 = np.eye(4)
e2 = np.eye(4,4, 2)
e3 = np.eye(4,4, -2)
print('e1:', e1)
print('e2:', e2)
print('e3:', e3)
>>> output:
    e1: [[1. 0. 0. 0.]
		 [0. 1. 0. 0.]
		 [0. 0. 1. 0.]
		 [0. 0. 0. 1.]]
	e2: [[0. 0. 1. 0.]
		 [0. 0. 0. 1.]
		 [0. 0. 0. 0.]
		 [0. 0. 0. 0.]]
	e3: [[0. 0. 0. 0.]
		 [0. 0. 0. 0.]
		 [1. 0. 0. 0.]
		 [0. 1. 0. 0.]]

1.2.9 repeat() function

Create an array in which each element is repeated N times.
The function uses the format: numpy.repeat(a,repeats,axis=None). A is the collection object, and repeats is the specified number of element repetitions. In the case of multi-dimensional array, axis can specify the direction of the repeated dimension.

import numpy as np
r1 = np.repeat([0,1,0], 5)
print('r1:', r1)
>>> output:
    r1: [0 0 0 0 0 1 1 1 1 1 0 0 0 0 0]

1.3 use of array attributes

ndim attribute: returns the dimension of the array.
Shape property: returns the shape size of the array.
size attribute: returns the number of array elements.
dtype property: returns the array element type.
itemsize property: returns the byte size of an array element.

import numpy as np
t1 = np.array([['a','b','c'],['d','e','f'],['g','h','i']])
print('t1:', t1)
print('t1.ndim:', t1.ndim)
print('t1.shape:', t1.shape)
print('t1.size:', t1.size)
print('t1.dtype:', t1.dtype)
print('t1.itemsize:', t1.itemsize)
>>> output:
    t1: [['a' 'b' 'c']
		 ['d' 'e' 'f']
		 ['g' 'h' 'i']]
	t1.ndim: 2
	t1.shape: (3, 3)
	t1.size: 9
	t1.dtype: dtype('<U1')
	t1.itemsize: 4

1.4 use of array method

reshape method: change the shape of the array.
all method: to judge whether the specified array elements are non-0, return True; otherwise, return False.
any method: judge that if the array element has a non-0 value, it returns True; otherwise, it returns False.
Copy method: copies a copy of the array.
astype method: change the type of array element.

import numpy as np
t1 = np.arange(9)
# reshape method
t2 = t1.reshape(3,3)  #Convert from a one-dimensional array to a two-dimensional array of 3 rows and 3 columns.
print('t1:', t1)
print('t2:', t2)
# all method
t3 = np.ones(9).all()
t4 = np.array([1,0,2])
t5 = np.array([[1,0,2],[1,2,3]])
print('t3:',t3)
print('t4.all:', t4.all())
print('t5.all(axis=1):', t5.all(axis=1))  # Judge whether each row is 0 from the row direction.
# The parameter axis points to the dimension direction, and 0 indicates the second dimension and column direction; 1 indicates the first dimension, row direction, and so on.
# any method
t6 = np.array([[1,0,2],[0,0,2]])
print('t6.any(axis=1):', t6.any(axis=1))
print('t6.any(axis=0):', t6.any(axis=0))
# copy method
t7 = np.array([['a', 'b', 'c'],
               ['d', 'e', 'f'],
               ['g', 'h', 'i']])
t8 = t7
t9 = np.copy(t7)
print('id(t7):', id(t7))
print('id(t8):', id(t8))
print('id(t9):', id(t9))
# astype method
t10 = np.ones(9, dtype = int)
print('t10:', t10)
print('t10.astype(float):', t10.astype(float))
>>> output:
    t1: [0 1 2 3 4 5 6 7 8]
	t2: [[0 1 2]
		 [3 4 5]
		 [6 7 8]]
	t3: True
	t4.all: False
	t5.all(axis=1): [False  True]
	t6.any(axis=1): [ True  True]
	t6.any(axis=0): [ True False  True]
	id(t7): 2182816274448
	id(t8): 2182816274448
	id(t9): 2182816274544
	t10: [1 1 1 1 1 1 1 1 1]
	t10.astype(float): [1. 1. 1. 1. 1. 1. 1. 1. 1.]

2. Indexing and slicing

2.1 basic index

The basic index usage of Numpy array is the same as that of Python list object. Square brackets [] are also used to index a group of values.

import numpy as np
# Reading and writing of single element of one-dimensional array
n1=np.arange(10)
print('n1:', n1)
print('n1[9]:', n1[9])
print('n1[-1]:', n1[-1])
n1[0]=10   # Modify elements according to subscript (elements with subscript 0)
print('n1:', n1)
# Reading and writing of single element of two-dimensional array
n2=n1.reshape(2,5)
print('n2:', n2)
print('n2[1,0]:', n2[1,0])
n2[1,1]=-1    # Modify element according to subscript (row 2, column 2)
print('n2[1,1]:', n2[1,1])
# Reading and writing of single element of three-dimensional array
n3=np.arange(12).reshape(2,2,3)
print('n3:', n3)
print('n3[1,0,0]:', n3[1,0,0])  #Subscript 1 is the 2nd row of the 3rd dimension, middle 0 is the 1st row of the 2nd dimension, and rightmost 0 is the 1st column of the 1st dimension.
print('n3[1,1,1]:', n3[1,1,1])
n3[1,0,2]=-1    # Modify elements according to subscripts (3D: Row 2, 2D: row 1, 1D: column 3)
print('n3:', n3)
>>> output:
    n1: [0 1 2 3 4 5 6 7 8 9]
	n1[9]: 9
	n1[-1]: 9
	n1: [10  1  2  3  4  5  6  7  8  9]
	n2: [[10  1  2  3  4]
		 [ 5  6  7  8  9]]
	n2[1,0]: 5
	n2[1,1]: -1
	n3: [[[ 0  1  2]
		  [ 3  4  5]]
		 [[ 6  7  8]
 		  [ 9 10 11]]]  #The number 8 is the second row of the third dimension, the first row of the second dimension, and the third column of the first dimension.
	n3[1,0,0]: 6
	n3[1,1,1]: 10
	n3: [[[ 0  1  2]
		  [ 3  4  5]]
	 	 [[ 6  7 -1]
		  [ 9 10 11]]]

2.1.1 index omission usage

When the dimension cannot be determined, you can read the array through the ellipsis to the right of the subscript or omit the subscript number directly.
Omitting from the left of the subscript can only be in the form of "··", not in the form of n3[,2], otherwise an error will be reported.
From the subscript middle dimension, only "··" can be used, and the subscript number in the middle cannot be directly omitted, otherwise an error will be reported.

import numpy as np
n3=np.arange(12).reshape(2,2,3)
print('n3:', n3)
print('n3[1,...]:',n3[1,...])  # Omit right
print('n3[1,]:',n3[1,])  
print('n3[...,2]:',n3[...,2])   # Omit left
print('n3[1,...,2]:',n3[1,...,2])   # Omit middle
>>> output:
    n3: [[[ 0  1  2]
  		  [ 3  4  5]]
		 [[ 6  7  8]
 		  [ 9 10 11]]]   #The number 8 is the second row of the third dimension, the first row of the second dimension, and the third column of the first dimension.
	n3[1,...]: [[ 6  7  8]
			    [ 9 10 11]]
	n3[1,]: [[ 6  7  8]
 			 [ 9 10 11]]
	n3[...,2]: [[ 2  5]
  				[ 8 11]]
	n3[1,...,2]: [ 8 11]

2.1.2 generate array index

import numpy as np
n4=np.arange(4).reshape(2,2)
print('n4:', n4)
print('n4[1][1]:', n4[1][1])  # Equivalent to n4[1,1]
print('n4[1,1]:', n4[1,1])
>>> output:
    n4: [[0 1]
		 [2 3]]
	n4[1][1]: 3
	n4[1,1]: 3

2.2 slicing

The basic format of subscript slice is [b:e:s], B is the subscript start number, e is the subscript end number (the subscript of the number itself is not included, that is, it corresponds to the mathematically right open interval), s is the step size, and its default value is 1. b. E and s can be omitted arbitrarily.

import numpy as np
# One dimensional array slice
s1=np.arange(1,10)
print('s1:', s1)
print('s1[1:4]:', s1[1:4])   # Take the elements of one-dimensional array subscripts 1 ~ 3
print('s1[:5]:', s1[:5])   # Take the elements of one-dimensional array subscripts 0 ~ 4
print('s1[5:]:', s1[5:])   # Take the subscript 5 of one-dimensional array to the last element
print('s1[:-1]:', s1[:-1])   # Take all the elements from the penultimate subscript of the one-dimensional array
print('s1[:]:', s1[:])   # Take all subscript elements of a one-dimensional array
print('s1[::2]:', s1[::2])  #Step size is 2
# 2D array slice
s2=np.arange(9).reshape(3,3)
print('s2:', s2)
  # 2D array row slicing
print('s2[1:3]:', s2[1:3])    # Take 2 and 3 rows of subarray values, which is equivalent to s2[1:3,] or s2[1:3,:]
print('s2[1:3,]:', s2[1:3,])
print('s2[1:3,:]:', s2[1:3,:])
print('s2[:2]:', s2[:2])   # Take 1 and 2 rows of subarray
print('s2[2:]:', s2[2:])   # Take the sub array in line 3, which is equivalent to s2[2]
    # Row slice, column assignment
print('s2[:,2]:', s2[:,2])    # Take all rows, column 3, subarray
  # 2D array column slicing
print('s2[:,:2]:', s2[:,:2])    # Take all rows, column 1 and column 2 subarray
print('s2[...,:]:', s2[...,:])  # Get all rows, all columns
print('s2[1,2:]:', s2[1,2:])    # Take row 2 and column 3
# 3D array slice
s3=np.array([[['Tom',10,'boy'],['John',11,'girl']],[['Alice',12,'girl'],['Kite',11,'boy']]])
print('s3:', s3)
print('s3[1,1,:]:', s3[1,1,:])      #Get the second row of the third dimension, the first row of the second dimension, and the subarray of all columns of the first dimension
print('s3[0,:,:2]:', s3[0,:,:2])    #Get the subarray of the first row, the first row and the second row in the third dimension, and the first and second columns in the first dimension
>>> output:
    s1: [1 2 3 4 5 6 7 8 9]
	s1[1:4]: [2 3 4]
	s1[:5]: [1 2 3 4 5]
	s1[5:]: [6 7 8 9]
	s1[:-1]: [1 2 3 4 5 6 7 8]
	s1[:]: [1 2 3 4 5 6 7 8 9]
	s1[::2]: [1 3 5 7 9]
	s2: [[0 1 2]
 		 [3 4 5]
		 [6 7 8]]
	s2[1:3]: [[3 4 5]
			  [6 7 8]]
	s2[1:3,]: [[3 4 5]
			   [6 7 8]]
	s2[1:3,:]: [[3 4 5]
			    [6 7 8]]
	s2[:2]: [[0 1 2]
 			 [3 4 5]]
	s2[2:]: [[6 7 8]]
	s2[:,2]: [2 5 8]
	s2[:,:2]: [[0 1]
			   [3 4]
 			   [6 7]]
	s2[...,:]: [[0 1 2]
			    [3 4 5]
 				[6 7 8]]
	s2[1,2:]: [5]
	s3: [[['Tom' '10' 'boy']
  		  ['John' '11' 'girl']]
		 [['Alice' '12' 'girl']
  		  ['Kite' '11' 'boy']]]
	s3[1,1,:]: ['Kite' '11' 'boy']
	s3[0,:,:2]: [['Tom' '10']
 				 ['John' '11']]

2.3 fancy index

Fancy indexing uses all elements of an integer array as subscript values for indexing, also known as array index.

2.3.1 integer array index

import numpy as np
# One dimensional array index
fi1=np.array(['Tom cat','Garfield','Persian cat','black cat','British short faced cat','Pastoral cat'])
f1=np.array([1,2,4,5])
print('fi1[f1]:', fi1[f1])   #Remove cats that are not cat breeds
# Two dimensional array index
  # Use a one-dimensional entire array as the array index to generate a sub array of the specified row
fi2=np.array([['Tom cat',1,200],['Garfield',10,1000],['Persian cat',5,2000],['black cat',2,180],['British short faced cat',8,1800],['Pastoral cat',20,100]])
f2=np.array([1,2,3])   # Specify rows 2, 3, and 4 with a one-dimensional array
print('fi2[f2]:', fi2[f2])
  # Specify the array of X and Y coordinates, and find the elements corresponding to the coordinates of the specified array to form a sub array.
fi3=np.array([[0,-1,9],[8,1,10],[-2,8,3]])
print('fi3:', fi3)
x=np.array([[0,1,2]])   #Specify the x coordinate value
y=np.array([0,1,1])          #Specify the y coordinate value
print('fi3[x,y]:', fi3[x,y])    #Find all elements corresponding to X and Y coordinates
>>> output:
    fi1[f1]: ['Garfield' 'Persian cat' 'British short faced cat' 'Pastoral cat']
	fi2[f2]: [['Garfield' '10' '1000']
			  ['Persian cat' '5' '2000']
 			  ['black cat' '2' '180']]
	fi3: [[ 0 -1  9]
 		  [ 8  1 10]
		  [-2  8  3]]
	fi3[x,y]: [[0 1 8]]

2.3.2 Boolean array index

Boolean index requires the Boolean array to keep the same shape as the quoted array, and the index result generates a new one-dimensional array.
In addition, Boolean indexes can be carried out in behavioral units.

import numpy as np
# Boolean index
s4=np.arange(9).reshape(3,3)
print('s4:', s4)
b1=np.array([[True,True,False],[False,True,False],[False,False,True]])
print('b1:', b1)
print('s4[b1]:', s4[b1])
b2=b1[:,1]
print('b2:', b2)
print('s4[b2]:', s4[b2])
# Boolean index in behavioral units
b3=np.array([True,False,False])
print('s4[b3]:', s4[b3])
>>> output:
    s4: [[0 1 2]
 		 [3 4 5]
 		 [6 7 8]]
	b1: [[ True  True False]
 		 [False  True False]
 		 [False False  True]]
	s4[b1]: [0 1 4 8]
	b2: [ True  True False]
	s4[b2]: [[0 1 2]
			 [3 4 5]]
	s4[b3]: [[0 1 2]]

2.4 iteration

As a collection of elements, the array can be iterated to read the corresponding elements.

import numpy as np
# Iteration of one-dimensional array
print('g:')
d1=np.arange(3)
for g in d1:
    print(g)
# Iteration of two-dimensional array
print('------------------')
print('g1:')
d2=np.array([['Tom',1,10],['John',2,100],['Mike',3,200]])
for g1 in d2:
    print(g1)
>>> output:
    g:
		0
		1
		2
	------------------
	g1:
		['Tom' '1' '10']
		['John' '2' '100']
		['Mike' '3' '200']

END

Edit | sxlib