NumPy 学习笔记（一）

NumPy：

　　1、NumPy 是一个功能强大的第三方库（需要自己安装），主要用于对多维数组执行计算；

　　　  它提供了大量的库函数和操作，可以帮助程序员更轻松地进行数值计算

　　2、可以和另外两个第三方库 SciPy 和 Matplotlib 一起使用从而在一定程度上替换对 Matlab 的使用

　　3、主要应用：

　　　　①数学运算：NumPy 对于执行各种数学运算非常有用，如数值积分、微分、内插、外推以及矩阵的内积、外积、特征向量等。

　　　　②图像处理和计算机图形学：计算机中的图像表示为多维数字数组。NumPy 成为同样情况下最自然的选择。

　　　　    实际上，NumPy 提供了一些优秀的库函数来快速处理图像。例如，镜像图像、按特定角度旋转图像等

　　　　③机器学习模型：在编写机器学习算法时，需要对矩阵进行各种数值计算。例如矩阵乘法、换位、加法等

NumPy 数组：

　　1、NumPy 提供最重要的数据结构是一个称为 ndarray 的 N 维数组类型。 它描述相同类型的元素集合，NumPy 数组是通常的 Python 数组的扩展

　　　  ndarray 配备了大量的函数和运算符，可以帮助我们快速编写各种类型计算的高性能代码，每个元素在内存中使用相同大小的块

　　2、NumPy 数组的创建方法：

　　　　①从其他 python 数据类型（如：列表、元组等）转换过来

　　　　②NumPy 原生数组的创建（通过 arange、ones、zeros 等创建）

　　　　③使用特殊库函数（例如，random）创建

　　　　④从磁盘读取数组，无论是标准格式还是自定义格式

　　　　⑤通过使用字符串或缓冲区从原始字节创建数组

import numpy as np

lst = [1, 2, 3]
arr = np.array(lst)
# 输出 Type:  <class 'numpy.ndarray'>
#      arr:  [1 2 3]
print("Type: ", type(arr), "\narr: ", arr)

# numpy.arange(star, end, step) 返回 [star, end) 隔 step-1 的各个元素
# 输出 [1 3 5 7 9]
arr = np.arange(1, 10, 2)
print("arr", arr, sep=" = ")

# numpy.random.randn(size) 创建一个长度为 size 的服从标准正态分布的随机数组
arr = np.random.randn(5)
print("arr: ", arr)
# numpy.random.random(size) 创建一个范围为 [0, 1)，长度为 size 的服从均匀分布的随机数组
arr = np.random.random(5)
print("arr: ", arr)

# numpy.linspace(star, end, size) 创建一个长度为 size，范围为 [star, end] 的数组
# 输出 [0.  2.5  5.  7.5  10.]
arr = np.linspace(0, 10, 5)
print("arr: ", arr)

# numpy.zeros(shape) 创建一个用 0 填充，形状为 shape 的数组
a = np.zeros((2, 2))
print("a", a, sep=" = ")

b = np.ones((2, 2))
print("b", b, sep=" = ")

c = np.full((2, 2), 7)  # 创建一个 2*2 矩阵，并填充 7
print("c", c, sep=" = ")

d = np.eye(3)  # 创建一个 3*3 的单位矩阵
print("d", d, sep=" = ")

注：np.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0) 里，

　　object 表示任何暴露数组接口方法的对象都会返回一个数组或任何（嵌套）序列；

　　dtype 为数组的数据类型，可选；copy 可选，默认为true，表示对象是否被复制；order 里 C（按行）、F（按列）或A（任意，默认）；

　　subok 默认情况下，返回的数组被强制为基类数组。 如果为true，则返回子类；ndmin 指定返回数组的最小维数

import numpy as np

# 本来是一个一维数组，但通过 ndmin=2 使得数组最小维度为2维
# 输出 arr: [[1 2 3 4]] 注意为 2 维数组
arr = np.array([1, 2, 3, 4], ndmin=2)
print("arr", arr, sep=": ")
# 输出 arr: [[1 2] [3 4]]，因为其维度大于最小维度
arr = np.array([[1, 2], [3, 4]], ndmin=1)
print("arr", arr, sep=": ")

# 指定数据类型为复数
arr = np.array([1, 2, 3], dtype=complex)
# 输出 arr: [1.+0.j  2.+0.j  3.+0.j]
print("arr", arr, sep=": ")

　　3、数组属性：

　　　　①shape：返回数组形状，如 (2, 3) 表示 2 行 3 列的 2 维数组

　　　　②ndim：返回数组维度

　　　　③size：返回数组里元素个数

　　　　④itemsize：返回数组中每个元素的字节单位长度

　　　　⑤T：转置矩阵，但不会改变原矩阵

　　　　⑥flags：返回对象的内存信息

　　　　⑦real：返回元素的实部

　　　　⑧imag：返回元素的虚部

　　　　⑨data：包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性

import numpy as np

# shape 这一数组属性返回一个包含数组维度的元组，它也可以用于调整数组大小
arr = np.array([[1, 2, 3], [4, 5, 6]])
arr_t = arr[:, 2]
# 输出列号为 2 的所有元素，即 [3, 6]
print("arr_t[][2]: ", arr_t)
# 输出数组形状，这里为 (2, 3)
print("The arr's shape: ", arr.shape)
arr.shape = (3, 2)      # 修改形状为 3 行 2 列，注意形状和元素个数
print("The new arr: ", arr)
# 也可以通过 reshape() 函数来调整大小，但不会改变原数组
temp = arr.reshape(2, 3)
print(temp)     # 2 维数组，且数组里有 3 个元素

# ndim 属性返回数组维度
arr = np.arange(24)     # 创建 [0...23] 的数组
print(arr.ndim)     # 输出 1
arr.shape = (2, 4, 3)   # 修改为 3 维数组
print("arr's ndim: ", arr.ndim)     # 输出 3

# itemsize 这一数组属性返回数组中每个元素的字节单位长度
arr = np.array([1, 2, 3, 4, 5])
print("size: ", arr.size)
print("itemsize: ", arr.itemsize)     # 输出 4（整数默认为 4 字节）

# dtype 返回数组元素类型
print("dtype: ", arr.dtype)     # 输出 dtype: int32(即 4 字节)
arr.dtype = np.int8     # 修改整数类型
print("itemsize: ", arr.itemsize)     # 输出 1

arr = np.array([[1, 2, 3], [4, 5, 6]])
# 调用矩阵的 T 属性，可以转置这个矩阵，但不会改变原矩阵
print("translate arr: ", arr.T)
print("arr: ", arr)

# 输出元素的实虚部
arr = np.array([1+2j, 2+3j, 3+4j])
print("arr's real: ", arr.real)     # 输出 [1. 2. 3.]
print("arr's imag: ", arr.imag)     # 输出 [2. 3. 4.]

# 输出对象的内存信息
print(arr.flags)

　　　　4、数组的简单运算：

　　　　　　大部分数学运算均只对在相应元素进行，如运算四则运算加减乘除，并且运算支持广播

　　　　　　（即不同形状的数组如果符合某种条件则可以进行运算）！

　　　　　　若要进行矩阵乘法则需要函数 dot() 或运算符 @

import numpy as np

arr_one = np.array([[1.0, 2.0], [3.0, 4.0]])
arr_two = np.array([[5.0, 6.0], [7.0, 8.0]])
# 四则运算时对应元素进行运算
sum = arr_one + arr_two
dif = arr_one - arr_two
mul = arr_one * arr_two
quo = arr_one / arr_two
matrix_product = arr_one.dot(arr_two)       # 矩阵乘法
print(("sum: ", sum), ("dif: ", dif), ("mul: ", mul), ("quo: ", quo), sep="\n")
print("matrix_product: ", matrix_product)
# 大小比较也是通过对应元素进行的
print("arr_one < arr_two = ", arr_one < arr_two)
print("arr_one ** 2", arr_one ** 2, sep=" = ")
# @ 可以用于矩阵乘法
print("matrix_product: ", arr_one @ arr_two)