NumPy Bitwise Operations#

Bitwise operations are a class of operations that perform on binary numbers at the bit level, directly manipulating the individual bits of binary representations without regard to the overall value.

Bitwise operations are widely used in computer science for optimization and handling of low-level data.

NumPy “bitwise_” prefixed functions are bitwise operation functions.

NumPy bitwise operations include the following functions:

1
import numpy as np
2

3
arr1 = np.array([True, False, True], dtype=bool)
4
arr2 = np.array([False, True, False], dtype=bool)
5

6
result_and = np.bitwise_and(arr1, arr2)
7
result_or = np.bitwise_or(arr1, arr2)
8
result_xor = np.bitwise_xor(arr1, arr2)
9
result_not = np.bitwise_not(arr1)
10

11
print("AND:", result_and)  # [False, False, False]
12
print("OR:", result_or)    # [True, True, True]
13
print("XOR:", result_xor)  # [True, True, True]
14
print("NOT:", result_not)  # [False, True, False]
15

16
# Bitwise NOT
17
arr_invert = np.invert(np.array([1, 2], dtype=np.int8))
18
print("Invert:", arr_invert)  # [-2, -3]
19

20
# Left shift
21
arr_left_shift = np.left_shift(5, 2)
22
print("Left Shift:", arr_left_shift)  # 20
23

24
# Right shift
25
arr_right_shift = np.right_shift(10, 1)
26
print("Right Shift:", arr_right_shift)  # 5

String Functions#

The following functions operate on arrays with dtype numpy.string_ or numpy.unicode_ to perform vectorized string operations. They are based on the standard string functions in the Python standard library.

These functions are defined in the character array class (numpy.char).

• numpy.char.add()/multiply()/center()

The numpy.char.add() function concatenates the elements of two arrays element-wise.

1
import numpy as np
2

3
print ('Concatenating two strings:')
4
print (np.char.add(['hello'],[' xyz']))
5
print ('\\n')
6

7
print ('Concatenation examples:')
8
print (np.char.add(['hello', 'hi'],[' abc', ' xyz']))
9

10
print (np.char.multiply('Runoob ',3))
11

12
# np.char.center(str , width,fillchar) ：
13
# str: string, width: length, fillchar: fill character
14
print (np.char.center('Runoob', 20,fillchar = '*'))

• numpy.char.capitalize()/title()/lower()/upper()

1
import numpy as np
2

3
print (np.char.capitalize('runoob'))
4

5
print (np.char.capitalize('runoob'))
6

7
# operate on arrays
8
print (np.char.lower(['RUNOOB','GOOGLE']))
9

10
# operate on strings
11
print (np.char.lower('RUNOOB'))

• numpy.char.split()/splitlines()/strip()

numpy.char.split() splits strings by a specified separator and returns an array. By default, the separator is a space.

1
import numpy as np
2

3
# Separator defaults to space
4
print (np.char.split ('i like runoob?'))
5
# Separator is .
6
print (np.char.split ('www.runoob.com', sep = '.'))
7

8
# Newline characters \\n
9
# \\n, \\r, \\r\\n can all be used as line breaks.
10
print (np.char.splitlines('i\\nlike runoob?'))
11
print (np.char.splitlines('i\\rlike runoob?'))
12

13
# Remove the leading and trailing 'a' from the string
14
print (np.char.strip('ashok arunooba','a'))
15

16
# Remove the leading and trailing 'a' from array elements
17
print (np.char.strip(['arunooba','admin','java'],'a'))

• numpy.char.join()/replace()/encode()/decode()

numpy.char.join() function joins the elements of an array or strings using a specified separator.

1
import numpy as np
2

3
# operate on strings
4
print (np.char.join(':','runoob'))
5

6
# operate on multiple separators for array elements
7
print (np.char.join([':','-'],['runoob','google']))
8

9
print (np.char.replace ('i like runoob', 'oo', 'cc'))
10

11
a = np.char.encode('runoob', 'cp500')
12
print (a)
13

14
print (np.char.decode(a,'cp500'))

NumPy Mathematical Functions#

1
import numpy as np
2

3
a = np.array([0,30,45,60,90])
4
print ('Sine values for different angles:')
5
# Convert to radians by multiplying pi/180
6
print (np.sin(a*np.pi/180))
7
print ('\\n')
8
print ('Cosine values for angles in the array:')
9
print (np.cos(a*np.pi/180))
10
print ('\\n')
11
print ('Tangent values for angles in the array:')
12
print (np.tan(a*np.pi/180))

1
import numpy as np
2

3
a = np.array([0,30,45,60,90])
4
print ('Array with sine values:')
5
sin = np.sin(a*np.pi/180)
6
print (sin)
7
print ('\\n')
8
print ('Inverse sine of the angles, result in radians:')
9
inv = np.arcsin(sin)
10
print (inv)
11
print ('\\n')
12
print ('Check the result by converting back to degrees:')
13
print (np.degrees(inv))
14
print ('\\n')
15
print ('Inverse cosine and arctan behave similarly:')
16
cos = np.cos(a*np.pi/180)
17
print (cos)
18
print ('\\n')
19
print ('Arccosine:')
20
inv = np.arccos(cos)
21
print (inv)
22
print ('\\n')
23
print ('Angle in degrees:')
24
print (np.degrees(inv))
25
print ('\\n')
26
print ('Tangent:')
27
tan = np.tan(a*np.pi/180)
28
print (tan)
29
print ('\\n')
30
print ('Inverse tangent:')
31
inv = np.arctan(tan)
32
print (inv)
33
print ('\\n')
34
print ('Angle in degrees:')
35
print (np.degrees(inv))

Arithmetic Functions#

NumPy arithmetic functions include simple addition, subtraction, multiplication, and division: add(), subtract(), multiply() and divide().

Note that arrays must have the same shape or be broadcastable.

1
import numpy as np
2

3
a = np.arange(9, dtype = np.float_).reshape(3,3)
4
print ('First array:')
5
print (a)
6
print ('\\n')
7
print ('Second array:')
8
b = np.array([10,10,10])
9
print (b)
10
print ('\\n')
11
print ('Addition of the two arrays:')
12
print (np.add(a,b))
13
print ('\\n')
14
print ('Subtraction of the two arrays:')
15
print (np.subtract(a,b))
16
print ('\\n')
17
print ('Multiplication of the two arrays:')
18
print (np.multiply(a,b))
19
print ('\\n')
20
print ('Division of the two arrays:')
21
print (np.divide(a,b))

• numpy.reciprocal()

  numpy.reciprocal() returns the reciprocal of each element in the input array. For example, the reciprocal of 1/4 is 4/1.

  1
  import numpy as np
  2
  
  3
  a = np.array([0.25,  1.33,  1,  100])
  4
  print ('Our array:')
  5
  print (a)
  6
  print ('\\n')
  7
  print ('Calling reciprocal function:')
  8
  print (np.reciprocal(a))

• numpy.power()

  numpy.power() takes the elements in the first input array as bases and raises them to the powers of the corresponding elements in the second input array.

  1
  import numpy as np
  2
  
  3
  a = np.array([10,100,1000])
  4
  print ('Our array:')
  5
  print (a)
  6
  print ('\\n')
  7
  print ('Calling power function:')
  8
  print (np.power(a,2))
  9
  print ('\\n')
  10
  print ('Second array:')
  11
  b = np.array([1,2,3])
  12
  print (b)
  13
  print ('\\n')
  14
  print ('Calling power function again:')
  15
  print (np.power(a,b))

• numpy.mod()

  numpy.mod() computes the remainder after division for corresponding elements in the input arrays. The numpy.remainder() function produces the same result.

  1
  import numpy as np
  2
  
  3
  a = np.array([10,20,30])
  4
  b = np.array([3,5,7])
  5
  print ('First array:')
  6
  print (a)
  7
  print ('\\n')
  8
  print ('Second array:')
  9
  print (b)
  10
  print ('\\n')
  11
  print ('Calling mod() function:')
  12
  print (np.mod(a,b))
  13
  print ('\\n')
  14
  print ('Calling remainder() function:')
  15
  print (np.remainder(a,b))

Statistical Functions#

• numpy.amin() and numpy.amax()

  numpy.amin() is used to compute the minimum value of elements in an array along a specified axis.

  1
  numpy.amin(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
  2
  
  3
  # Parameter descriptions:
  4
  #     a: input array, can be a NumPy array or array-like object.
  5
  #     axis: optional parameter to specify along which axis to compute the minimum. If not provided, returns the minimum of the entire array. Can be an integer or a tuple of axes.
  6
  #     out: optional parameter for the output storage.
  7
  #     keepdims: optional parameter; if True, keeps the number of dimensions of the result the same as input. If False (default), reduces axes of length 1.
  8
  #     initial: optional parameter to specify an initial value for the minimum calculation.
  9
  #     where: optional boolean array to specify which elements to consider.

  numpy.amax() is used to compute the maximum value along a specified axis of the array.

  1
  numpy.amax(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
  2
  
  3
  # Parameter descriptions:
  4
  #     a: input array, can be a NumPy array or array-like object.
  5
  #     axis: optional parameter to specify along which axis to compute the maximum. If not provided, returns the maximum of the entire array. Can be an integer or a tuple of axes.
  6
  #     out: optional parameter for the output storage.
  7
  #     keepdims: optional parameter; if True, keeps the number of dimensions of the result the same as input. If False (default), reduces axes of length 1.
  8
  #     initial: optional parameter to specify an initial value for the maximum calculation.
  9
  #     where: optional boolean array to specify which elements to consider.

1
import numpy as np
2

3
a = np.array([[3,7,5],[8,4,3],[2,4,9]])
4
print ('Our array is:')
5
print (a)
6
print ('\\n')
7
print ('Calling amin() function:')
8
print (np.amin(a,1))
9
print ('\\n')
10
print ('Calling amin() again:')
11
print (np.amin(a,0))
12
print ('\\n')
13
print ('Calling amax() function:')
14
print (np.amax(a))
15
print ('\\n')
16
print ('Calling amax() again:')
17
print (np.amax(a, axis =  0))

• numpy.ptp()

  numpy.ptp() computes the difference between the maximum and minimum values in the array (max - min).

  1
  numpy.ptp(a,axis=None,out=None,keepdims=<no value>,initial=<no value>,where=<no value>)
  2
  
  3
  # Parameter descriptions:
  4
  #     a: input array, can be a NumPy array or array-like object.
  5
  #     axis: optional parameter; specify axis for peak-to-peak value. If not provided, returns the peak-to-peak of the entire array. Can be an integer or a tuple of axes.
  6
  #     out: optional parameter for the output storage.
  7
  #     keepdims: optional parameter; if True, keeps the dimensions. If False (default), reduces axes of length 1.
  8
  #     initial: optional parameter for an initial value.
  9
  # where: optional boolean array to specify which elements to consider.
  10
  
  11
  import numpy as np
  12
  
  13
  a = np.array([[3,7,5],[8,4,3],[2,4,9]])
  14
  print ('Our array:')
  15
  print (a)
  16
  print ('\\n')
  17
  print ('Calling ptp() function:')
  18
  print (np.ptp(a))
  19
  print ('\\n')
  20
  print ('Along axis 1:')
  21
  print (np.ptp(a, axis =  1))
  22
  print ('\\n')
  23
  print ('Along axis 0:')
  24
  print (np.ptp(a, axis =  0))

• numpy.percentile()

  Percentiles are metrics used in statistics that indicate the percentage of observations below this value. The function numpy.percentile() accepts the following parameters.

  First, the percentile:
  The p-th percentile is a value such that at least p% of the data items are less than or equal to this value, and at least (100-p)% are greater than or equal to this value.
  For example, college entrance exam results are often reported in percentiles. Suppose a candidate’s raw score in the Chinese section is 54. Relative to others, it is not easy to judge. But if a raw score of 54 corresponds to the 70th percentile, we know about 70% of students scored below him and about 30% scored above him.
  Here p = 70.

1
numpy.percentile(a, q, axis)
2

3
# Parameter descriptions:
4
#     a: input array
5
#     q: percentiles to compute, in the range 0 ~ 100
6
#     axis: axis along which to compute the percentiles
7

8
import numpy as np
9

10
a = np.array([[10, 7, 4], [3, 2, 1]])
11
print ('Our array:')
12
print (a)
13

14
print ('Calling percentile() function:')
15
# 50% percentile is the median of a after sorting
16
print (np.percentile(a, 50))
17

18
# axis 0, along columns
19
print (np.percentile(a, 50, axis=0))
20

21
# axis 1, along rows
22
print (np.percentile(a, 50, axis=1))
23

24
# keep dimensions
25
print (np.percentile(a, 50, axis=1, keepdims=True))

• numpy.median()

  numpy.median() is used to compute the median of the elements in array a.

  1
  numpy.median(a, axis=None, out=None, overwrite_input=False, keepdims=<no value>)
  2
  
  3
  # Parameter descriptions:
  4
  #     a: input array, can be a NumPy array or array-like object.
  5
  #     axis: optional parameter to specify along which axis to compute the median. If not provided, computes the median of the entire array. Can be an integer or a tuple of axes.
  6
  #     out: optional parameter for the output storage.
  7
  #     overwrite_input: optional parameter; if True, allows using the input array's memory in the computation. This may improve performance in some cases, but may modify the input array.
  8
  #     keepdims: optional parameter; if True, keeps the dimensionality of the result the same as the input array. If False (default), reduces axes of length 1.
  9
  
  10
  import numpy as np
  11
  
  12
  a = np.array([[30,65,70],[80,95,10],[50,90,60]])
  13
  print ('Our array:')
  14
  print (a)
  15
  print ('\\n')
  16
  print ('Calling median() function:')
  17
  print (np.median(a))
  18
  print ('\\n')
  19
  print ('Along axis 0:')
  20
  print (np.median(a, axis =  0))
  21
  print ('\\n')
  22
  print ('Along axis 1:')
  23
  print (np.median(a, axis =  1))

• numpy.mean()

  numpy.mean() returns the arithmetic mean of the elements in the array. If an axis is provided, it computes along that axis.

  The arithmetic mean is the sum of the elements along the axis divided by the number of elements.

  1
  numpy.mean(a, axis=None, dtype=None, out=None, keepdims=<no value>)
  2
  
  3
  # Parameter descriptions:
  4
  
  5
  # a: input array, can be a NumPy array or array-like object.
  6
  # axis: optional parameter to specify along which axis to compute the mean. If not provided, computes the mean of the entire array. Can be an integer or a tuple of axes.
  7
  # dtype: optional parameter to specify the output data type. If not provided, an appropriate dtype is chosen based on the input data.
  8
  # out: optional parameter to specify the output storage.
  9
  # keepdims: optional parameter; if True, keeps the dimensions of the result the same as the input; if False (default), reduces axes of length 1.

• numpy.average()

  numpy.average() computes the weighted average of array elements using the corresponding weights provided in another array.

  This function can accept an axis parameter. If no axis is specified, the array is flattened.

  A weighted average is obtained by multiplying each value by its corresponding weight, summing them, and dividing by the total weight.

  1
  numpy.average(a, axis=None, weights=None, returned=False)
  2
  
  3
  # Parameter descriptions：
  4
  # a: input array, can be a NumPy array or array-like object.
  5
  # axis: optional parameter to specify along which axis to compute the weighted average. If not provided, computes the weighted average of the entire array. Can be an integer or a tuple of axes.
  6
  # weights: optional parameter to specify the weights for data points. If weights are not provided, equal weights are assumed.
  7
  # returned: optional parameter; if True, returns the weighted average and the sum of weights.
  8
  
  9
  import numpy as np
  10
  
  11
  a = np.array([1,2,3,4])
  12
  print ('Our array:')
  13
  print (a)
  14
  print ('\\n')
  15
  print ('Calling average() function:')
  16
  print (np.average(a))
  17
  print ('\\n')
  18
  # If weights are not specified, equivalent to mean
  19
  wts = np.array([4,3,2,1])
  20
  print ('Calling average() again:')
  21
  print (np.average(a,weights = wts))
  22
  print ('\\n')
  23
  # If returned is true, also return the sum of weights
  24
  print ('Sum of weights:')
  25
  print (np.average([1,2,3,  4],weights =  [4,3,2,1], returned =  True))
  26
  
  27
  # In a multi-dimensional array, you can specify the axis to compute on.
  28
  a = np.arange(6).reshape(3,2)
  29
  print ('Our array:')
  30
  print (a)
  31
  print ('\\n')
  32
  print ('Modified array:')
  33
  wt = np.array([3,5])
  34
  print (np.average(a, axis =  1, weights = wt))
  35
  print ('\\n')
  36
  print ('Modified array:')
  37
  print (np.average(a, axis =  1, weights = wt, returned =  True))

• Standard Deviation

  Standard deviation is a measure of the dispersion of a set of data around its mean.

  The standard deviation is the square root of the variance.

  std = sqrt(mean((x - x.mean())^2))

  1
  import numpy as np
  2
  
  3
  print (np.std([1,2,3,4]))

• Variance

  The variance (sample variance) in statistics is the average of the squared differences between each sample value and the mean of all samples, i.e., mean((x - x.mean())** 2).

  In other words, the standard deviation is the square root of the variance.

  1
  import numpy as np
  2
  
  3
  print (np.var([1,2,3,4]))

NumPy Sorting and Filtering Functions#

NumPy provides several sorting methods. These sorting functions implement different sorting algorithms, each characterized by speed, worst-case performance, required workspace, and stability. The table below compares three sorting algorithms.

• numpy.sort()

  numpy.sort() function returns a sorted copy of the input array. The function signature is:

  1
  numpy.sort(a, axis, kind, order)
  2
  
  3
  # Parameter descriptions:
  4
  #     a: array to be sorted
  5
  #     axis: axis along which to sort the array; if the array is flat, it is flattened, sorting along the last axis
  6
  #     kind: defaults to 'quicksort'
  7
  #     order: if the array has fields, the field to sort by

• numpy.argsort()

  numpy.argsort() returns the indices that would sort the array values in ascending order.

1
import numpy as np
2

3
x = np.array([3,  1,  2])
4
print ('Our array:')
5
print (x)
6
print ('\\n')
7
print ('Calling argsort() on x:')
8
y = np.argsort(x)
9
print (y)
10
print ('\\n')
11
print ('Reconstruct the original array in sorted order:')
12
print (x[y])

• numpy.lexsort()

  numpy.lexsort() sorts multiple sequences. Think of it as sorting a spreadsheet where each column represents a sequence, with sorting given priority to the later columns.

1
import numpy as np
2

3
nm =  ('raju','anil','ravi','amar')
4
dv =  ('f.y.',  's.y.',  's.y.',  'f.y.')
5
ind = np.lexsort((dv,nm))
6
print ('Calling lexsort() function:')
7
print (ind)
8
print ('\\n')
9
print ('Using this index to get the sorted data:')
10
print ([nm[i]  +  ", "  + dv[i]  for i in ind])

• msort、sort_complex、partition、argpartition

• numpy.argmax() and numpy.argmin()

  numpy.argmax() and numpy.argmin() return the indices of the maximum and minimum elements along the given axis, respectively.

• numpy.nonzero()

  numpy.nonzero() returns the indices of the non-zero elements in the input array.

• numpy.where()

  numpy.where() returns the indices of elements in the input array that satisfy a given condition.

• numpy.extract()

  numpy.extract() extracts elements from an array that satisfy a condition and returns them.

NumPy Byte Swapping#

On almost all machines, multi-byte objects are stored as a contiguous sequence of bytes. Endianness is the storage rule for multi-byte program objects.

• Big-endian: the high-order byte is stored at the low memory address, and the low-order byte at the high memory address; this storage pattern is somewhat like treating data as a string: addresses increase from low to high, and the data is placed from high to low; this matches our reading habit.
• Little-endian: the high-order byte is stored at the high memory address, and the low-order byte at the low memory address; this storage pattern effectively combines address order and data significance, with high-address parts having high weight and low-address parts having low weight.

numpy.ndarray.byteswap() swaps the byte order of every element in the ndarray.

1
import numpy as np
2

3
A = np.array([1, 256, 8755], dtype=np.int16)
4
print(A)
5
print(list(map(hex, A)))
6
print(A.byteswap(inplace=True))
7
print(list(map(hex, A)))

Views or Shallow Copy#

ndarray.view() creates a new array object; the view’s shape changes do not affect the original data.

1
import numpy as np
2

3
# Initially a is a 3x2 array
4
a = np.arange(6).reshape(3,2)
5
print ('Array a:')
6
print (a)
7
print ('Create a view of a:')
8
b = a.view()
9
print (b)
10
print ('Different id() for a and b:')
11
print ('a id():')
12
print (id(a))
13
print ('b id():')
14
print (id(b))
15
# Modifying b's shape does not modify a
16
b.shape =  2,3
17
print ('b shape:')
18
print (b)
19
print ('a shape:')
20
print (a)
21

22
# Slicing to create views modifies data and affects the original array:
23
arr = np.arange(12)
24
print ('Our array:')
25
print (arr)
26
print ('Create slices:')
27
a=arr[3:]
28
b=arr[3:]
29
a[1]=123
30
b[2]=234
31
print(arr)
32
print(id(a),id(b),id(arr[3:]))

Copies or Deep Copy#

ndarray.copy() creates a copy. Modifications to the copy do not affect the original data; they do not share memory.

1
import numpy as np
2

3
a = np.array([[10,10],  [2,3],  [4,5]])
4
print ('Array a:')
5
print (a)
6
print ('Create a deep copy of a:')
7
b = a.copy()
8
print ('Array b:')
9
print (b)
10
# b and a do not share any content
11
print ('Can we write to b to write to a?')
12
print (b is a)
13
print ('Modify b:')
14
b[0,0]  =  100
15
print ('Modified array b:')
16
print (b)
17
print ('a remains unchanged:')
18
print (a)

Transpose Matrix#

NumPy not only supports the numpy.transpose function to swap the array’s axes, but also supports the T attribute.

For example, for a matrix with m rows and n columns, using the T attribute converts it to an n-by-m matrix.

1
import numpy as np
2

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

5
print ('Original array:')
6
print (a)
7
print ('\\n')
8

9
print ('Transposed array:')
10
print (a.T)

matlib.empty()#

matlib.empty() function returns a new matrix, with the syntax:

1
numpy.matlib.empty(shape, dtype, order)
2

3
# Parameter explanations:
4
#     shape: integer or tuple of integers defining the new matrix shape
5
#     Dtype: optional, data type
6
#     order: C (row-major) or F (column-major)
7

8
import numpy.matlib
9
import numpy as np
10

11
print (np.matlib.empty((2,2)))
12
# Fill with random data

numpy.matlib.zeros()#

numpy.matlib.zeros() function creates a matrix filled with zeros.

1
import numpy as np
2

3
print (np.matlib.zeros((2,2)))

numpy.matlib.ones()#

numpy.matlib.ones() function creates a matrix filled with ones.

1
import numpy.matlib
2
import numpy as np
3

4
print (np.matlib.ones((2,2)))

numpy.matlib.eye()#

numpy.matlib.eye() function returns a matrix with 1s on the diagonal and zeros elsewhere.

1
numpy.matlib.eye(n, M,k, dtype)
2

3
# Parameter explanations:
4
#     n: number of rows to return
5
#     M: number of columns to return, default is n
6
#     k: index of the diagonal
7
#     dtype: data type
8

9
import numpy.matlib
10
import numpy as np
11

12
print (np.matlib.eye(n =  3, M =  4, k =  0, dtype =  float))

numpy.matlib.identity()#

numpy.matlib.identity() function returns the identity matrix of a given size.

The identity matrix is a square matrix with 1s on the main diagonal from the top-left to the bottom-right, and 0s elsewhere.

1
import numpy.matlib
2
import numpy as np
3

4
# Size 5, type is floating point
5
print (np.matlib.identity(5, dtype =  float))

numpy.matlib.rand()#

numpy.matlib.rand() function creates a matrix of a given size with random data.

1
import numpy.matlib
2
import numpy as np
3

4
print (np.matlib.rand(3,3))
5

6
# Matrices are always two-dimensional, while ndarray is an n-dimensional array. Both objects are interchangeable.
7
import numpy.matlib
8
import numpy as np
9

10
i = np.matrix('1,2;3,4')
11
print (i)
12

13
j = np.asarray(i)
14
print (j)
15

16
k = np.asmatrix (j)
17
print (k)

Using Chinese#

Matplotlib does not support Chinese by default, and we can resolve this with the following simple method.

1. Download Source Han Sans
2. Put the downloaded OTF font into the code directory
3. matplotlib.font_manager.FontProperties(fname="SourceHanSansSC-Bold.otf") fname specifies the font path

1
import numpy as np
2
from matplotlib import pyplot as plt
3
import matplotlib
4

5
# fname is the path to your downloaded font library; note SourceHanSansSC-Bold.otf path
6
zhfont1 = matplotlib.font_manager.FontProperties(fname="SourceHanSansSC-Bold.otf")
7

8
x = np.arange(1,11)
9
y =  2  * x +  5
10
plt.title("菜鸟教程 - 测试", fontproperties=zhfont1)
11

12
# fontproperties sets Chinese display, fontsize sets font size
13
plt.xlabel("x 轴", fontproperties=zhfont1)
14
plt.ylabel("y 轴", fontproperties=zhfont1)
15
plt.plot(x,y)
16
plt.show()