NumPy 基础

import numpy as np

# A NumPy array can be specified to be stored in row-major format, using the keyword
# argument order= 'C', and column-major format, using the keyword argument
# order= 'F', when the array is created or reshaped. The default format is row-major.
data = np.array([[0, 1], [1, 2], [2, 3], [3, 4]])
print('数组的维度数:', data.ndim)
print('数组中元素的总个数:', data.size)
print('数组中元素的数据类型:', data.dtype)
print('整个数组在内存中所占的字节数:', data.nbytes)
print('数组中每个元素在内存中所占的字节数:', data.itemsize)
print('获取数组的形状(各维度上元素的个数情况):', data.shape)
print('转换为 Python 内置的列表类型:', data.tolist())
# print('Numpy支持的所有数据类型:', np.sctypeDict)

data_0 = data[0]
print('数组的维度数data_0:', data_0.ndim)
print('数组中元素的总个数data_0:', data_0.size)
print('数组中元素的数据类型data_0:', data_0.dtype)
print('整个数组在内存中所占的字节数data_0:', data_0.nbytes)
print('数组中每个元素在内存中所占的字节数data_0:', data_0.itemsize)
print('获取数组的形状(各维度上元素的个数情况)data_0:', data_0.shape)
print('转换为 Python 内置的列表类型data_0:', data_0.tolist())

data_0_0 = data[0][0]
print('数组的维度数data_0_0:', data_0_0.ndim)
print('数组中元素的总个数data_0_0:', data_0_0.size)
print('数组中元素的数据类型data_0_0:', data_0_0.dtype)
print('整个数组在内存中所占的字节数data_0_0:', data_0_0.nbytes)
print('数组中每个元素在内存中所占的字节数data_0_0:', data_0_0.itemsize)
print('获取数组的形状(各维度上元素的个数情况)data_0_0:', data_0_0.shape)
print('转换为 Python 内置的列表类型data_0_0:', data_0_0.tolist())

# Once a NumPy array is created, its dtype cannot be changed, other than by creating
# a new copy with type-casted array values.
data = np.array([[0, 1], [1, 2], [2, 3], [3, 4]])
print('数组中元素的数据类型 data:', data.dtype)
print('整个数组在内存中所占的字节数 data:', data.nbytes)
print('转换为 Python 内置的列表类型 data:', data.tolist())

data2 = np.array(data, dtype = np.float64)
print('数组中元素的数据类型 data2:', data2.dtype)
print('整个数组在内存中所占的字节数 data2:', data2.nbytes)
print('转换为 Python 内置的列表类型 data2:', data2.tolist())

data3 = np.array(data, dtype = np.complex64)
print('数组中元素的数据类型 data3:', data3.dtype)
print('整个数组在内存中所占的字节数 data3:', data3.nbytes)
print('转换为 Python 内置的列表类型 data3:', data3.tolist())

data4 = data.astype(np.float32)
print('数组中元素的数据类型 data4:', data4.dtype)
print('整个数组在内存中所占的字节数 data4:', data4.nbytes)
print('转换为 Python 内置的列表类型 data4:', data4.tolist())

data5 = np.sqrt(data)  # data 是 int，但是 data5 默认是 float64 类型
print('数组中元素的数据类型 data5:', data5.dtype)
print('整个数组在内存中所占的字节数 data5:', data5.nbytes)
print('对 data 开平方后得到的数据:', data5.tolist())

# Only when the data type of the array is complex is the square root of –1 resulting in the imaginary unit
# (denoted as 1j in Python).
data6 = np.sqrt([-1 + 1j, -2 - 2j, -3 * 3j], dtype = np.complex128)
print('数组中元素的数据类型 data6:', data6.dtype)
print('整个数组在内存中所占的字节数 data6:', data6.nbytes)
print('对 data6 开平方后得到的数据:', data6.tolist())

# RuntimeWarning: invalid value encountered in sqrt
# data7 = np.sqrt([-1])

# # ValueError: setting an array element with a sequence.
# # The requested array has an inhomogeneous shape after 1 dimensions.
# # The detected shape was (5,) + inhomogeneous part.
# ragged_array = np.array([[0, 1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11], [12, 13], [14]])
# print('数组的维度数ragged_array:', ragged_array.ndim)
# print('数组中元素的总个数ragged_array:', ragged_array.size)
# print('数组中元素的数据类型ragged_array:', ragged_array.dtype)
# print('整个数组在内存中所占的字节数ragged_array:', ragged_array.nbytes)
# print('数组中每个元素在内存中所占的字节数ragged_array:', ragged_array.itemsize)
# print('获取数组的形状(各维度上元素的个数情况)ragged_array:', ragged_array.shape)
# print('转换为 Python 内置的列表类型ragged_array:', ragged_array.tolist())

#  have a ragged array created using NumPy with different-length sublists
# The dtype=object parameter is crucial here.
# When creating a ragged array (where subarrays have different lengths),
# NumPy needs to store it as an array of Python objects rather than a regular rectangular numeric array.
# Without dtype=object, NumPy would try to create a rectangular array and either:
# Pad shorter rows with zeros or NaN values
# Raise an error because the sublists have different lengths
ragged_array_2 = np.array([[0, 1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11], [12, 13], [14]], dtype = object)
print('数组的维度数ragged_array_2:', ragged_array_2.ndim)
print('数组中元素的总个数ragged_array_2:', ragged_array_2.size)
print('数组中元素的数据类型ragged_array_2:', ragged_array_2.dtype)
print('整个数组在内存中所占的字节数ragged_array_2:', ragged_array_2.nbytes)
print('数组中每个元素在内存中所占的字节数ragged_array_2:', ragged_array_2.itemsize)
print('获取数组的形状(各维度上元素的个数情况)ragged_array_2:', ragged_array_2.shape)
print('转换为 Python 内置的列表类型ragged_array_2:', ragged_array_2.tolist())

special_limit_value = {
    'np.inf': np.inf,
    'np.e': np.e,
    'np.pi': np.pi
}
print(special_limit_value)

zeros_data = np.zeros(shape = (3, 4), dtype = int)
print('zeros_data:', zeros_data.tolist())

ones_data = np.ones(shape = (3, 4), dtype = int)
print('ones_data:', ones_data.tolist())

multi_ones_data = 1.1 * np.ones(shape = (3, 4), dtype = float)
print('multi_ones_data:', multi_ones_data.tolist())

another_multi_ones_data = np.full(shape = (3, 4), fill_value = 10, dtype = int)
print('another_multi_ones_data:', another_multi_ones_data.tolist())

# To construct a matrix with an arbitrary one-dimensional array on the diagonal, we
# can use the np.diag function (which also takes the optional keyword argument k to
# specify an offset from the diagonal)
diag_data = np.diag([1, 2, 3])
print('diag_data:', diag_data.tolist())

range_data = np.arange(1, 20, 3)
print('range_data:', range_data.tolist())

lin_space_data = np.linspace(1, 20, 7)
print('lin_space_data:', lin_space_data.tolist())

# This creates 7 numbers between 10¹ and 10²⁰, where:
# The first parameter (1) is the start exponent
# The second parameter (20) is the end exponent
# The third parameter (7) is the number of points to generate
# By default, it uses base 10
# so the numbers are spaced evenly in powers of 10
log_space_data = np.logspace(1, 20, 7, base = 10)
print('log_space_data:', log_space_data.tolist())

# To create an array of specific size and data type, but without initializing the elements in
# the array to any particular values, we can use the function np.empty
# If all elements are guaranteed to be initialized later in the code, this can save a little bit of time,
# especially when working with large arrays.
uninitialized_data = np.empty(shape = (10, 10), dtype = np.int8)
print('uninitialized_data:', uninitialized_data.tolist())

# It is often necessary to create new arrays that share properties, such as shape and data
# type, with another array. NumPy provides a family of functions for this purpose: np.
# ones_like, np.zeros_like, np.full_like, and np.empty_like.
ones_like_data = np.ones_like(uninitialized_data)
print('ones_like_data:', ones_like_data.tolist())

zeros_like_data = np.zeros_like(uninitialized_data)
print('zeros_like_data:', zeros_like_data.tolist())

full_like_data = np.full_like(uninitialized_data, 1)
print('zeros_like_data:', full_like_data.tolist())

empty_like_data = np.empty_like(uninitialized_data)
print('empty_like_data:', empty_like_data.tolist())

# the function np.identity generates a square matrix with ones on the diagonal
# and zeros elsewhere
diagonal_data = np.identity(n = 5, dtype = int)
print('diagonal_data:', diagonal_data.tolist())


eye_data = np.eye(N = 5, k = 1)
print('eye_data:', eye_data.tolist())
eye_data = np.eye(N = 5, k = -1)
print('eye_data:', eye_data.tolist())