一. 数组的降维

import numpy as np
list1 = [1,2,3,4,5,6,7,8]
v = np.array(list1)
v = v.reshape(2,2,2)
print(v)
v.ndim

# 将三维降到二维
r1 = v.reshape(1,8)
print(r1)
r1.ndim

# 将高维数据转化为一维
# ravel()
r2 = v.ravel()
print(r2)

# flatten()
r3 = v.flatten()#非常重要，flatten方法返回的是原数组的副本，对返回的一维数组修改不影响原始多维数组；ravel方法（如果可能）返回原始数组视图，修改可能影响原始多维数组 
print(r3)

list1 = [1,2,3,4,5,6,7,8]
v = np.array(list1)
print(v)
# 小补充shape也可以实现降维
v.shape = (2,4)#通过直接对array数据的属性进行修改 
print(v)

 

ravel ()：将高维数组转为一维（返回视图）

我们先看如何用ravel()将高维数组转为一维，以及实际运行效果：

代码示例（基于前面的三维数组 v）：

python

运行

import numpy as np
list1 = [1,2,3,4,5,6,7,8]
v = np.array(list1).reshape(2,2,2)  # 三维数组：2×2×2
r2 = v.ravel()  # 转为一维数组
print("ravel()处理后的一维数组：", r2)

调试结果：

plaintext

ravel()处理后的一维数组： [1 2 3 4 5 6 7 8]

关键说明：

• ravel()的作用是将任意高维数组「展平」为一维数组，不创建新的内存副本，而是返回原数组的「视图」。
• 所谓「视图」，可以理解为：原数组 v（2×2×2）的内存空间没变，ravel()只是改变了数据的「展示形式」—— 从三维的 2×2×2 变成了一维的 1×8，数据本身还在原来的内存位置。
• 因此，如果修改 r2 的值，可能会影响原始数组 v。比如：

  python

  运行

  r2[0] = 100  # 修改r2的第一个元素
  print(v)  # 原数组v的对应位置也会变成100
  

flatten()：将高维数组转为一维（返回副本，重要！）

flatten()是更常用的降维函数，我们重点讲解：

代码示例：

python

运行

r3 = v.flatten()  # 转为一维数组
print("flatten()处理后的一维数组：", r3)

调试结果：

plaintext

flatten()处理后的一维数组： [1 2 3 4 5 6 7 8]

表面看，r2（ravel 结果）和 r3（flatten 结果）完全一样，都是[1 2 3 4 5 6 7 8]，但核心区别在于：

• flatten()返回的是原数组的副本：它会在内存中重新创建一块空间，将原数组的数据「复制」过去，然后以一维形式展示。
• 因此，修改 r3 的值，绝对不会影响原始数组 v。比如：

  python

  运行

  r3[0] = 100  # 修改r3的第一个元素
  print(v)  # 原数组v的第一个元素仍然是1（不受影响）
  

ravel () 与flatten() 的核心区别

函数	是否创建副本	修改返回值是否影响原数组	内存操作
ravel()	否（返回视图）	可能影响	仅改变展示形式，数据位置不变
flatten()	是（返回副本）	绝对不影响	复制数据到新内存，独立存在

补充：通过 shape 属性实现降维

除了上述方法，还可以直接修改数组的shape属性来改变维度（包括降维）：

运行

v = np.array([1,2,3,4,5,6,7,8])  # 初始一维数组
v.shape = (2,4)  # 直接修改shape为(2,4)，降为二维
print(v)

结果：

plaintext

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

shape属性是数组的内置属性，直接修改它会改变原数组的维度，无需创建新数组，非常便捷。

二.创建特殊的数组 

import numpy as np

# 创建全为0的数组
a = np.zeros(5)
b = np.zeros((2,2))#zeros 接受形状参数，这里(2,2)表示二维 2x2 全 0 数组 
c = np.zeros((3,2,2))
print(a, '\n', b, '\n', c)
# 创建全为1的数组
d = np.ones(5)
e = np.ones((2,2))
f = np.ones((2,2,2))

# 创建全为指定值（这里是5）的数组，矩阵中全部填充指定的数据
g = np.full((2,2,2), 5)

# 小补充，创建单位矩阵相关（np.eye 创建对角线为1，其余为0的矩阵，这里 5 行 7 列 ）
h = np.eye(5,7)
print('hello')

创建全为 0 的数组（np.zeros）

相关代码如下：

python

运行

a = np.zeros(5)
b = np.zeros((2,2))  # 传入元组(2,2)，表示二维2x2数组
c = np.zeros((3,2,2))  # 传入元组(3,2,2)，表示三维数组
print(a, '\n', b, '\n', c)

讲解：

• 参数特点：np.zeros() 接受一个表示数组形状的参数，该参数可以是整数（一维）或元组（多维）。
• 维度说明：
  • np.zeros(5)：参数为整数 5，表示创建 1 维数组，长度为 5，全为 0。
  • np.zeros((2,2))：参数为元组(2,2)，表示创建 2 维数组（2 行 2 列），全为 0。注意外层是函数括号，内层(2,2)是元组，用于指定形状。
  • np.zeros((3,2,2))：参数为元组(3,2,2)，表示创建 3 维数组（3 个 2 行 2 列的子数组），全为 0。
• 数据类型：输出结果中 0 的形式为0.（带小数点），说明默认数据类型是浮点数（float），这是 NumPy 创建此类数组的默认设置。

创建全为 1 的数组（np.ones）

相关代码如下：

python

运行

d = np.ones(5)
e = np.ones((2,2))
f = np.ones((2,2,2))

讲解：

• 用法与np.zeros一致：np.ones()的参数规则和维度逻辑和np.zeros完全相同，只是数组元素全为 1。
  • np.ones(5)：1 维数组，长度 5，全为 1。
  • np.ones((2,2))：2 维数组（2 行 2 列），全为 1。
  • np.ones((2,2,2))：3 维数组（2 个 2 行 2 列的子数组），全为 1。
• 数据类型：默认同样为浮点数（输出为1.），因为 NumPy 创建矩阵时默认用浮点数，方便后续计算（避免整数运算丢失小数结果）。

创建全为指定值的数组（np.full）

相关代码如下：

python

运行

g = np.full((2,2,2), 5)

讲解：

• 作用：np.full()用于创建一个指定形状、且所有元素都为指定值的数组。
• 参数：
  • 第一个参数(2,2,2)：元组，指定数组形状（3 维，2x2x2）。
  • 第二个参数5：指定填充的数值（这里全为 5）。
• 结果：数组g是 3 维结构，所有元素均为 5（数据类型根据填充值默认，这里 5 是整数，所以结果为整数类型）。

小补充：创建对角线为 1 的矩阵（np.eye）

相关代码如下：

python

运行

h = np.eye(5,7)

讲解：

• 作用：np.eye()创建一个矩阵，主对角线元素为 1，其余元素为 0（类似单位矩阵，但可以是非方阵）。
• 参数：5,7表示创建一个 5 行 7 列的矩阵。
• 特点：主对角线（从左上角到右下角）的元素为 1，其余为 0，默认数据类型为浮点数（1.和0.）。

 

三. numpy 中常用的两个函数 

import numpy as np

# 1. arange(start, end, step) -> 类似 range(start, end, step)，[左闭右开区间]一次性产生规律的数据
r1 = np.arange(0,9,3)
print(r1)

# 2. linspace(start, end, nums) ，[左右都是闭区间]，生成 nums 个在 start 到 end 间等距的数据
r2 = np.linspace(0,1,21)
print(r2)

 

np.arange：生成规律的数组

• 含义：arange 是 "array range" 的缩写，在 range 基础上扩展，生成的是 NumPy 数组（矩阵形式的可迭代对象）。
• 参数：arange(start, end, step)，与 range 用法类似：
  • start：起始值（包含）
  • end：结束值（不包含，左闭右开）
  • step：步长
• 示例：r1 = np.arange(0,9,3) 生成 [0 3 6]，即从 0 开始，每次加 3，直到小于 9。

np.linspace：生成等距数据

• 含义：linspace 是 "linear space" 的缩写，用于在指定区间内生成等间隔的数值。
• 参数：linspace(start, end, nums)：
  • start：起始值（包含）
  • end：结束值（包含，左右闭区间）
  • nums：生成的数值个数
• 示例：r2 = np.linspace(0,1,21) 会在 0 到 1 之间均匀生成 21 个数据，自动计算间隔（间隔为 (1-0)/(21-1) = 0.05）。

四.一维数组元素的选取与修改

import numpy as np

array1 = np.arange(1,9,1)
print(array1)

# 选取某个元素
a = array1[1]

# 选取某些元素
b = array1[[1,3,5]]

# 切片(左闭右开)
c = array1[0:6]
print(a,b,c)

# 修改某个元素
print(array1)
array1[0] = 10

# 批量修改某些元素
array1[[1,3,5]] = 20
print(array1)

array1[0:6] = 100
print(array1)

 

一维数组元素的选取

相关代码及说明如下：

python

运行

array1 = np.arange(1,9,1)  # 生成数组 [1 2 3 4 5 6 7 8]
a = array1[1]  # 选取索引为1的元素
b = array1[[1,3,5]]  # 选取索引为1、3、5的元素
c = array1[0:6]  # 切片选取（左闭右开，包含0到5索引的元素）

• 单个元素选取：通过 array1[索引] 实现，如 array1[1] 取索引 1 的元素，结果为 2。
• 多个元素选取：通过 array1[[索引1, 索引2, ...]] 实现，中括号内的列表表示要选取的多个索引，如 array1[[1,3,5]] 取索引 1、3、5 的元素，结果为 [2 4 6]。
• 切片选取：通过 array1[start:end] 实现（左闭右开），如 array1[0:6] 取索引 0 到 5 的元素，结果为 [1 2 3 4 5 6]。

一维数组元素的修改

相关代码及说明如下：

python

运行

array1[0] = 10  # 修改索引为0的元素
array1[[1,3,5]] = 20  # 批量修改索引1、3、5的元素
array1[0:6] = 100  # 切片批量修改元素

• 单个元素修改：通过 array1[索引] = 新值 实现，如 array1[0] = 10 后，数组首个元素变为 10。
• 多个元素批量修改：通过 array1[[索引1, 索引2, ...]] = 新值 实现，如 array1[[1,3,5]] = 20 后，索引 1、3、5 的元素均变为 20。
• 切片批量修改：通过 array1[start:end] = 新值 实现（左闭右开），如 array1[0:6] = 100 后，索引 0 到 5 的元素均变为 100。

 

五.二维数组元素的选取与修改

import numpy as np

array1 = np.arange(24).reshape(4,6)#创建 4 行 6 列二维数组 
print(array1)

# 选取某个元素，第 2 行第 5 列（索引从 0 开始 ）
a = array1[1,4]

# 选取某行元素，第 4 行所有列 
b = array1[3,:] 

# 选取某些行，连续行（0 到 2 行 ）
c = array1[0:2,:]
# 选取某些行，不连续行（0 和 2 行 ）
d = array1[[0,2],:]

# 选取某列，第 4 列所有行 
e = array1[:,3]

# 选取某些列，连续列（0 到 3 列 ）
f = array1[:,0:3]
# 选取某些列，不连续列（0 和 3 列 ）
g = array1[:,[0,3]]
print(a)
print(b)
print(c)
print(d)
print(e)
print(f)
print(g)

# 修改元素
# 修改某个元素，第 2 行第 5 列改为 100 
array1[1,4] = 100
print(array1)

# 修改某行元素，第 4 行所有列改为 100 
array1[3,:] = 100
print(array1)

# 修改某些行元素，0 和 2 行所有列改为 50 
array1[[0,2],:] = 50
print(array1)

 

二维数组元素的选取

（基于 4 行 6 列的二维数组array1 = np.arange(24).reshape(4,6)，索引从 0 开始，行在前、列在后，用逗号分隔）

1. 选取单个元素

• 代码：a = array1[1,4]
• 含义：逗号前1表示第 2 行，逗号后4表示第 5 列，即选取 “第 2 行第 5 列” 的元素（原数组中该位置值为 10）。

2. 选取某行元素

• 代码：b = array1[3,:]
• 含义：3表示第 4 行，:表示选取该行所有列，即 “第 4 行的全部元素”（原数组中为[18,19,20,21,22,23]）。

3. 选取某些行（连续 / 不连续）

• 连续行（0 到 2 行，不含第 2 行）：
  代码：c = array1[0:2,:]
  含义：0:2表示第 0 行和第 1 行，:表示所有列，即选取 “前 2 行的全部元素”。

• 不连续行（0 和 2 行）：
  代码：d = array1[[0,2],:]
  含义：[0,2]表示第 0 行和第 2 行（列表指定不连续行），:表示所有列，即选取 “这两行的全部元素”。

4. 选取某列元素

• 代码：e = array1[:,3]
• 含义：:表示所有行，3表示第 4 列，即选取 “第 4 列的全部元素”（原数组中为[3,9,15,21]）。

5. 选取某些列（连续 / 不连续）

• 连续列（0 到 3 列，不含第 3 列）：
  代码：f = array1[:,0:3]
  含义：:表示所有行，0:3表示第 0 到 2 列，即选取 “这三列的全部元素”。

• 不连续列（0 和 3 列）：
  代码：g = array1[:,[0,3]]
  含义：:表示所有行，[0,3]表示第 0 列和第 3 列（列表指定不连续列），即选取 “这两列的全部元素”。

二维数组元素的修改

（通过索引定位后直接赋值，规则与 “选取” 一致）

1. 修改单个元素

• 代码：array1[1,4] = 100
• 含义：将 “第 2 行第 5 列” 的元素改为 100。

2. 修改某行元素

• 代码：array1[3,:] = 100
• 含义：将 “第 4 行所有列” 的元素均改为 100。

3. 修改某些行元素

• 代码：array1[[0,2],:] = 50
• 含义：将 “第 0 行和第 2 行所有列” 的元素均改为 50。

总结：二维数组的选取和修改核心是通过 “行索引，列索引” 定位，:表示 “全部选取”，切片（start:end）用于连续索引，列表（[index1,index2]）用于不连续索引。

 

六.三维数组元素的选取与修改 

import numpy as np

array1 = np.arange(48).reshape(2,4,6)#创建 2 个 4 行 6 列的三维数组 
print(array1)

# 选取某个元素，第 2 个二维数组（索引 1 ）里第 1 行（索引 0 ）第 1 列（索引 0 ）
a = array1[1,0,0]

# 选取某行元素，第 1 个二维数组（索引 0 ）里第 2 行（索引 1 ）所有列 
b = array1[0,1,:]

# 选取某些行元素，连续行（第 1 个二维数组里 1 到 3 行 ）
c = array1[0,1:3,:]
# 选取某些行元素，不连续行（第 1 个二维数组里 1 和 3 行 ）
d = array1[0,[1,3],:]

# 选取某列，第 2 个二维数组（索引 1 ）里所有行的第 2 列（索引 1 ）
e = array1[1,:,1]

# 选取某些列，连续列（第 2 个二维数组里所有行的 1 到 4 列 ）
f = array1[1,:,1:4]
# 选取某些列，不连续列（第 2 个二维数组里所有行的 1 和 4 列 ）
g = array1[1,:,[1,4]]

# 修改元素，第 2 个二维数组里第 1 行第 1 列改为 100 
array1[1,0,0] = 100
print(array1)

v = np.array([array1,array1,array1,array1])
a= v[2,1,2: ,1:3]
print(a)

 

三维数组的创建

代码：array1 = np.arange(48).reshape(2,4,6)

• 含义：生成 48 个数据（0-47），重塑为三维数组，结构为「2 个 4 行 6 列的二维数组」（维度顺序：第 1 维 2 个元素，每个元素是 4 行 6 列的二维数组）。

三维数组元素的选取

（索引规则：[第1维索引, 第2维索引（行）, 第3维索引（列）]，:表示 “全部选取”，切片 / 列表表示 “部分选取”）

1. 选取单个元素

• 代码：a = array1[1,0,0]
• 含义：第 1 维索引 1（第 2 个二维数组）、第 2 维索引 0（第 1 行）、第 3 维索引 0（第 1 列），结果为 24（原数组中对应位置的值）。

2. 选取某行元素

• 代码：b = array1[0,1,:]
• 含义：第 1 维索引 0（第 1 个二维数组）、第 2 维索引 1（第 2 行）、所有列（:），结果为[6 7 8 9 10 11]。

3. 选取某些行（连续 / 不连续）

• 连续行：c = array1[0,1:3,:]
  含义：第 1 个二维数组中，第 2-3 行（索引 1 到 3，不含 3）的所有列，结果为该范围内的两行数据。
• 不连续行：d = array1[0,[1,3],:]
  含义：第 1 个二维数组中，第 2 行和第 4 行（索引 1、3）的所有列。

4. 选取某列元素

• 代码：e = array1[1,:,1]
• 含义：第 2 个二维数组（索引 1）中，所有行（:）的第 2 列（索引 1），结果为该列的所有值。

5. 选取某些列（连续 / 不连续）

• 连续列：f = array1[1,:,1:4]
  含义：第 2 个二维数组中，所有行的第 2-4 列（索引 1 到 4，不含 4）。
• 不连续列：g = array1[1,:,[1,4]]
  含义：第 2 个二维数组中，所有行的第 2 列和第 5 列（索引 1、4）。

三维数组元素的修改

• 代码：array1[1,0,0] = 100
• 含义：将第 2 个二维数组（索引 1）中第 1 行（索引 0）第 1 列（索引 0）的元素改为 100。

高维数组的扩展（以四维为例）

代码：v = np.array([array1,array1,array1,array1])（生成 4 个array1组成的四维数组）

• 选取示例：a = v[2,1,2: ,1:3]
  含义：第 3 个元素（索引 2）→ 第 2 个二维数组（索引 1）→ 从第 3 行开始的所有行（2:）→ 第 2-3 列（1:3），按维度顺序逐层定位即可。

总结：多维数组选取核心是「按维度顺序用逗号分隔索引」，:表全部选取，切片 / 列表表部分选取，规则可推广到任意高维。

 

七.数组的组合 

import numpy as np

# 生成基数组
array1 = np.arange(9).reshape(3,3)
array2 = 2*array1
print(array1)
print(array2)

# 水平组合
a3 = np.hstack((array1,array2))
a4 = np.hstack((array2,array1))
a5 = np.hstack((array1,array2,array1))

# concatenate 连接，axis=0 表示按行方向（垂直方向？这里原注释描述可能有误，axis=0 实际是垂直堆叠，axis=1 是水平堆叠 ，需注意 ）
a6 = np.concatenate((array1,array2),axis=0)

# 垂直组合
a7 = np.vstack((array2,array1))

a8 = np.concatenate((array1,array2),axis=0)
print(1)

 

数组（矩阵）的组合方法

（基于 3 行 3 列的基础矩阵array1和array2，其中array2 = 2 * array1，即每个元素为array1对应元素的 2 倍）

1. 水平组合（按列拼接，横向扩展）

• 函数：np.hstack()
• 作用：将多个矩阵按水平方向（列方向）拼接，行数不变，列数累加。
• 示例：

  python

  运行

  a3 = np.hstack((array1, array2))  # 拼接array1和array2，结果为3行6列
  a5 = np.hstack((array1, array2, array1))  # 拼接3个矩阵，结果为3行9列
  

• 说明：hstack的参数是一个元组（包含待拼接的矩阵），h对应 “horizontal（水平）”，拼接后矩阵横向扩展。

2. 垂直组合（按行拼接，纵向扩展）

• 函数：np.vstack()
• 作用：将多个矩阵按垂直方向（行方向）拼接，列数不变，行数累加。
• 示例：

  python

  运行

  a7 = np.vstack((array2, array1))  # 拼接array2和array1，结果为6行3列
  

• 说明：v对应 “vertical（垂直）”，拼接后矩阵纵向扩展。

3. 通用拼接函数np.concatenate()

• 作用：通过axis参数指定拼接方向，功能与hstack/vstack一致，更灵活。
• 参数：axis=0表示垂直拼接（行方向，同vstack）；axis=1表示水平拼接（列方向，同hstack）。
• 示例：

  python

  运行

  a6 = np.concatenate((array1, array2), axis=0)  # axis=0：垂直拼接，6行3列
  a8 = np.concatenate((array1, array2), axis=1)  # axis=1：水平拼接，3行6列
  

总结：矩阵组合核心是方向控制 —— 水平组合（列扩展）用hstack或concatenate(axis=1)，垂直组合（行扩展）用vstack或concatenate(axis=0)。

八.numpy 内数组元素的切割

import numpy as np

array1 = np.arange(16).reshape(4,4)
print(array1)

# 水平切割，hsplit 按水平方向（列方向）切割，分成 2 等份 
a = np.hsplit(array1,2)
# split 实现水平切割，axis=1 表示列方向 
b = np.split(array1,2,axis=1)

# 垂直切割，vsplit 按垂直方向（行方向）切割，分成 2 等份 
c = np.vsplit(array1,2)
# split 实现垂直切割，axis=0 表示行方向 
d = np.split(array1,2,axis=0)

# 强制切割（不等份切割 ）
# 水平强制切割，axis=1 列方向，分成 3 份（不等份 ）
e = np.array_split(array1,3,axis=1)

# 垂直强制切割，axis=0 行方向，分成 3 份（不等份 ）
f = np.array_split(array1,3,axis=0)


array1 = np.arange(25).reshape(5,5)
print(array1)

# 水平强制切割，axis=1 列方向，分成 3 份（不等份 ）
g = np.array_split(array1,3,axis=1)

# 垂直强制切割，axis=0 行方向，分成 3 份（不等份 ）
h = np.array_split(array1,3,axis=0)

 

九.数组的算数运算

import numpy as np

array1 = np.arange(1, 5, 1).reshape(2, 2)
array2 = 2 * array1
print(array1)
print(array2)

# 数组的加法【对应位置的元素求和】
print(array1 + array2)

# 数组的减法[对应位置元素相减]
print(array1 - array2)

# 数组的乘法【对应位置相乘】
print(array1 * array2)

# 数组的除法[对应位置相除]
print(array1 / array2)

# 数组的取余(%)
print(array2 % array1)

# 数组的取整
print(array1 // array2)

十. 数组的深拷贝与浅拷贝

import numpy as np

array1 = np.array([1, 2, 3])
# 浅拷贝
array2 = array1

# 更改array2的元素的值
array2[0] = 100
print(array2)
print("######################")
print(array1)

# 深拷贝
array3 = array1.copy()
array3[0] = 10
print(array3)
print("######################")
print(array1)

十一.numpy 内的随机模块 (一).py

import random
import numpy as np
import matplotlib.pyplot as plt
"""
randint(start,end):
产生一个随机整数
(0,10) ->左闭右开的区间
"""
# 随机种子
np.random.seed(1000)  # random 矩阵类型随机
r1 = np.random.randint(0, 10)
print(r1)

a = []
for i in range(100):
    a0 = np.random.randint(0, 10)
    a.append(a0)
print(a)
plt.hist(a, color='r')  # 绘制直方图
plt.show()

numpy 内的随机模块 (二) 

import numpy as np
"""
rand() ->(0,1)之间的随机浮点数
"""
# np.random.seed(100)
r1 = np.random.rand()
print(r1)

"""
normal() ->生成一些符合正态分布的数据
N~(0,1)
numpy.random.normal(loc=0.0, scale=1.0, size=None)
参数说明:
loc: 正态分布的均值(期望值), 决定了分布的中心位置, 默认值为 0.0
scale: 正态分布的标准差, 决定了分布的离散程度, 默认值为 1.0
size: 输出数组的形状, 可以是整数(表示一维数组长度)或元组(表示多维数组形状), 默认值为 None(返回单个值)
"""
r2 = np.random.normal()
print(r2)

##########################
# 生成随机数矩阵
r3 = np.random.randint(0, 10, size=(5, 5))
print(r3)

r4 = np.random.rand(5, 5)
print(r4)

r5 = np.random.normal(5, 10, size=(5, 5))
print(r5)

 十二.numpy 内一些函数的使用

import numpy as np

array1 = np.random.normal(size=(3, 3))
print(array1)

# 一些函数
# 求方差
print(array1.var())

# 求标准差
a = array1.std()

# 求均值
b = array1.mean()

# 求和
c = array1.sum()

# 求中位数
# array1.median()
d = np.median(array1)

# 求和运算
# 对矩阵的行求和
e = array1.sum(axis=1)
# 对矩阵的列进行求和
f = array1.sum(axis=0)

十二.矩阵的运算

import numpy as np

# 生成两个基数组
a = np.arange(4).reshape(2, 2)
b = a.copy()

# 矩阵的运算
# 加减乘除(求逆)
# 加减 ->对应元素加减

# 矩阵的乘法【点乘】
# a * b
a1 = a.dot(b)
a2 = np.dot(a, b)

# 矩阵求逆
"""
inv():
并不是所有的矩阵都有逆;
即使你没有逆, 给你一个逆【伪逆】
"""
a3 = np.linalg.inv(a)

a4 = a.dot([[-1.5, 0.5],
            [1., 0.]])
print(a4)

 numpy 文件读写示例

# numpy.loadtxt(): 从文本文件中加载数据。这个函数假定文件中的每一行都有相同数量的值,
# 你可以使用 delimiter 参数指定分隔符, 如逗号、制表符等。例如:
import numpy as np

data = np.loadtxt('datingTestSet2.txt', delimiter='\t')
print(data)

# 将数组保存到txt文件中
import numpy as np

array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])  # 创建一个 NumPy 数组
np.savetxt('array.txt', array)  # 使用 savetxt() 将数组保存到文本文件中