1 数组基础

1.1 Numpy简介

NumPy是Python的一个基础科学计算包，是许多高级的第三方科学计算的模块，如：Matplotlib、Pandas等，都是基于NumPy所构建的。它包含以下几个特点：

1. 强大的多维数组功能。
2. 精细而复杂的功能。
3. 用于集成C / C ++和Fortran代码的工具。
4. 实用的线性代数，傅里叶变换和随机数功能。

在使用数组前，必须首先导入Numpy模块。导入格式：
      import numpy as np

1.2 Numpy数组基础

      数组是Numpy中的核心类型，全称为N维数组（N-dimensional Array, ndarray），整个Numpy模块都是围绕数组来构建的，它是一个固定大小和形状的大数据集容器，该对象由两部分组成：

1. 实际的数据；
2. 描述这些数据的元数据；

大部分的数组操作仅仅修改元数据的部分，而不改变底层的实际数据。

      Numpy.array和标准的Python库中的Array.array是不一样的，标准的Python库中的Array.array只能处理一维数组，且所有元素的类型必须是一致的，支持的数据类型有整型、浮点型以及复数型，但这些类型不能够满足科学计算的需求，因此Numpy中添加了许多其他的数据类型，如bool、int、int64、float32、complex64等。

      同时，NumPy数组有许多特有的属性。（见下表）

同学们可能会有疑问：创建一个数组arr = [ 1,2, 3], 我们想查看他的属性时需要调用内置函数 len(), dir() 来查看，这些函数后面都有括号；但是使用 .size 和 .shap 时却不用带括号

解答： 大家可以想一想我们学过的类，我们创建的类有方法和属性，方法是函数，属性就是一个变量；假设我们创建一个类和对象，A a，访问函数(方法)时用 a.Fun(), 访问变量(属性)时用 a.n 。
      在Python中，len() 是一个内置函数，用于获取序列（如列表、字符串、元组等）的长度。因此，你需要使用括号来调用这个函数，因为它需要执行一些内部操作来计算长度。
      而在NumPy中，.shape 和 .size 是数组对象的属性，而不是方法。属性是用来存储数据或状态信息的，因此不需要括号来调用。

代码演示：

#在使用数组前，必须首先导入NumPy模块。导入格式：
import numpy as np

#定义一个数组
arr = np.array([[1,2,3],[4,5,6]])#注意，是[数组，数组]

print(arr) #打印出数组
print(f'数组的维度：{arr.ndim}') #数组的维度
print(f'数组形状：{arr.shape}') #数组的形状，几行几列
print(f'数组的个数：{arr.size}') #数组元素的个数
print(f'数组元素的类型：{arr.dtype}') #数组元素类型
print(f'元素所占字节：{arr.itemsize}') #元素所占字节
print(f'数组所占内存大小：{arr.nbytes}') #数组所占内存大小

a = np.array([[i for i in range(5)],[i for i in range(1,6)]])
print(arr)
print(f'数组的维度：{a.ndim}') #数组的维度
print(f'数组的形状：{a.shape}') #数组的形状，几行几列
print(f'数组的大小：{a.size}') #数组元素的个数

1.3 创建数组

1.3.1 使用np.array()函数生成数组

      利用np.array()函数来创建，函数的参数可以是元组、列表，也可是另一个数组。语法格式为：
X = np.array(list/tuple) 或者 X = np.array(list/tuple, dtype = np.dtype)

注：当np.array()不指定dtype时，NumPy将根据数据情况自动匹配一个dtype类型。
注：若数值类型不同时，会将其合并为类型范围较大的一种

代码演示：

print("自动匹配类型：")
a = np.array([[i for i in range(5)],[i for i in range(1,6)]])
print(a)
print(f'数组的维度：{a.ndim}') #数组的维度
print(f'数组的形状：{a.shape}') #数组的形状，几行几列
print(f'数组的大小：{a.size}') #数组元素的个数
print(f'数组元素的类型：{a.dtype}')
print('')

print("自定义的类型：")
arr = np.array([[1,2,3],(1,2,3)], dtype = np.float32)
print(arr)
print(f'维度：{arr.ndim}')
print(f'形状：{arr.shape}')
print(f'大小：{arr.size}')
print(f'数组元素的类型：{arr.dtype}')

#注：若数值类型不同时，会将其合并为类型范围较大的一种

1.3.2 利用内置函数产生特定形式的数组

1.3.2.1 简单内置函数

代码演示：

print(np.arange(5))
print("")
print(np.zeros((2,2)))
print("")
print(np.ones((3,3)))
print("")
print(np.full((3,3),6))
print("")
print(np.eye(4))

1.3.2.2 特殊内置函数

1. np.arange()函数

语法：X = np.arange([start, stop, step, dtype=None )
注：np.arange()函数可以产生一个等距数组（左闭右开[ ,)域 ），其中：[ ] 内的内容可省略，start的默认值为0，step的默认值为1。故而，参数个数可以为1个、2个或3个。

代码演示：

arr1 = np.arange(6)
print(f'np.arange(6):{ arr1}')

arr2 = np.arange(1,6)
print(f'np.arange(1, 6):{ arr2}')

arr3 = np.arange(2, 7, 2)
print(f'np.arange(1, 7, 2):{ arr3}')

2. np.linspace() 函数

语法：X = np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
注：Numpy中的linspace 函数可以用来创建由等差数列构成的一维数组。

数据类型	说明
start	序列的起始值
stop	序列的终止值,如果endpoint=Ture,该值包含于数列中
num	要生成的等步长的样本数量，默认为50
endpoint	该值为Ture时，数列中包含stop值，反之则不包含，默认值为True
retstep	如果为True时，生成的数组中会显示间距，反之不显示
dtype	ndarray的数据类型

代码演示：

arr1 = np.linspace(1,10,10)
print(f"起始值为1，终止值为10，元素个数为10：{arr1}")

arr2 = np.linspace(1,1,10)
print(f"数组元素全部为1，个数为10的数列：{arr2}")

arr3 = np.linspace(10,20,5)
print(f'取终止值20：{arr3}')

arr4 = np.linspace(10,20,5,endpoint = False)
print(f'不取终止值20：{arr4}')

arr5 = np.linspace(1,6,6).reshape(2,3)
print(f'将数组设置为 2行3列 :')
print(arr5)

3. np.empty() 函数

注：X = np.empty(n)函数是生成一个指定形状和类型且全为空的数组，该函数只是让系统分配指定大小的内容，而并没有初始化，里面的值是随机的。n为生成数组元素的个数。

代码演示：

arr1 = np.empty(2)
print(arr1)

1.3.3 生成随机数组

1. numpy.random.rand(d0, d1, …, dn)函数
   注：创建给定形状的数组，并使用[0.0, 1.0)上均匀分布的随机浮点数填充该数组。当函数没有参数时，返回一个随机浮点数，当函数有一个参数时，返回该参数长度大小的一维随机浮点数数组，当函数有两个及以上参数时，则返回对应维度的数组。
2. numpy.random.randint(low, high=None, size=None, dtype=int)函数
   注：返回随机整数数组，数据值位于半开区间 [low, high)。可以用size设置数组的形状，例如，若size为(m,n,k)，则绘制mnk形状的样本。size默认值为“None”，在这种情况下，将返回单个值。
3. numpy.random. randn(d0, d1, …, dn)函数
   注：返回一个或一组服从标准正态分布的随机样本值。当函数没有参数时，则返回一个浮点数，当函数有一个参数时，则返回秩为1的数组，不能表示向量和矩阵，当函数有两个及以上参数时，则返回对应维度的数组，能表示向量或矩阵。
   此外，np.random.standard_normal()函数与np.random.randn()类似，但是np.random.standard_normal()的输入参数为元组（tuple）。
4. numpy.random.shuffle(x) 函数
   注：类似洗牌操作，修改参数x。参数x为要洗牌的数组、列表或可变序列。
5. numpy.random.permutation(x)函数
   注：随机排列一个序列，或返回一个排列的范围。如果x是一个多维数组，则它只会沿着其第一个索引移动。

代码演示：

arr1 = np.random.rand(5)
print(f"rand()生成长度为5的一维随机浮点数数组：{arr1}")
print('')
arr2 = np.random.rand(3,2)
print(f"rand()生成三行两列的随机小数数组:")
print(arr2)
print('')
arr3 = np.random.randint(1,5,size = (2,3))
print(f"randint()生成2行3列的从[1，5）之间取的整数数组：{arr3}")
print('')
arr4 = np.random.randn(10)
print(f"randn()生成一组符合标准正态分布的随机样本值：{arr4}")
print('')
arr5 = np.arange(10)
np.random.shuffle(arr5)
print(f"打乱数组的顺序：{arr5}")
print('')
arr7 = np.arange(10)
arr8 = np.random.permutation(arr7)
print(f"返回对arr7随机排序的结果：{arr8}")

1.4 数组的数据类型

      当使用元组或列表时作为创建数组的参数时，若数据类型不同，会将其类型统一为类型范围较大的一种，即当传入的数据有多种类型时，NumPy会自动进行判断，将数组转化为最为通用的类型。

代码演示：

arr = np.array([[1,2,3],[6,7,8],(1.1, 2.2, 3.3)])
print(arr.dtype)

1.5 数组的迭代

1. 一维数组：迭代返回对应数组中的每一个元素。

代码演示：

arr1 = np.array([1, 2, 3])
print("一维数组迭代：")
for i in arr1:
    print(i)

2. 多维数组：迭代返回值是一个维度减一的数组。

代码演示：

print("二维数组迭代：")
arr2 = np.array([[1, 2, 3],[4, 5, 6],[7, 8, 9]])
print(f"数组：{arr2}")
print("一次迭代：")
for i in arr2:
    print(i)

3. 多维数组：可以进行列迭代和逐个元素迭代。

arr3 = np.array([[1, 2, 3],[4, 5, 6],[7, 8, 9]])
print(f"数组：{arr3}")
print("列迭代和逐个元素迭代：")
for i in arr3.flat:
    print(i)

1.6数组的索引和切片

1.6.1 一维数组的索引

一维数组的索引与列表类似，不仅支持单个元素的索引，还支持负数索引与切片，负索引或切片后得到的结果仍是一个数组，可以进行数组的相关操作。
代码演示：

arr = np.arange(0,10)
print("不含步长：")
print(f"数组元素：{arr}")
print(f"单个元素的索引，索引第二个元素：{arr[1]}：")
print(f"从第二到倒数第一个元素，不包括最后一个元素：{arr[1: -1]}") #[]左闭右开
print(f"从索引1到索引9：{arr[1: 8]}")
print(f"从索引2到终止：{arr[2: ]}")
print(f"从开始到倒数第二个数：{arr[ : -1]}")
print("")
print("含步长：")
print(f"取索引2开始到索引10截止，步长为2：{arr[2: 10: 2]}")

s = slice(2, 10, 2)
print(f"使用slice函数切片：{arr[s]}")

1.6.2 多维数组的索引

• 单个元素：array[行数][列数]
• 某一行元素：array[行数：] 或 array[行数：]
• 某一列元素：array[：，列数]
• 某几行和某几列：
• [起始行：终止行，起始列：终止列]

代码演示：

arr = np.arange(9).reshape(3,3)
print("数组为：")
print(arr)
print(f"打印数组的1行且1列的元素：{arr[1][1]}")
print(f'打印数组2，3行且2列的元素：{arr[1:3,1]}') # : 两侧是左闭右开
print(f'打印第2列的所有元素：{arr[ : ,2]}')
print(f"打印1-2行和1-2列的元素：\n", arr[0:2,0:2])

1.7 多维数组的合并和拆分

1.7.1 合并

1. 在水平方向上，一般采用 hstack() 函数实现两个数组的合并。
   具体语法为：np. hstack((a,b))。
   此外，concatenate(axis=1)函数和column_stack()函数可以实现类似的效果。

代码演示：

arr1 = np.array([[1,1,1],[3,3,3]])
arr2 = np.array([[2,2,2],[4,4,4]])
arr3 = np.hstack((arr1,arr2))
print(f"水平方向的合并：{arr3}")
print(f"采用concatenate方法在水平方向合并数组：{np.concatenate((arr1, arr2), axis = 1)}")
print(f"采用column_stack方法在水平方向合并数组：{np.column_stack((arr1, arr2))}")

2. 在竖直方向上一般采用vstack()函数实现两个数组的合并。
具体语法为：np. vstack((a,b))。
当参数axis设置为0时，concatenate()函数可以得到同样的结果。row_stack()函数亦如是。除此之外，还有一种是深向合并的操作，它是沿着第三个坐标轴的方向来合并，使用到的函数是dstack()。

代码演示：

arr3 = np.array([[1,1,1],[3,3,3]])
arr4 = np.array([[2,2,2],[4,4,4]])
arr5 = np.vstack((arr3,arr4))
print(f"使用vstack，竖直方向的合并：{arr5}")

arr6 = np.dstack((arr3,arr4))
print(f"使用dstack，数组的深向合并：\n",arr6)

1.7.2 拆分

• 水平拆分：对于一个n*m的数组，可以沿着水平方向将其拆分为m部分，并且各部分的大小和形状完全相同： hsplit()、 split(axis=1)
• 竖向拆分：对于一个n*m的数组，也可以沿着竖向(按行)将其拆分为n部分，并且各部分的大小和形状完全相同：vsplit()、split(axis=0)
• 深向拆分：对于一个n*m的数组，也可以沿着深向将其拆分为n部分：dsplit()

arr = np.arange(12).reshape(3,4)
print(f"采用hsplit函数实现水平拆分（按列拆分）：\n",np.hsplit(arr,2)) #拆分成每行两列
print(f"采用vsplit函数实现竖直拆分（按行拆分）：\n",np.vsplit(arr, 1))#拆分成每列一行
print(f"采用axis=0的split实现竖直拆分（按行拆分）：\n",np.split(arr,1,axis = 0))

2 数组的相关操作

2.1 统计相关操作

Numpy 提供了很多统计函数，可以支持对数组的多种统计操作。
例如，从数组中查找最小元素，最大元素，计算均值、标准差和方差等。

常见的统计函数及说明见表：

代码演示：

arr = np.arange(12).reshape(3,4)
np.random.shuffle(arr)
print(f"对所有元素求和：{arr.sum()}")
print(f"对指定维数求和，返回一个数组：{arr.sum(axis= 1)}")
print(f"最大值：{arr.max()}, 最小值：{arr.min()}")
print(f"数组中的元素沿axis=1方向的最大值：{arr.max(axis=1)}")
print(f"数组中anxis=0轴方向的最大值和最小值的差：{arr.ptp(axis=0)}")
print(f"最大值的位置：{arr.argmax()}, 最小值的位置：{arr.argmin()}")
print(f"平均值：{arr.mean()}")
print(f"所有元素求积：{arr.prod()}")
print(f"标准差：{arr.std()}, 方差：{arr.var()}")
print("-----------")
a = np.array([[1,2,3],[4,5,6]])
print(f"指定权重数组，调用averge()函数的，沿axis=1计算数组中元素的加权平均值：{np.average(a,axis = 1,weights = a)}")
print(f"调用std()函数，计算数组标准差：{np.std(a)}")

2.2 形状相关操作

2.2.1 修改数组自身形状

.shape属性
代码演示：

arr1 = np.arange(10)
arr1.shape = 2,5
print(f"shap 直接在原数组上修改：{arr1}")

2.2.2 修改数组形状（不修改自身）

reshape()方法也可以实现类似.shape属性的效果，但是它不改变原数组的形状，并返回一个新的数组。注意：形状参数必须与数组大小一致，否之会抛出异常。
reshape()方法可以接受一个“-1”作为参数，当某一维度是-1时，Numpy会自动根据其他维度来计算这一维度的大小。
代码演示：

arr2 = np.arange(9)
arr3 = arr2.reshape(3,3)
print(f"原数组arr2：{arr2}")
print(f"修改后的数组arr3：\n",arr3)

arr4 = arr2.reshape(-1, 3)
print(f"使用-1，系统自动根据其他参数匹配维度：\n",arr4)

print("------")
arr5 = np.arange(6)
arr6 = arr5.reshape(-1,3)
print(f"原数组arr4：{arr5}")
print(f"当参数为-1时，其他维度自动计算大小：\n",arr6)

2.2.3 改变数组自身形状的方法

.resize() 方法的作用与reshape()方法的功能一致，但改变原来数组的形状。它的原理是首先将原来数组转变为一维数组，再判断元素的个数，若缺失，则缺失元素 以0补全；若过满，则只截取所需元素，从而实现对数组形状的修改。
注意：.resize()方法不支持-1参数。

代码演示：

arr1 = np.arange(10)
arr1.resize(2,5)
print(arr1)

arr1.resize(4,4)
print(f"元素过多以0补全：{arr1}")

2.2.4 数组的转置

对于数组而言，转置可以通过 .T 属性和 .transpose() 方法实现。一般情况下，这两种方法是等价的。对一维数组而言，转置返回它的本身；对于二维数组而言，转置相当于将其行列互换；对于多维数组而言，转置是将所有的维度反向，原来的第一维变为最后一维，原来的最后一维变成第一维。

代码演示：

arr1 = np.arange(12)
arr1.resize(3,4)
print(arr1)
print('------------------')
print('arr1.T 转置后：')
arr2 = arr1.T
print(arr2)

print('------------------')
print('arr1.transport() 转置后：')
arr3 = arr1.transpose()
print(arr3)

2.2.5 数组的降维

1. 数组的降维是针对多维数组而言的，可以利用 .flat 属性得到数组中的一个一维引用数组，同时，此属性支持修改对应数值，从而使原数组的对应位置有相应的改变。
2. .flatten() 方法和 .revel() 方法也可以实现将数组返回一维化的结果，但是.flatten()方法返回的是原数组的一个复制，修改它对原数组不产生影响。.revel()方法是返回引用，只有在必要时返回复制。

# .flat 先把数组都变成一维，支持修改对应数值
arr1 = np.arange(10).reshape(2,5)

print("原数组：\n", arr1)
print(f"打印arr1.flat[-1]: { arr1.flat[-1]}")

arr1.flat[-1] = 100
print(f"采用arr1.flat[-1]=100修改后打印arr1：\n", arr1)

arr2 = arr1.flatten()
print(f"采用flatten方法实现数组一维化：{arr2}")

2.3 数组的四则运算、点乘与比较操作

2.3.1 数组的四则运算

1. 数组与数字之间的四则运算，规则是数组元素分别对应进行相应运算。
2. 数组与数组之间也可以进行四则运算，前提是参与运算的数组需有相同的行列。运算规则是按位运算，对应位置进行运算。此外，数组还支持幂运算、取余和取整运算。

代码演示：

arr1 = np.array([[1,2,3],[4,5,6]])
arr2 = np.array([[1,2,3],[4,5,6]])
print('arr1:\n',arr1)
print("arr2: \n",arr2)
#所有元素+2，加减乘除都一样
print(f"arr1所有元素+2：\n",arr1+2)
#所有元素+2，加减乘除都一样
print("两个数组相减：\n",arr1 - arr2)
print("arr1**arr2 (arr1对应位置上arr2的次幂)：\n", arr1**arr2)
print("arr1 % arr2(取余运算)：\n",arr1 % arr2)
print("arr1 // arr2(取整运算)：\n", arr1//arr2)

2.3.2 点乘

在数学上，二维数组可以看成矩阵，一维数组可以看成向量，它们还支持点乘运算，用.dot()函数实现。

代码演示：

arr1 = np.array([[1,2,3],[4,5,6]])
arr2 = np.array([[1,2,3],[4,5,6]])
print('arr1:\n',arr1)
print("arr2: \n",arr2)
print(" arr1.dot(arr2.T) (.dot()函数实现矩阵乘法):\n", arr1.dot(arr2.T))

2.3.3 比较操作

数组还支持其他运算，例如，比较和逻辑操作。在比较操作中，数组可以与一个数进行比较，会返回一个布尔型的数组；数组与数组之间也可以进行比较，返回一个布尔型数组。

代码演示：

arr1 = np.array([[1,2,3],[4,5,6]])
arr2 = np.array([[4,5,6],[1,2,3]])
print('arr1:\n',arr1)
print("arr2: \n",arr2)
print("arr1>3(数组与一个数进行比较)：\n", arr1>3)
print("arr1>arr2(数组与数组比较)：\n", arr1 > arr2)

3 数组读写

3.1 数据的读取

从文本文件中读取数据： np.loadtxt()函数 。语法格式为：
*numpy.loadtxt(fname, dtype=<class ‘float’>, comments=‘#’, delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0, encoding=‘bytes’, max_rows=None, , like=None)

数据类型	说明
frame	文字、字符串或产生器，可以是.gz 或 .bz2 的压缩文件
dtype	结果数据的数据类型；默认值为float
delimiter	分隔字符串，默认是空格
skiprows	指跳过前n行，包括注释；默认值为0
usecols	要读取的列，0是第一列。例如，usecols=（1,4，5）将提取第2、第5和第6列。默认值“None”将读取所有列
unpack	如果为True，读入属性将分别写入不同变量

1. 数据的分隔字符为空格

代码演示：

s = np.loadtxt('test.txt')
print(f"读取的数据类型为：{s.dtype}")
print(f"读取的数据内容为：{s}")

2. 数据的分隔字符为 ‘ ，’
   如果文件中的数据不是空格分隔，可以设置参数delimiter指定分隔符。
   

s = np.loadtxt('test.txt',delimiter = ',')
print(f"读取的数据类型为：{s.dtype}")
print(f"读取的数据内容为：{s}")

3. 文件中含有字符串数组
   如果文件中的含有字符串的数组，可以加上一个参数值。
   
   代码演示：

s = np.loadtxt('test.txt',str)
print(f"读取的数据类型为：{s.dtype}")
print(f"读取的数据内容为：{s}")

4. 文件中包含字符串和数值型的混合数据,可以如下指定数据类型进行读取。

s = np.loadtxt('test.txt',skiprows = 1,dtype = {'names':('name','age','number'),'formats':('S10','i4','f4')})
print(f"读取的数据类型为：{s.dtype}")
print(f"读取的数据内容为：{s}")

3.2 数据的写入

将数组写入文件：np.savetxt()，
写入时默认使用科学记数法的形式保存数字。语法格式如下：
np.savetxt(fname, X, fmt=‘%.18e’, delimiter=’ ‘, newline=’\n’, header=‘’, footer=‘’, comments='# ', encoding=None)

数据类型	说明
frame	文字、字符串或产生器，可以是.gz 或 .bz2 的压缩文件
X	一维或二维数组，即要保存到文本文件的数据
fmt	单一格式（如10.5f）、格式序列或多格式字符串
delimiter	分隔字符串，默认是空格

1. 使用默认参数写入

代码演示：

arr = np.array([[1,2,3],[4,5,6]])
np.savetxt("test.txt",arr)

2. 可以使用fmt参数设置数据写入的格式

代码演示：

arr = np.array([[1,2,3],[4,5,6]])
np.savetxt("test.txt",arr,fmt = "%d")

3. 可以用delimiter参数指定分隔符

代码演示：

arr = np.array([[1,2,3],[4,5,6]])
np.savetxt("test.txt",arr,fmt = "%d",delimiter = ',')