线性代数核心概念与NumPy科学计算实战全解析

前言

学习方法：

思维导图，梳理

多记忆，函数名和功能，参数

学会应用，不要钻牛角尖

---

一、浅解线性代数

1.1标量

标量是一个只有大小没有方向的量。在数学上，标量通常表示为一个普通的数字，如‌质量、‌长度、时间、温度

标量的运算遵循基本的代数运算，如：加减乘除等

---

1.2 向量

1.2.1 定义

向量是一个有方向和大小的量。向量的起点称为原点，终点称为向量的端点‌，向量的长度（或模）是起点和终点之间的距离

---

1.2.2 向量的几种表现方式

1.2.2.1 在几何中

向量可以用有向线段来表示，有向线段的长度表示向量的大小，有向线段的方向表示向量的方向。通常将有向线段不带箭头的端点称为向量的起点（或始点），带箭头的端点称为向量的终点。例如，始点为A、终点为B的有向线段表示的向量可以用来表示

---

1.2.2.2 在空间直角坐标中

在二维或三维空间中，向量可以用坐标来表示，例如，二维向量v=(v1,v2)表示在x轴和y轴上的分量；三维向量v=(v1,v2,v3)表示在x轴、y轴和z轴上的分量‌

---

1.2.2.3 在数学中

在数学中，向量通常表示为有序数组，可以是列向量（column vector）或行向量（row vector）。在数学上，列向量通常表示为一个 n×1 矩阵，而行向量表示为一个 1×n 矩阵

在 Python 中，向量可以用多种方式表示，最常见的是使用列表（list）、元组(tuple)或 NumPy 数组，列表是可变的，而元组是不可变的

---

1.2.3 向量的运算

1.2.3.1 向量的大小

向量的大小也就是向量的长度(或称模)。向量a的模记作|a|

向量的模是非负实数。例如：向量 ，则

向量的模是可以比较大小的。

---

1.2.3.2 加减运算

前提：当两个向量进行加减操作时，两个向量必须是同维向量

如a=(a1,a2,....,an)和b=(b1,b2,....,bn)

两个向量相加：a+b=(a1+b1, a2+b2, ...., an+bn)

两个向量相减：a-b=(a1-b1, a2-b2, ...., an-bn)

---

1.2.3.3 乘法

向量的乘法分为两种，一种是标量乘以向量，也就是向量的数乘，另一种是向量乘以向量，又分为内积和外积。

向量的数乘

数乘就是使用一个标量乘以向量，其核心本质就是对向量的大小和方向进行改变。

如：a=(1, 1) , 2*a=(2*1, 2*1)=(2, 2)，-2*a=(-2*1, -2*1)=(-2, -2)

向量的内积

两个向量相乘的结果是一个标量，这就叫向量的内积或点积，使用 · 作为运算符

如：a=(2, 3) ，b=(3, 4)，则a**·** b=2*3+3*4=18

向量的外积(了解)

两个向量相乘的结果是一个向量，叫向量的外积或叉积

在几何上，向量的外积是一个向量，这个向量的方向垂直于相乘的两个向量组成的平面，大小为两个向量组成的平行四边形的面积。

练习：a = (1,2,3,4,5) b=(5,4,3,2,1)

a*b=35

---

1.2 矩阵

1.2.1 矩阵的概念

矩阵（Matrix） 是一个由数字排列成的矩形阵列，是一个二维数组，通常用大写字母表示，如 A。矩阵的元素可以是标量，矩阵的行数和列数分别称为矩阵的维度，一个 m×n 的矩阵有 m 行和 n 列，可以表示为:

其中这mxn个数称为矩阵A的元素，称为矩阵A的第i行第j列元素，矩阵的每一行或每一列都可以理解为一个行向量或列向量。

---

1.2.2 特殊类型的矩阵

行矩阵：只有一行的矩阵称为行矩阵或行向量

列矩阵：只有一列的矩阵称为列矩阵或列向量

零矩阵：元素都为0的矩阵称为零矩阵

方阵：矩阵的行数与列数相等，即m=n的矩阵，称为n阶方阵

单位矩阵：主对角线元素为1，其余元素为0的方阵

同型矩阵：两个矩阵A和B的行数与列数对应相等的矩阵称为同型矩阵

---

1.2.3 矩阵的加减法

做运算的两个矩阵A和B必须是同型矩阵 ，其计算结果就是将两个矩阵的对应元素进行相加减得到一个新的同型矩阵。

矩阵A、B为：

---

1.2.4 矩阵的乘法

1.2.4.1矩阵的数乘

常数与矩阵相乘又称为矩阵的数乘。数乘是指一个矩阵的所有元素都乘以一个常数k，相当于将这个矩阵内的所有元素缩放了k倍大小。

2 X A

---

1.2.4.2 矩阵和向量相乘

矩阵和向量也可以进行相乘运算，前提条件是矩阵的列数=向量的行数时才可乘，矩阵左乘一个列向量,相乘结果为：向量,假设有一个矩阵 A 和一个向量 v，矩阵 A 的大小为 m×n，向量 v 是一个 n 维列向量，矩阵 A 和向量 v 的乘积是一个新的向量 w，其大小为 m 维的列向量。

即：

---

1.2.4.3 矩阵的内积

矩阵之间的乘法也叫做矩阵的点积、内积，是矩阵运算中的核心操作之一，其进行的前提条件是第一个矩阵的列数必须等于第二个矩阵的行数。当满足这一条件时，矩阵乘法的结果将是一个新的矩阵，其行数等于第一个矩阵的行数，列数等于第二个矩阵的列数。

即：

---

1.2.5 矩阵的转置

矩阵的转置是指将矩阵的行和列互换得到的新矩阵。设矩阵A是m行n列的矩阵，则矩阵A的转置矩阵记作AT ，它是一个n行m列的矩阵。

比如矩阵A，转置后的结果为：

---

1.3 张量

张量是可以具有任意维度的数组，零维张量就是标量，一维张量就是向量，二维张量就是矩阵，更高维的张量可以看作是多维数组。比如可以将一张RGB彩色图可以表示成一个三维张量（三维数组）。

a = [1, 2, 3, 4, 5] #一维

b = [[1, 2, 3],

4, 5, 6\]\] #二维 c = \[\[\[1, 2, 3\], \[4, 5, 6

1, 1, 1\], \[2, 3, 3\]\]\] #三维 *** ** * ** *** ## 二、numpy ### 2.1 库的安装 #### 2.1.1 方法一 在pycharm的终端栏查看已经安装的库的命令：python -m pip list 或者在pycharm的文件-\>设置-\>项目-\>python解释器中查看     安装时需要挂载梯子 *** ** * ** *** #### 2.1.2 方法二 在pycharm软件的terminal上执行命令  pip install matplotlib == 3.7.2 *** ** * ** *** ### 2.2 numpy库的功能 NumPy(Numerical Python)是一个开源的Python科学计算库，它提供了多维数组对象（‌ndarray）以及大量的数学函数库 * 支持多维数组操作：NumPy提供了强大的n维数组对象ndarray，可进行高效的数据处理 * 丰富的函数：NumPy内置了大量数学、统计和线性代数函数。 * 高性能：NumPy底层采用C语言编写，相比于python来说运算速度快，性能优越 * 具有广播功能：可以允许不同形状的数组进行算术运算 练习：实现两个列表的元素相加运算 a = \[1, 2, 3, 4

b = [3, 4, 5, 6]

---

2.3 特点

• NumPy数组在内存中连续存储，并且每个元素的大小、类型相同。其在访问和修改元素时具有极高的效率。
• NumPy数组可以是多维的，具有明确的形状（shape）。
• NumPy提供了丰富的数学、统计、线性代数等函数库，可以进行相应的运算。
• NumPy数组的内部实现是基于C语言的
• NumPy的广播机制允许不同形状的数组在进行运算时自动扩展它们的形状，从而能够进行元素级的运算

---

三、n d a r r a y 数组

使用numpy之前需要先导入numpy库

import numpy as np

3.1 创建数组

numpy.array(object, dtype=None, copy=True, order='K', subok=False, ndmin=0)

参数：

object:可以是列表、元组、ndarray数组等可迭代对象，表示要转换为数组的数据。

dtype:数组元素的数据类型，可选，如果未指定，则根据输入数据自动推断。

copy:对象是否需要复制，默认为True

True，则复制输入数据；

False，当传入参数的数据类型和dtype指定的不一致时才复制

order:指定数组在内存中的存储顺序，可以是'C'（C语言风格,行优先）、'F'（Fortran风格,列优先）或'K'（尽可能与输入数据的顺序一致）。默认为'K'。

subok:默认返回一个与基类类型一致的数组

ndmin:指定数组的最小维度。如果输入数据的维度小于ndmin，则 NumPy 会自动在前面添加维度，以使数组的维度至少为ndmin。

numpy.asarray(a, dtype = None, order = None)

功能：创建numpy数组，于array类似，array比较常用
参考代码：

# 导入numpy库，并将其重命名为np，方便后续使用
import numpy as np

# 创建一个Python列表（可变序列类型）
a = [1, 2, 3, 4, 5]
# 使用numpy的array函数将列表转换为numpy数组
arr = np.array(a)
# 打印通过列表创建的numpy数组（默认数据类型为int）
print(arr)

# 创建一个元组（不可变序列类型）
b = (1, 2, 3, 4, 5)
# 将元组转换为numpy数组，并指定数据类型为浮点数
brr = np.array(b, dtype=float)
# 打印通过元组创建的numpy数组（强制转换为float类型）
print(brr)

# 创建brr的浅拷贝（共享内存地址，修改原始数组会影响拷贝）
crr = np.array(brr, copy=False)
# 修改brr数组的第一个元素（由于是浅拷贝，crr的值会同步改变）
brr[0] = 100
# 打印crr数组，验证浅拷贝的效果（输出值会随brr改变而变化）
print(crr)

C:\Users\98317\PycharmProjects\Python3_13\.venv\Scripts\python.exe C:\Users\98317\PycharmProjects\Python3_13\day001.py 
[1 2 3 4 5]
[1. 2. 3. 4. 5.]
[100.   2.   3.   4.   5.]

进程已结束，退出代码为 0

---

3.2 数组的访问

数组可以通过索引和切片进行访问，

索引从 0 开始，可以使用负数索引从数组末尾开始访问元素。

切片访问与Python列表的切片方式类似，使用冒号:进行切片，格式为start:stop:step，其中start、stop值为数组的索引，遵循左闭右开原则，三个值可根据情况省略

---

3.2.1 一维数组的访问

# 导入 numpy 库并使用别名 np
import numpy as np

# 创建一个包含 1 到 5 的一维 numpy 数组
arr = np.array([1, 2, 3, 4, 5])

# 索引操作
# 访问数组的第一个元素，索引从 0 开始
print(arr[0])

# 访问数组倒数第二个元素，负索引表示从数组末尾开始计数
print(arr[-2])

# 切片操作
# 遵循左闭右开原则，start:stop:step
# 从索引 0 开始，到索引 4 结束（不包含 4），步长为 2
print(arr[0:4:2])

# 从下标为 1 的元素开始，获取后面所有元素
print(arr[1:])

# 从第一个元素开始，到下标为 3 的元素（不包含 3）
print(arr[:3])

# 获取数组的所有元素
print(arr[:])

C:\Users\98317\PycharmProjects\Python3_13\.venv\Scripts\python.exe C:\Users\98317\PycharmProjects\Python3_13\day001.py 
1
4
[1 3]
[2 3 4 5]
[1 2 3]
[1 2 3 4 5]

进程已结束，退出代码为 0

---

3.2.2 多维数组的访问

对于多维数组，可以通过逗号分隔的索引来访问特定元素，也可以使用连续的[]来访问特定元素，例如，对于一个二维数组，第一个索引表示行，第二个索引表示列。

多维数组切片时，可以分别为每个维度指定切片。对于一个二维数组`arr`，切片操作的语法如下：

arr[row_slice, column_slice]

其中，row_slice用于选择行的范围，column_slice用于选择列的范围。
示例：

# 导入NumPy库，并将其重命名为np，方便后续使用
import numpy as np

# 创建一个二维NumPy数组
arr = np.array([[1, 2, 3], [4, 5, 6]])

# 打印整个数组
print(arr)

# 打印数组第一行第二列的元素（索引从0开始）
print(arr[0][1])

# 打印数组第二行第二列的元素
print(arr[1][1])

# 另一种打印数组第二行第二列元素的方式
print(arr[1, 1])  #与上一行效果相同

# 打印数组的第二行
print(arr[1])

# 打印数组第一行的前两个元素
print(arr[0:1, 0:2])

# 打印数组所有行的第一列和第三列元素
print(arr[0:2, [0, 2]])

# 打印数组的第一行
print(arr[0:1])

# 打印数组所有行的第一列元素
print(arr[:, 0:1])  #时刻牢记，逗号前面是行，逗号后面是列

C:\Users\98317\PycharmProjects\Python3_13\.venv\Scripts\python.exe C:\Users\98317\PycharmProjects\Python3_13\day001.py 
[[1 2 3]
 [4 5 6]]
2
5
5
[4 5 6]
[[1 2]]
[[1 3]
 [4 6]]
[[1 2 3]]
[[1]
 [4]]

进程已结束，退出代码为 0

---

3.3 创建特殊数组

3.3.1 empty

创建一个指定形状（shape）、数据类型（dtype）且初值为随机值的数组。

numpy.empty(shape, dtype = float, order = 'C')

参数：

shape：数组的形状，用[]或()表示

dtype：数组元素的类型

order：数据在计算机内存中的存储元素的顺序，C或F
可以通过ndarray.fill()填充具体的数值

# 导入 NumPy 库并将其别名为 np
import numpy as np

# 创建一个 2 行 3 列的空数组，数据类型为整数
# np.empty 函数返回一个给定形状和类型的新数组，但不初始化数组中的元素
arr = np.empty([2, 3], dtype=int)
# 打印创建的数组
print(arr)

# 使用 fill 方法将数组中的所有元素填充为 10
arr.fill(10)
# 打印填充后的数组
print(arr)

C:\Users\98317\PycharmProjects\Python3_13\.venv\Scripts\python.exe C:\Users\98317\PycharmProjects\Python3_13\day001.py 
[[                  0 4594572339843380019 4598175219545276416]
 [4602678819172646912 4604930618986332160 4607182418800017408]]
[[10 10 10]
 [10 10 10]]

进程已结束，退出代码为 0

---

3.3.2 zero

numpy.zeros(shape, dtype = float, order = 'C')
功能：创建一个全为0的指定大小的数组

numpy.zeros_like(a, dtype=None, order='K', subok=True, shape=None)

参数：a：可以是列表、元组、numpy数组

功能：创建一个和给定的数组具有相同形状的全为0的数组

# 导入NumPy库，并将其重命名为np，方便后续使用
import numpy as np

# 使用np.zeros函数创建一个2行3列的整数类型的零数组
# 第一个参数[2, 3]指定数组的形状，第二个参数dtype=int指定数组的数据类型为整数
arr = np.zeros([2, 3], dtype=int)
# 打印创建好的零数组
print(arr)

# 定义一个Python列表a
a = [1, 2, 3, 4, 5]
# 使用np.zeros_like函数创建一个与列表a形状相同的零数组
# 该函数会根据输入对象的形状创建一个全零数组
arr = np.zeros_like(a)
# 打印与列表a形状相同的零数组
print(arr)

C:\Users\98317\PycharmProjects\Python3_13\.venv\Scripts\python.exe C:\Users\98317\PycharmProjects\Python3_13\day002.py 
[[0 0 0]
 [0 0 0]]
[0 0 0 0 0]

进程已结束，退出代码为 0

---

3.3.3 ones

numpy.ones(shape, dtype = None, order = 'C')

功能：创建指定形状的全为1的数组

numpy.ones_like(a, dtype=None, order='K', subok=True, shape=None)

功能：创建一个和给定的数组具有相同形状的全为1的数组

# 导入NumPy库，并将其重命名为np，方便后续使用
import numpy as np

# 使用np.ones函数创建一个2行3列的整数类型的全1数组
# 第一个参数[2, 3]指定数组的形状，dtype=int指定元素类型为整型（默认是float）
arr = np.ones([2, 3], dtype=int)
# 打印创建的全1数组
print(arr)

# 定义一个Python列表a
a = [1, 2, 3, 4, 5]
# 使用np.ones_like函数创建与列表a形状相同的全1数组
# 该函数会继承输入对象（此处是列表）的维度信息（输出为(5,)的一维数组）
arr = np.ones_like(a)
# 打印生成的数组
print(arr)

C:\Users\98317\PycharmProjects\Python3_13\.venv\Scripts\python.exe C:\Users\98317\PycharmProjects\Python3_13\day002.py 
[[1 1 1]
 [1 1 1]]
[1 1 1 1 1]

进程已结束，退出代码为 0

---

3.3.4 full

numpy.full(shape, fill_value, dtype=None, order='C')

功能：创建一个指定形状，并设置指定值的数组

参数：shape：形状

fill_value：填充的值

# 导入numpy科学计算库（用于数组操作和数学计算）
import numpy as np  

# 创建一个2行3列的全15矩阵
# 使用np.full方法生成指定形状的数组，填充值为15
# 参数[2,3]表示数组维度，15为填充值
arr = np.full([2, 3], 15)

print(arr)

C:\Users\98317\PycharmProjects\Python3_13\.venv\Scripts\python.exe C:\Users\98317\PycharmProjects\Python3_13\day002.py 
[[15 15 15]
 [15 15 15]]

进程已结束，退出代码为 0

---

四、numpy数据类型

4.1 基本类型

|---------------|---------------------------------------------------|
| 名称 | 描述 |
| np.int8 | 字节（-128 to 127） |
| np.int16 | 整数（-32768 to 32767） |
| np.int32 | 整数（-2147483648 to 2147483647） |
| np.int64 | 整数（-9223372036854775808 to 9223372036854775807） |
| np.uint8 | 无符号整数（0 to 255） |
| np.uint16 | 无符号整数（0 to 65535） |
| np.uint32 | 无符号整数（0 to 4294967295） |
| np.uint64 | 无符号整数（0 to 18446744073709551615） |
| np.float16 | 半精度浮点数，包括：1 个符号位，5 个指数位，10 个尾数位 |
| np.float32 | 单精度浮点数，包括：1 个符号位，8 个指数位，23 个尾数位 |
| np.float64 | 双精度浮点数，包括：1 个符号位，11 个指数位，52 个尾数位 |
| np.complex64 | 复数，共64位， 32 位浮点数的实数部分和32位浮点数虚数部分 |
| np.complex128 | 复数，共128位， 64 位浮点数的实数部分和64位浮点数虚数部分 |
| np.bool_ | 布尔型数据类型（True 或者 False） |
| np.int_ | 默认的整数类型（根据系统来定是int32还是int64） |
| np.intc | 与 C 的 int 类型一样，一般是 int32 或 int 64 |
| np.intp | 用于索引的整数类型（类似于 C 的 ssize_t，一般情况下仍然是 int32 或 int64） |
| np.float_ | float64 类型的简写 |
| np.complex_ | complex128 类型的简写，即 128 位复数 |

---

4.1.1 整数类型 ：

'b': 有符号字符（相当于 int8）

'u': 无符号字符（相当于 uint8）

'i1', 'i2', 'i4', 'i8': 分别表示有符号的8位、16位、32位、64位整数

'u1', 'u2', 'u4', 'u8': 分别表示无符号的8位、16位、32位、64位整数

---

4.1.2 浮点类型 ：

'f2', 'f4', 'f8': 分别表示16位、32位、64位浮点数（相当于 float16, float32, float64）

---

4.1.3 复数类型 ：

'c8', 'c16', 'c32': 分别表示由两个16位、32位、64位浮点数组成的复数（相当于 complex64, complex128, complex256）

---

4.1.4 布尔类型 ：

'?' 或 'bool': 布尔类型（相当于 bool_）

---

4.1.5 字节类型 ：

'S<n>': 固定长度的字节字符串，<n> 表示长度。例如，'S10' 表示长度为10的字节字符串。

---

4.1.6 unicode类型 ：

'U<n>': 固定长度的Unicode字符串，<n> 表示长度（以字符为单位）。例如，'U10' 表示长度为10的Unicode字符串（Unicode编码标准来表示的字符串）。

补充：S10和U10区别：

S：是采用ASCII编码的字符串，ASCII 是一种基于英文字符的编码标准

U：是采用Unicode编码的字符串，Unicode 是一种国际标准的字符编码

两者编码方式不一样

---

4.2 结构化数据类型

NumPy的结构化数据类型（structured data type）允许你创建包含多个字段的数组，其中每个字段可以有不同的数据类型。这种数据结构类似于C语言中的结构体（struct）或Python中的字典（虽然访问方式有所不同），使得你可以在单个数组中存储复杂的数据记录。

结构化数组的每个元素都是一个记录，而每个记录则包含多个命名的字段。字段名可以是任何有效的字符串，而字段的数据类型则可以是NumPy支持的任何数据类型，包括基本数据类型和其他结构化类型。

格式：

('键名1'， '类型1')， （'键名2'， '类型2'）...

参考代码：

import numpy as np

# 定义结构化数据类型，包含两个字段：
# x: 4字节整型(i4)，y: 4字节浮点型(f4)
type = [('x', 'i4'), ('y', 'f4')]

# 创建包含三个元组的示例数据，每个元组对应一条结构化记录
a = [(1, 1.4), (2, 2.5), (3, 4.5)]

# 将Python列表转换为NumPy结构化数组，指定数据类型
arr = np.array(a, dtype=type)
print(arr)  # 打印整个结构化数组

print(arr[0])  # 访问并打印第一条记录（索引0）

# 通过键名访问元素
print(arr['x'][1])  # 访问第二个元素的x字段（索引1）

C:\Users\98317\PycharmProjects\Python3_13\.venv\Scripts\python.exe C:\Users\98317\PycharmProjects\Python3_13\day001.py 
[(1, 1.4) (2, 2.5) (3, 4.5)]
(1, 1.4)
2

进程已结束，退出代码为 0

练习：定义一个结构化数据类型，每个元素包含3个字段，分别是name、age、height

参考：

# 导入numpy库
import numpy as np

# 定义结构化数据类型：包含三个字段的元组列表
# 'name'字段：长度12的Unicode字符串类型（U12）
# 'age'字段：4字节整型（i4）
# 'height'字段：4字节浮点型（f4）
ty = [("name", "U12"), ("age", "i4"), ("height", "f4")]

# 创建包含三个人员信息的元组列表
a = [("zhangsan", 32, 175.1), ("lisi", 45, 180.1), ("wangwu", 16, 165.1)]

# 将Python列表转换为numpy结构化数组，使用预定义的数据类型
b = np.array(a, dtype=ty)

# 打印整个结构化数组
print(b)
# 通过字段名访问并打印所有人员的name字段
print(b['name'])

C:\Users\98317\PycharmProjects\Python3_13\.venv\Scripts\python.exe C:\Users\98317\PycharmProjects\Python3_13\day001.py 
[('zhangsan', 32, 175.1) ('lisi', 45, 180.1) ('wangwu', 16, 165.1)]
['zhangsan' 'lisi' 'wangwu']

进程已结束，退出代码为 0

---

五、ndarray的属性

5.1常用属性

|---------------|-------------------------------|
| ndarray.ndim | 秩(zhi)，即轴的数量或维度的数量 |
| ndarray.shape | 数组的维度，对于矩阵，n 行 m 列 |
| ndarray.size | 数组元素的总个数，相当于 .shape 中 n*m 的值 |
| ndarray.dtype | ndarray 对象的元素类型 |

# 导入NumPy库（科学计算常用库）
import numpy as np

# 创建一个2x3的二维数组，指定数据类型为32位浮点数
arr = np.array([[1, 2, 3], [4, 5, 6]], dtype='f4')

# 数组的维度
print(arr.ndim)  # 输出: 2 (二维数组)
# 形状
print(arr.shape)  # 输出: (2, 3) (2行3列)
# 数组中元素个数
print(arr.size)  # 输出: 6 (2x3=6个元素)
# 数组元素的类型
print(arr.dtype)  # 输出: float32 (32位浮点数类型)

C:\Users\98317\PycharmProjects\Python3_13\.venv\Scripts\python.exe C:\Users\98317\PycharmProjects\Python3_13\day001.py 
2
(2, 3)
6
float32

进程已结束，退出代码为 0

---

5.2 修改属性

5.2.1 astype

numpy.ndarray.astype(dtype, order='K', casting='unsafe', subok=True, copy=True)

参数：

dtype：表示新数据类型的对象。这可以是 NumPy 的 dtype 对象，也可以是 Python 的数据类型，例如 `int` 或 `float`。

casting：控制数据类型转换的安全性。

'no'：表示根本不应该进行转换数据类型。

'equiv'：允许数值上等价的类型转换，即转换前后数据的位表示相同。这意味着转换不会导致数据丢失。

'safe'：允许安全的类型转换，即转换过程中不会丢失信息。

'same_kind'：允许相同数据类型类别内的转换。例如，允许整型和整型之间、浮点型和浮点型之间的转换，但是不允许整型和浮点型之间的转换。

'unsafe'：允许任何类型的转换，不考虑是否会导致数据丢失或改变。这是最不安全的选项，因为它可能会静默地丢弃数据。

# 导入numpy库（使用别名np）
import numpy as np

# 创建2x3的二维数组
arr = np.array([[1, 2, 3], [4, 5, 6]])
print(arr)  # 打印原始数组

# 将数组元素类型转换为32位浮点数（float32）
ret = arr.astype('f4')
print(ret)  # 打印转换类型后的数组

C:\Users\98317\PycharmProjects\Python3_13\.venv\Scripts\python.exe C:\Users\98317\PycharmProjects\Python3_13\day002.py 
[[1 2 3]
 [4 5 6]]
[[1. 2. 3.]
 [4. 5. 6.]]

进程已结束，退出代码为 0

---

5.2.2 reshape

numpy.ndarray.reshape(newshape, order='C')

参数：

newshape：整数或整数元组，新的形状应该与原始数组中的元素数量相匹配。 当值为-1时，会根据元素总个数除以固定的值，自动计算出来

import numpy as np  # 导入NumPy科学计算库，约定缩写为np

# 创建一个2x3的二维数组，元素类型默认为int32/int64（根据系统）
arr = np.array([[1, 2, 3], [4, 5, 6]])
print(arr)  # 打印原始数组
print()  # 输出空行分隔不同结果

# 使用reshape方法将数组重组为3x2结构，-1表示自动计算该维度大小
ret = arr.reshape([-1, 2])
print(ret)  # 打印重组后的新数组

C:\Users\98317\PycharmProjects\Python3_13\.venv\Scripts\python.exe C:\Users\98317\PycharmProjects\Python3_13\day002.py 
[[1 2 3]
 [4 5 6]]

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

进程已结束，退出代码为 0

---

5.2.3 resize

esize 方法用于改变数组的大小， 它会直接修改调用它的原始数组 。如果新形状大于原始形状，则会在数组的末尾添加新的元素，这些元素的值未定义；如果新形状小于原始形状，则会截断数组。

numpy.ndarray.resize(newshape)

import numpy as np  # 导入NumPy科学计算库，约定缩写为np

# 创建一个2x3的二维数组，元素类型默认为int32/int64（根据系统）
arr = np.array([[1, 2, 3], [4, 5, 6]])
print(arr)  # 打印原始数组
print()  # 输出空行分隔不同结果

# 使用resize方法直接修改数组形状为3x4（会填充默认值）
arr.resize([3, 4])
print(arr)  # 打印调整后的数组（含自动填充的0元素）
print()  # 输出空行分隔不同结果

# 再次调整数组形状为3x1（截断多余元素）
arr.resize([3, 1])
print(arr)  # 打印最终调整后的数组
print()  # 输出空行保持格式统一

C:\Users\98317\PycharmProjects\Python3_13\.venv\Scripts\python.exe C:\Users\98317\PycharmProjects\Python3_13\day002.py 
[[1 2 3]
 [4 5 6]]

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

[[1]
 [2]
 [3]]


进程已结束，退出代码为 0

5.2.4 flatten

flatten方法返回一个一维数组，它是原始数组的拷贝，修改新数组不会影响原数组，它默认按行顺序展平数组，但可以通过参数 `order` 来指定展平顺序

numpy.ndarray.flatten(order='C')

参数：

order：指定的顺序，'C' 表示按行，'F' 表示按列，'A' 或 'K' 表示与原数组相同的顺序

import numpy as np  # 导入NumPy科学计算库，约定缩写为np

# 创建一个2x3的二维数组，元素类型默认为int32/int64（根据系统）
# 数组初始化时自动推断数据类型，具体类型取决于操作系统架构
# 二维数组在内存中按行优先顺序存储（C风格）
arr = np.array([[1, 2, 3], [4, 5, 6]])
print(arr)  # 打印原始数组（保持二维结构），输出格式为：
# [[1 2 3]
#  [4 5 6]]
print()  # 输出空行分隔不同结果

# 使用Fortran风格（列优先）将二维数组展平为一维数组
# 'F'参数表示按列顺序进行展平（沿第二轴方向操作）
# 方法说明：
# flatten() 返回展开的一维数组拷贝
# 参数说明：
#   order='F' 表示按列优先顺序展开（Fortran风格）
# 返回值：
#   包含原始数组元素的一维numpy数组，元素按列顺序排列
ret = arr.flatten('F')
print(ret)

C:\Users\98317\PycharmProjects\Python3_13\.venv\Scripts\python.exe C:\Users\98317\PycharmProjects\Python3_13\day002.py 
[[1 2 3]
 [4 5 6]]

[1 4 2 5 3 6]

进程已结束，退出代码为 0

5.2.5 T

Ndarray 对象的 T 属性是一个特殊的属性，它返回转置后的数组（transpose）。

转置是一个操作，它将数组的维度进行交换。对于二维数组，这意味着行变为列，列变为行。对于更高维度的数组，转置操作涉及到交换数组的轴。

import numpy as np  # 导入NumPy科学计算库，约定缩写为np

# 创建一个2x3的二维数组，元素类型默认为int32/int64（根据系统）
# 数组初始化时自动推断数据类型，具体类型取决于操作系统架构
# 二维数组在内存中按行优先顺序存储（C风格）
arr = np.array([[1, 2, 3], [4, 5, 6]])
print(arr)  # 打印原始数组（保持二维结构），输出格式为：
# [[1 2 3]
#  [4 5 6]]
print()  # 输出空行分隔不同结果

# 计算数组的转置（行列交换）
# .T属性返回原始数组的视图（view），不会复制数据
# 转置后数组形状变为3x2，内存存储顺序变为列优先（F风格）
ret = arr.T
print(ret)  # 打印转置结果，输出格式为：
# [[1 4]
#  [2 5]
#  [3 6]]

C:\Users\98317\PycharmProjects\Python3_13\.venv\Scripts\python.exe C:\Users\98317\PycharmProjects\Python3_13\day002.py 
[[1 2 3]
 [4 5 6]]

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

进程已结束，退出代码为 0

---

六、numpy创建数组的其它函数

6.1 arange

numpy.arange(start, stop, step, dtype)

参数：

start：起始值，默认为0

stop：终止值（不包含）

step：步长，默认为1

dtype：返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。

import numpy as np  # 导入NumPy库并使用简写别名np

# 使用NumPy的arange函数创建等差数组
# 当只传入单个参数时，默认生成0到n-1的整数数组
arr = np.arange(10)  # 创建一个包含0到9的整型一维数组

# 打印数组内容
print(arr)  # 输出结果：[0 1 2 3 4 5 6 7 8 9]

C:\Users\98317\PycharmProjects\Python3_13\.venv\Scripts\python.exe C:\Users\98317\PycharmProjects\Python3_13\day001.py 
[0 1 2 3 4 5 6 7 8 9]

进程已结束，退出代码为 0

---

6.2 linspace

用于创建一个一维数组，数组是一个等差数列构成的

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

参数：

start：序列的起始值

stop：序列的终止值

num：要生成的等步长的样本数量，默认为`50`

endpoint：该值为 True时，数列中包含`stop`值，反之不包含，默认是True。

retstep：如果为 True 时，生成的数组中会显示间距，反之不显示。

dtype：`ndarray` 的数据类型

import numpy as np  # 导入NumPy库并使用简写别名np

# 生成均匀分布的数值数组
# 参数说明：
# 起始值=1，结束值=20，生成20个样本
# endpoint=False表示不包含右端点
# retstep=True表示返回样本间步长
arr, step = np.linspace(1, 20, 20, endpoint=False, retstep=True)  # arr: 生成的等差数列数组  step: 实际计算出的步长值
print(arr, step)  # 输出数组和步长信息

C:\Users\98317\PycharmProjects\Python3_13\.venv\Scripts\python.exe C:\Users\98317\PycharmProjects\Python3_13\day001.py 
[ 1.    1.95  2.9   3.85  4.8   5.75  6.7   7.65  8.6   9.55 10.5  11.45
 12.4  13.35 14.3  15.25 16.2  17.15 18.1  19.05] 0.95

进程已结束，退出代码为 0

---

6.3 random

Ndarray数组还可以创建具有随机元素的数组。随机元素的值可以根据是否设置随机数种子每次产生相同或不同的随机值。

随机数种子：是一个用于初始化随机数生成器的值，随机数种子的值可以是任意的，如果不显式设置种子，通常会使用当前时间作为种子，这样每次程序运行时都会产生不同的随机数序列。如果设置相同的随机数种子，每次程序运行时生成的随机数序列都是相同的。

np.random.seed(num)

功能：设置随机数种子，种子值可以是任何整数，通常是正整数。

---

6.3.1 rand

numpy.random.rand(d0, d1, ..., dn)

功能：返回一个或一组[0.0, 1.0) 区间均匀分布的随机浮点类型样本

参数：d0, d1, ..., dn：这些参数定义了输出数组的形状

# 导入NumPy科学计算库，并使用np作为别名方便后续调用
import numpy as np  # np是numpy的别名

# 定义随机数种子，则每次产生的随机数都是相同的，不指定时默认以当前时间作为随机数种子
np.random.seed(10)  # 设置种子值为10，保证可重复性。参数应为[0, 2**32)范围内的整数
arr = np.random.rand(2)  # 生成包含2个元素的一维数组
print(arr)  # 输出示例：[0.77132064 0.02075195]

C:\Users\98317\PycharmProjects\Python3_13\.venv\Scripts\python.exe C:\Users\98317\PycharmProjects\Python3_13\day001.py 
[0.77132064 0.02075195]

进程已结束，退出代码为 0

---

6.3.2 random

numpy.random.randn(d0, d1, ..., dn)

功能：用于生成服从标准正态分布（均值为0，标准差为1）的随机数

参数：生成的数组的形状

import numpy as np  # 导入NumPy库并用np作为别名，NumPy是Python科学计算的基础包

# 使用random模块生成[0.0, 1.0)区间的随机浮点数数组
# 参数[2,3]表示生成2行3列的二维数组
arr = np.random.random([2, 3])  # 返回值arr是numpy.ndarray类型对象

# 打印生成的随机数组到控制台
# 输出内容会根据随机数生成结果变化，每次运行结果不同
print(arr)

C:\Users\98317\PycharmProjects\Python3_13\.venv\Scripts\python.exe C:\Users\98317\PycharmProjects\Python3_13\day001.py 
[[0.60206497 0.31867238 0.47388345]
 [0.00107651 0.86694808 0.53872016]]

进程已结束，退出代码为 0

---

6.3.3 randint

numpy.random.randint(low, high=None, size=None, dtype=int)

功能：用于生成随机整数，这些数在指定的范围内均匀分布(每个数的概率相同)

参数：low：生成随机数的起始点（包含）

high（可选）：生成随机数的结束点（不包含）

size：定义输出数组形状的整数或元组，省略时会生成一个随机数

dtype:指定返回数组的数据类型

import numpy as np  # 导入NumPy库并用np作为别名，NumPy是Python科学计算的基础包

# 生成随机整数矩阵
# 使用np.random.randint方法创建2行3列的二维数组
# 参数说明：
#   low=1  - 生成随机数的最小值（包含）
#   high=10 - 生成随机数的最大值（不包含）
#   size=(2,3) - 输出数组的维度
arr = np.random.randint(1, 10, (2, 3))

# 打印生成的随机数组
# 输出格式为：
# [[x x x]
#  [x x x]] 其中x为1-9的随机整数
print(arr)

C:\Users\98317\PycharmProjects\Python3_13\.venv\Scripts\python.exe C:\Users\98317\PycharmProjects\Python3_13\day001.py 
[[5 7 8]
 [3 8 1]]

进程已结束，退出代码为 0

---

6.3.4 randn

numpy.random.randn(d0, d1, ..., dn)

功能：用于生成服从标准正态分布（均值为0，标准差为1）的随机数

参数：生成的数组的形状

import numpy as np  # 导入NumPy库并用np作为别名，NumPy是Python科学计算的基础包

# 生成服从标准正态分布的随机数组
# randn函数返回包含100个元素的浮点数数组，每个元素服从N(0,1)分布
# 该数组存储在变量arr中用于后续操作
arr = np.random.randn(100)

# 打印输出生成的随机数组
# 默认以科学记数法形式显示数组内容，输出维度为一维数组[100]
print(arr)

C:\Users\98317\PycharmProjects\Python3_13\.venv\Scripts\python.exe C:\Users\98317\PycharmProjects\Python3_13\day001.py 
[ 0.07778002  1.70999319 -0.63088192  0.21346851 -0.40473221  0.10291831
 -0.1660106  -0.86326148  0.24267027 -0.5583113   0.4630395   1.08021299
  1.09669886  1.71414142  0.3108109  -0.44741444 -0.56802397  0.42692015
  0.67654081  1.71243507 -0.3423595   0.55594399 -0.80709932 -0.91734803
  0.22102892  0.62462684  0.59539262 -1.84930542 -0.9556041   1.27727322
  0.66462185 -1.66926531  1.47761742 -0.10380882 -1.2001593  -0.79187998
 -0.7725446  -1.2200066   0.59974537 -0.37168065 -1.49790916  0.33398969
  0.01732084  0.0746353  -1.44371212 -0.0660916   1.11176828  0.35292241
 -1.09324659 -1.01774023  0.43107523  2.02809619  0.85189936  0.20470118
 -0.67084044  0.27914835 -0.21939725 -0.16457771 -0.38868549  0.49161516
 -1.29476404 -0.30804919 -0.73422435  1.76907217  0.65660244 -0.39147841
  0.92526789  0.17017299  0.95209495 -1.50527621  0.07353199 -0.82581594
  0.17153436  0.17480936  0.56634944 -0.25917579  0.82023093  0.98665273
  0.60563119 -1.05222164  2.13564806  0.31688253  0.8895478   0.15932209
 -0.04358487  1.07144582  0.20537008  1.2641246  -1.11508857 -0.26663894
 -0.16036393  0.00455272  0.93627618 -0.07677321 -0.75502922  0.80423438
  0.47386791  0.11436867  0.26585706 -1.77420802]

进程已结束，退出代码为 0

---

6.3.5 normal

numpy.random.normal(loc=0.0, scale=1.0, size=None)

功能：用于生成正态分布（高斯分布）随机数的函数

参数：loc：浮点数，表示正态分布的均值（μ），默认值为 0.0。

scale：浮点数，表示正态分布的标准差（σ），默认值为 1.0。注意，这里的 scale 实际上是标准差，而不是方差。

size：整数或整数元组，指定输出数组的形状。如果省略或为 None，则返回一个单一的浮点数。

import numpy as np  # 导入NumPy库并用np作为别名，NumPy是Python科学计算的基础包

# 生成服从正态分布的随机数数组
# 参数说明：
# loc: 正态分布的均值（中心位置）
# scale: 正态分布的标准差（离散程度）
# size: 输出数组的维度
# 返回值：包含100个符合N(1,2)分布的随机数的ndarray对象
arr = np.random.normal(1, 2, 100)
print(arr)  # 输出生成的随机数组内容

C:\Users\98317\PycharmProjects\Python3_13\.venv\Scripts\python.exe C:\Users\98317\PycharmProjects\Python3_13\day001.py 
[-0.16425994 -2.01985825  2.16831035  1.21701752  4.13591462  0.84577998
  1.80422304 -0.44488814 -0.14850861 -1.14886427  2.2553122  -0.62519526
  2.16208432 -1.30267699  1.17061761  4.6346547   0.64378313  2.77635433
  4.85396845 -2.22637447  6.75000456  3.35718791 -2.51906798  0.34871305
  2.65758503  0.34404481  0.98121449  0.89301387  1.72924839  1.07964817
 -1.11782688 -0.91200568  1.71852544  0.88418068  2.08032079 -4.04121558
  1.61224355  2.326888    2.21537781 -2.15627222 -0.23967345 -1.15839667
  3.81484408 -0.69229898  1.72444422  2.52806835  2.51756744  0.19762417
  1.82699809 -3.35264708  4.21211124 -0.90314093  1.10917903  0.14872497
  2.18040512  5.027969    1.90869569  1.60805869 -3.73183115 -1.5969511
 -1.94464078 -0.06125288  2.68765647 -1.14988192  1.71972878  0.64560451
 -0.34665092  3.21779509  1.18141849 -1.15075103  4.20841648 -0.87383229
  0.18380841  0.35187278  2.54842196 -1.54351244 -0.05672807 -0.65315172
  2.87338339  2.59845603  0.48677879  2.29208102 -5.44484178 -0.40014926
 -0.92202332  2.6357367   5.15167042 -2.8444641   4.02959799 -0.48547023
  2.68808702  0.75760293  1.30988812  6.07455892  2.83637605  1.03023745
 -2.0175667  -3.42332532 -0.0884019  -0.75325304]

进程已结束，退出代码为 0

---

6.3.6 uniform

numpy.random.uniform(low=0.0, high=1.0, size=None)

功能：用于从均匀分布中抽取一个浮点数

参数：low：浮点数或类似浮点数的数组，样本抽取区间的下限，默认值为 0。

high：浮点数或类似浮点数的数组，表示样本抽取区间的上限，默认值为 1。

size：整数或元组，可选参数，表示输出的形状。如果未提供，则返回单个浮点数。如果提供了一个整数，则返回一个一维数组；如果提供了一个元组，则返回一个多维数组。

import numpy as np  # 导入NumPy库并用np作为别名，NumPy是Python科学计算的基础包

# 生成均匀分布随机数组
# 参数说明：
# low=1（最小值范围）
# high=10（最大值范围）
# size=(2,3)（生成数组的维度）
# 返回值：包含均匀分布随机数的2x3二维数组
arr = np.random.uniform(1, 10, (2, 3))
# 打印输出生成的随机数组
print(arr)

C:\Users\98317\PycharmProjects\Python3_13\.venv\Scripts\python.exe C:\Users\98317\PycharmProjects\Python3_13\day001.py 
[[1.59356599 1.25145768 3.11499368]
 [5.81466932 7.17059161 1.35535477]]

进程已结束，退出代码为 0

---

6.3.7 shuffle

numpy.random.shuffle(x)

功能：用来随机打乱数组元素的顺序的

参数：x：要打乱的数组

import numpy as np  # 导入NumPy库并用np作为别名，NumPy是Python科学计算的基础包

# 创建一维数组（1x5）
arr = np.array([1, 2, 3, 4, 5])
# 创建二维数组（3x3）
brr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

def shuffle(x):
    """随机打乱数组内容（原地修改）

    Args:
        x: ndarray, 需要打乱顺序的数组。支持一维或多维数组

    Note:
        直接修改原数组，不返回新数组
        对于多维数组，只打乱第一维的顺序
    """

np.random.shuffle(arr)
np.random.shuffle(brr)

# 输出打乱后的一维数组
print(arr)
# 输出空行分隔
print()
# 输出打乱后的二维数组
print(brr)

C:\Users\98317\PycharmProjects\Python3_13\.venv\Scripts\python.exe C:\Users\98317\PycharmProjects\Python3_13\day001.py 
[3 2 5 1 4]

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

进程已结束，退出代码为 0

---

七、数组的运算

7.1 算数运算

如果两个数组 a 和 b 形状相同，即满足 a.shape == b.shape，那么 a和b 进行基本运算的结果就是 a 与 b 数组对应位相运算，前提是两个数组的形状相同。

---

7.1.1加法运算

NumPy支持数组加法运算，可以使用numpy.add()函数或+运算符。

import numpy as np  # 导入NumPy库并用np作为别名，NumPy是Python科学计算的基础包

a = np.array([1, 2, 3, 4, 5])
b = np.array([5, 4, 3, 2, 1])
print(a + b)
print(np.add(a, b))

C:\Users\98317\PycharmProjects\Python3_13\.venv\Scripts\python.exe C:\Users\98317\PycharmProjects\Python3_13\day001.py 
[6 6 6 6 6]
[6 6 6 6 6]

进程已结束，退出代码为 0

---

7.1.2减法运算

NumPy数组同样支持减法运算，可以使用numpy.subtract()函数或 - 运算符

import numpy as np  # 导入NumPy库并用np作为别名，NumPy是Python科学计算的基础包

a = np.array([1, 2, 3, 4, 5])
b = np.array([5, 4, 3, 2, 1])
print(a - b)
print(np.subtract(a, b))

C:\Users\98317\PycharmProjects\Python3_13\.venv\Scripts\python.exe C:\Users\98317\PycharmProjects\Python3_13\day001.py 
[-4 -2  0  2  4]
[-4 -2  0  2  4]

进程已结束，退出代码为 0

---

7.1.3​​​​​​​乘法运算

NumPy数组同样支持乘法运算，它是元素级运算，意味着数组中每个元素分别与其他数组（或标量）中对应位置的元素进行相乘运算。

可以使用*或函数numpy.multiply。

import numpy as np  # 导入NumPy库并用np作为别名，NumPy是Python科学计算的基础包

a = np.array([1, 2, 3, 4, 5])
b = np.array([5, 4, 3, 2, 1])
print(a * b)
print(np.multiply(a, b))

C:\Users\98317\PycharmProjects\Python3_13\.venv\Scripts\python.exe C:\Users\98317\PycharmProjects\Python3_13\day001.py 
[5 8 9 8 5]
[5 8 9 8 5]

进程已结束，退出代码为 0

---

7.1.4​​​​​​​除法运算

NumPy数组同样支持除法运算，可以使用numpy.divide()函数或 / 运算符

import numpy as np  # 导入NumPy库并用np作为别名，NumPy是Python科学计算的基础包

a = np.array([1, 2, 3, 4, 5])
b = np.array([5, 4, 3, 2, 1])
print(a / b)
print(np.divide(a, b))

C:\Users\98317\PycharmProjects\Python3_13\.venv\Scripts\python.exe C:\Users\98317\PycharmProjects\Python3_13\day001.py 
[0.2 0.5 1.  2.  5. ]
[0.2 0.5 1.  2.  5. ]

进程已结束，退出代码为 0

---

​​​​​​​7.1.5开根号

NumPy数组同样支持除法运算，可以使用numpy.power()函数或 **0.5 运算符.

使用numpy.power函数来完成两个数组之间的幂运算，如果两个数组的形状相同，那么它就会将对应位置的元素进行幂运算.

numpy.power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True)

参数：x1：数组或标量，是底数

x2：数组或标量，表示幂(指数)

import numpy as np  # 导入NumPy库并用np作为别名，NumPy是Python科学计算的基础包

a = np.array([1, 2, 3, 4, 5])
print(a ** 0.5)
print(np.power(a, 0.5))

C:\Users\98317\PycharmProjects\Python3_13\.venv\Scripts\python.exe C:\Users\98317\PycharmProjects\Python3_13\day001.py 
[1.         1.41421356 1.73205081 2.         2.23606798]
[1.         1.41421356 1.73205081 2.         2.23606798]

进程已结束，退出代码为 0

---

7.2 矩阵运算

7.2.1 ​​​​​​​矩阵乘法

也称为点积，要求两个数组的形状兼容（第一个数组的列数等于第二个数组的行数），并且使用 @ 运算符或 numpy.dot 函数。

import numpy as np  # 导入NumPy库并用np作为别名，NumPy是Python科学计算的基础包

# 创建3x2维的数组（矩阵）
a = np.array([[1, 2], [3, 4], [5, 6]])
# 创建2x3维的数组（矩阵）
b = np.array([[1, 2, 3], [4, 5, 6]])

# 使用@运算符进行矩阵乘法运算（Python 3.5+特性）
print(a @ b)
# 使用dot方法进行矩阵乘法运算
# @param b: 要进行矩阵乘法的第二个数组
# @return: 返回两个数组的矩阵乘积
print(a.dot(b))

C:\Users\98317\PycharmProjects\Python3_13\.venv\Scripts\python.exe C:\Users\98317\PycharmProjects\Python3_13\day001.py 
[[ 9 12 15]
 [19 26 33]
 [29 40 51]]
[[ 9 12 15]
 [19 26 33]
 [29 40 51]]

进程已结束，退出代码为 0

---

总结

本文系统梳理线性代数基础概念与NumPy科学计算工具的核心应用，从标量、向量、矩阵、张量的数学定义出发，结合几何与坐标表达形式，详解向量加减、内积外积、矩阵转置、点积等运算规则。通过Python代码实战演示NumPy数组创建、索引切片、维度转换、特殊数组生成等操作，深入剖析ndarray对象的内存特性与广播机制。重点解析矩阵乘法、转置、元素级运算与结构化数据操作，覆盖空数组填充、均匀分布/正态分布随机数生成、数组变形等高频场景，贯通数学理论与编程实践，为机器学习与数据分析打下坚实基础。