NumPy_numpy库-优快云博客

本文链接：https://blog.youkuaiyun.com/Emliafight/article/details/146769942

第三方库-NumPy

1.基础

1.1概念

python的第三方库，主要用来计算、处理一维或多维数组
在数组算术计算方面， NumPy 提供了大量的数学函数
NumPy 的底层主要用 C语言编写，因此它能够高速地执行数值计算
NumPy 还提供了多种数据结构，这些数据结构能够非常契合的应用在数组和矩阵的运算上

1.2优点

NumPy 是 Python 科学计算基础库
NumPy 可以对数组进行高效的数学运算
NumPy 的 ndarray 对象可以用来构建多维数组
NumPy 能够执行傅立叶变换与重塑多维数组形状
NumPy 提供了线性代数，以及随机数生成的内置函数

1.3与python列表的区别

NumPy 数组是同质数据类型（homogeneous），即数组中的所有元素必须是相同的数据类型。数据类型在创建数组时指定，并且类型都相同。

Python 列表是异质数据类型（heterogeneous），即列表中的元素可以是不同的数据类型。列表可以包含整数、浮点数、字符串、对象等各种类型的数据。

NumPy 数组提供了丰富的数学函数和操作，如矩阵运算、线性代数、傅里叶变换等。

Python 列表提供了基本的列表操作，如添加、删除、切片、排序等。

1.4导入库

pip install numpy==1.26.0 -i https://pypi.tuna.tsinghua.edu.cn/simple/

2.ndarray

numpy定义的一个n维数组对象，即ndarray，数组中的每个元素都占有大小相同的内存块，同样也可以使用索引或切片

使用方式:

ndarray 是通过 array 函数或其他 NumPy 函数（如 zeros、ones、arange 等）创建的。
array 函数接受一个序列作为输入，并返回一个 ndarray 对象。

2.1 array()

使用array方法来创建ndarray对象

语法：

numpy.array(object, dtype = None, copy = True, order = None,ndmin = 0)
object：数组序列
dtype：更改数据类型(可选)
copy：是否能被复制(默认True)
order：以哪种方式来排列数组(C行/F列/A默认)(可选)
ndmin：指定维度(可选))

示例：

import numpy as np

arr1=np.array(object=[1,2,3,4],dtype=np.int32,order='F')
print(arr1) #[1 2 3 4],用array创建的数组是以空格作为分割符的

arr2=np.array(object=[1,2,3,4],ndmin=2)
print(arr2) #[[1 2 3 4]],二维数组，有两个中括号

2.2 zeros()

创建指定大小的数组，数组元素以 0 来填充

语法：

numpy.zeros(shape, dtype = float, order = 'C')
shape：数组形状，返回一个元组，保存数组几行几列

示例：

arr3 = np.zeros(shape=(2, 3), dtype='i1', order='C')
print(arr3) #[[0 0 0][0 0 0]],表示；两行三列

arr2=np.array(object=[1,2,3,4],ndmin=2)
print(arr2.shape) #(1,4)

2.3 ones()

创建指定形状的数组，数组元素以 1 来填充

语法：

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

示例：

arr4=np.ones(shape=(3,3),dtype='i1',order='C')
print(arr4) #[[1 1 1][1 1 1][1 1 1]]

2.4 full()

full()用于创建一个填充指定值的数组。

语法：

numpy.full(shape, fill_value, dtype=None, order='C')
fill_value:选择要填充的值，相当于上面zeros和ones的一个通用方法

2.5 arange()

arange() 函数用于创建一个等差数列的数组。类似于 range() 函数，但返回的是一个 NumPy 数组而不是一个列表。

语法：

numpy.arange(start, stop, step, dtype)
start：开始值
stop：结束值(不包含)
step：步长

示例：

arr5=np.arange(0,10,1)
print(arr5) #[0 1 2 3 4 5 6 7 8 9]

创建一个0-20的只有奇数的数组
arr5=np.arange(1,20,2)
print(arr5) #[ 1  3  5  7  9 11 13 15 17 19]

2.6linspace

在指定的数值区间内，返回均匀间隔的一维等差数组，默认均分 50 份，相当于更细致详细的arange函数

语法：

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

start：起始值：默认为 0
stop：终止值（默认包含）
num：表示数值区间内要生成多少个均匀的样本，默认值为 50，这个值为(start+stop)/(num-1)
endpoint：默认为 True，表示数列包含 stop 终止值，反之不包含
retstep表示是否返回步长。如果为 True，则返回一个包含数组和步长的元组；如果为 False，则只返回数组。默认为 False。

示例：

arr6=np.linspace(0,5,6)
print(arr6) #[0. 1. 2. 3. 4. 5.]

3.数据类型

NumPy 提供了比 Python 更加丰富的数据类型，如下所示：

序号	数据类型	语言描述
1	bool_	布尔型数据类型（True 或者 False）
2	int_	默认整数类型，类似于 C 语言中的 long，取值为 int32 或 int64
3	intc	和 C 语言的 int 类型一样，一般是 int32 或 int 64
4	intp	用于索引的整数类型（类似于 C 的 ssize_t，通常为 int32 或 int64）
5	int8	代表与1字节相同的8位整数。值的范围是-128到127
6	int16	代表 2 字节（16位）的整数。范围是-32768至32767
7	int32	代表 4 字节（32位）整数。范围是-2147483648至2147483647
8	int64	表示 8 字节（64位）整数。范围是-9223372036854775808至9223372036854775807
9	uint8	1字节（8位）无符号整数
10	uint16	2 字节（16位）无符号整数
11	uint32	4 字节（32位）无符号整数
12	uint64	8 字节（64位）无符号整数
13	float_	float64 类型的简写
14	float16	半精度浮点数，包括：1 个符号位，5 个指数位，10个尾数位
15	float32	单精度浮点数，包括：1 个符号位，8 个指数位，23个尾数位
16	float64	双精度浮点数，包括：1 个符号位，11 个指数位，52个尾数位
17	complex_	复数类型，与 complex128 类型相同
18	complex64	表示实部和虚部共享 32 位的复数
19	complex128	表示实部和虚部共享 64 位的复数
20	str_	表示字符串类型，等价于unicode_
21	bytes_	表示字节串类型，基于字节
22	string_	表示字节串类型，等价于`bytes_`，基于字节，NumPy 2.0以后版本被移除，使用`bytes_`代替
23	unicode_	表示字节串类型，基于字符，NumPy 2.0以后版本被移除，使用str_`代替

3.1 数据类型对象

数即前面的 dtype 对象，用来描述与数组对应的内存区域如何使用。

可以在创建数组时指定 dtype 参数来定义数组中元素的数据类型。

3.2数据类型标识码（了解即可）

NumPy 中每种数据类型都有一个唯一标识的字符码，int8, int16, int32, int64 四种数据类型可以使用字符串 ‘i1’, ‘i2’,‘i4’,‘i8’ 代替

详情见表…

4数组属性

4.1 shape

返回一个元组，元组中的每个元素表示数组在对应维度上的大小。元组的长度等于数组的维度数。

功能：

返回一个由数组维度构成的元组
通过赋值，可以用来调整数组维度的大小

arr7=np.array([1,2,3,4,5,6])
print(arr7.shape) #(6,) #一维数组的时候，这个值仅代表元素的个数
arr7.shape=(2,3)
print(arr7) #[[1 2 3][4 5 6]]

4.2 数组维度

它通常在 numpy.array() 函数中使用。通过 ndmin，你可以确保生成的数组至少具有指定的维度。

arr8= np.array([1, 2, 3, 4], ndmin=2)
print("ndim 查看维度：", arr8.ndim) #ndim 查看维度： 2

4.3 flags

flags 属性功能：

返回 ndarray 数组的内存信息

flags 属性功能：
   返回 ndarray 数组的内存信息
def flags_test():
    array_one = np.array([[1,2,3],[4,5,6]])
    print('array_one 数数组的内存信息：\n',array_one.flags)

输出：

C_CONTIGUOUS : True #行模式
F_CONTIGUOUS : False #列模式
OWNDATA : True
WRITEABLE : True
ALIGNED : True
WRITEBACKIFCOPY : False

5.切片

和列表类似，但是不同的是numpy可以分行列进行切片

5.1切片操作

array(行，列),在行和列的部分分别使用切片的操作

示例：

arr1=np.array([[1,2,3],[4,5,6],[7,8,9]])
#查询第一行数据
print(arr1[0,...]) #[1,2,3]
#查询第二行，第三列的数据
print(arr1[1,2]) #6

省略号 … 的作用

表示所有维度: 省略号用于表示数组的所有维度。例如，array[…, 1] 表示取所有行的第 1 列。
简化多维切片: 在多维数组中，省略号可以简化切片操作

6.高级索引

指使用整数数组、布尔数组或者其他序列来访问数组的元素。相比于基本索引，高级索引可以访问到数组中的任意元素，并且可以用来对数组进行复杂的操作和修改

6.1整数数组索引

使用一个数组来访问另一个数组的元素。这个数组中的每个元素都是目标数组中某个维度上的索引值。

示例：

arr1=np.array([[1,2,3],[4,5,6],[7,8,9]])
print(arr1)
#取出数组中的数据5，6，7
print(arr1[[1,1,2],[1,2,0]]) #[5 6 7]

取出 3 * 3 数组四个角的数据：

arr1=np.array([[1,2,3],[4,5,6],[7,8,9]])
print(arr1)
#取出 3 * 3 数组四个角的数据：
print(arr1[[0,0,2,2],[0,2,0,2]]) #[1,3,7,9]
#也可以使用反向索引
print(arr1[[0,0,-1,-1],[0,-1,0,-1]]) #[1,3,7,9]

6.2布尔数组索引

布尔索引通过布尔运算（如：比较运算符）来获取符合指定条件的元素的数组。

一维：

arr=np.array([1,2,3,4,5,6,7,8,9])
bool_idx = arr > 6
print(bool_idx)  # 输出: [False False False False False  False  True  True  True]

# 使用布尔索引获取满足条件的元素
re = arr[bool_idx]
print(re)  # 输出: [ 7  8  9]

多维：

arr=np.array([[1,2,3],[4,5,6],[7,8,9]])
bool_idx = arr > 6
print(bool_idx)  # 输出: [[False False False] [False False False][ True  True  True]]

# 使用布尔索引获取满足条件的元素
re = arr[bool_idx]
print(re)  # 输出: [7  8  9]

切片：

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

# 1. 索引第3个元素大于3的所有行
print(arr[arr[:, 1] > 6]) #[[7 8 9]]

# 2. 索引第2行大于4的所有的元素所在的列
print(arr[:, arr[1] > 4]) #[[2 3][5 6][8 9]]

注：以上bool表达式的判定都可以使用逻辑运算符(&,|,~),与python不一样，与c一样

7.广播（重要）

广播（Broadcast）是 numpy 对不同形状（shape）的数组进行数值计算的方式。若各维度的长度不相同，可以通过广播机制，将小维度(小的维度必须为1)重复对应缺失位扩张到大维度

广播规则

维度匹配：如果两个数组的维度数不同，维度数较少的数组会在前面补上长度为 1 的维度。

arr1= np.array([[1, 2, 3], [4, 5, 6]]) #形状(2，3)
arr2=np.array([10,10,10]) #形状(3,),可以看成一行，3列，但实际只有一个维度
arr3=arr1+arr2
print(arr3) #[[11 12 13] [14 15 16]]

形状匹配：如果两个数组在某个维度上的长度不同，但其中一个数组在该维度上的长度为 1，则该数组会沿着该维度进行广播。

arr1 = np.array([[1], [2]])  # 形状: (2, 1)
arr2 = np.array([10, 20, 30])  # 形状: (3,)
arr3 = arr1 + arr2
print(arr3) #[[11 21 31] [12 22 32]]

多维与标量匹配：标量是指只有一个值

arr = np.array([1, 2, 3])
# 1自动广播为[1 1 1]
result = arr + 1
print(result)  # 输出: [2 3 4]

不匹配：如果两个数组在某个维度上的长度既不相同也不为 1，则广播失败，抛出 ValueError。

arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# 创建一个形状为 (2, 3) 的二维数组
arr2d_broadcast = np.array([[10, 20, 30], [40, 50, 60]])

# 尝试相加
try:
    result = arr2d + arr2d_broadcast
except ValueError as e:
    print(e)  # 输出: operands could not be broadcast together with shapes (3,3) (2,3)

8.数组遍历

8.1 遍历数组的第一维度

arr1= np.array([[1, 2, 3], [4, 5, 6]]) #形状(2，3)
for i in arr1:
    print(i)#[1 2 3][4 5 6]

for i in arr: 遍历数组的第一维度，即按行或列的顺序逐个访问元素。

返回的是数组的子数组（如行或列），而不是单个元素。

8.2 nditer逐个访问元素

nditer是numpy强大的迭代器对象，内涵多个控制参数

1.order参数：‘C’(行风格)，‘F’(列风格)

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

# 使用 C 风格遍历数组
for x in np.nditer(arr, order='C'):
    print(x)
# 输出:
# 1
# 2
# 3
# 4
# 5
# 6

# 使用 Fortran 风格遍历数组
for x in np.nditer(arr, order='F'):
    print(x)
# 输出:
# 1
# 4
# 2
# 5
# 3
# 6

2.flags参数（指定迭代器的额外行为）

multi_index: 返回每个元素的多维索引。

arr = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])

it=np.nditer(arr,flags=['multi_index'])

for i in it:
    print(i,it.multi_index)
#输出
1 (0, 0, 0)
2 (0, 0, 1)
3 (0, 1, 0)
4 (0, 1, 1)
5 (1, 0, 0)
6 (1, 0, 1)
7 (1, 1, 0)
8 (1, 1, 1)

external_loop: 返回一维数组而不是单个元素，减少函数调用的次数，从而提高性能

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

it=np.nditer(arr,flags=['external_loop'])

for i in it:
    print(i)
#输出[1 2 3 4 5 6 7 8 9]，返回了一个一维数组

9.数组操作

9.1数组降维

函数名称	函数介绍
reshape	在不改变数组元素，返回一个视图，仅修改数组的形状
flat属性	返回是一个迭代器，可以遍历
flatten	以一维数组的形式返回一份原数组的副本，不会影响到原数组
ravel	与 flatten不同的点是，它返回的是数组视图（修改视图会影响原数组）

9.1.1 reshape()

reshape()函数可以在不改变原数组数据的情况下，改变数组的形状
返回的新数组是原数组的一个视图，形状和维度可以不一样，但是新数组修改数据会影响原数组
元素总数必须匹配：新形状中的元素总数必须与原数组中的元素总数相同。

示例：

arr1= np.array([1,2,3,4,5,6])
arr2=arr1.reshape(2,3)
print("修改前的原数组",arr1) #修改前的原数组 [1 2 3 4 5 6]
arr2[0,0]=0
print("修改后的新数组",arr2) #修改后的新数组 [[0 2 3] [4 5 6]]
print("修改后的原数组",arr1) #修改后的原数组 [0 2 3 4 5 6]，原数组也被修改了

#-1，占位符，numpy自动计算行/列的数量，即维度
arr1= np.array([1,2,3,4,5,6])
arr2=arr1.reshape(2,-1)
print(arr2) #[[1 2 3] [4 5 6]]

#利用arange和reshape直接生成一个(3,3)的矩阵
arr=np.arange(1,10).reshape(3,3)
print(arr)

9.1.2 flat属性

返回是一个迭代器，可以使用for循环遍历

arr=np.arange(1,10).reshape(3,3)
for i in arr.flat:
    print(i,end=' ')
print() #1 2 3 4 5 6 7 8 9

9.1.3 flatten()

数组的深复制，以一维数组的形式返回一份原数组的副本，不会影响到原数组

arr1=np.arange(1,10).reshape(3,3)
arr2=arr1.flatten()
print(arr2) #[1 2 3 4 5 6 7 8 9]
arr2[0]=0
print(arr2) #[0 2 3 4 5 6 7 8 9]
print(arr1) #[[1 2 3] [4 5 6] [7 8 9]]，原数组没有被修改

9.1.4 ravel()

数组的浅复制，它返回的是数组视图（修改视图会影响原数组）

arr1=np.arange(1,10).reshape(3,3)
arr2=arr1.ravel()
print(arr2) #[1 2 3 4 5 6 7 8 9]
arr2[0]=0
print(arr2) #[0 2 3 4 5 6 7 8 9]
print(arr1) #[[0 2 3] [4 5 6] [7 8 9]]，原数组被修改了

9.2矩阵转置

函数名称	说明
transpose	将数组的维度值进行对换，比如二维数组维度(1,4)使用该方法后为(4,1)
ndarray.T	一种类属性，与 transpose 方法相同

示例：

arr=np.arange(1,7).reshape(2,3)
print(arr.T)
print(np.transpose(arr)) 
#[[1 4]
 #[2 5]
 #[3 6]]，输出都为(3,2)的数组

9.3升维和降维

多维数组（也称为 ndarray）的维度（或轴）是从外向内编号的。这意味着最外层的维度是轴0，然后是轴1，依此类推。

函数名称	参数	说明
expand_dims(arr, axis)	arr：输入数组 axis：新轴插入的位置	在指定位置插入新的轴，从而扩展数组的维度
squeeze(arr, axis)	arr：输入数的组 axis：取值为整数或整数元组，用于指定需要删除的维度所在轴，指定的维度值必须为 1 ，否则报错；若为 None，则删除数组维度中所有为 1 的项	删除数组中维度为 1 的项

增加数组维度：

arr=np.array([1,2,3])
arr1=np.expand_dims(arr,axis=0) #行升维
print(arr1) #[[1 2 3]]
arr2=np.expand_dims(arr,axis=1) #列升维
print(arr2) #[[1][2][3]]

适应广播操作：

arr=np.array([1,2,3])
x=2
arr1=np.expand_dims(arr+2,axis=0)
print(arr1) #[[3 4 5]]

移除长度为1的维度：

arr=np.array([[[1,2,3]]])
print(arr.shape) #(1, 1, 3)

#按最外层轴0降维
arr1=np.squeeze(arr,axis=0)
print(arr1) #[[1 2 3]]

#按最外层轴1降维
arr2=np.squeeze(arr,axis=1)
print(arr2) #[[1 2 3]]

#按最内层轴2降维
#arr3=np.squeeze(arr,axis=2)
#print(arr3) #报错，最内层的维不为1

#不输入axis的值，即None
arr2=np.squeeze(arr,axis=None)
print(arr2) #[1 2 3]

9.4连接数组

函数名称	参数	说明
hstack(tup)	tup：可以是元组，列表，或者numpy数组，返回结果为numpy的数组	按水平顺序堆叠序列中数组（列方向），要求列数一致
vstack(tup)	tup：可以是元组，列表，或者numpy数组，返回结果为numpy的数组	按垂直方向堆叠序列中数组（行方向），要求行数一致

示例：

#行数一致
arr1=np.array([[1,2],[3,4]]) #(2,2)
arr2=np.array([[5],[6]]) #(2,1)
arr3=np.hstack((arr1,arr2))
print(arr3) #[[1 2 5][3 4 6]]

#列数一致
arr1=np.array([[1,2],[3,4]]) #(2,2)
arr2=np.array([[5,6]]) #(1,2)
arr3=np.vstack((arr1,arr2))
print(arr3) #[[1 2][3 4][5 6]]

9.5分割数组

函数名称	参数	说明
hsplit(arr, index)	arr：原数组 index：按列分割的索引位置	将一个数组水平分割为多个子数组（按列），返回一个数组存放分割后的数组
vsplit(arr, index)	arr：原数组 index：按行分割的索引位置	将一个数组垂直分割为多个子数组（按行），返回一个数组存放分割后的数组

示例：

#按垂直方向切割（列索引）
arr=np.arange(1,10).reshape(3,3)
arr1=np.hsplit(arr,[1])
print(arr1)
#[array([[1],
       [4],
       [7]]), array([[2, 3],
       [5, 6],
       [8, 9]])]
#按水平方向切割（行索引）
arr=np.arange(1,10).reshape(3,3)
arr2=np.vsplit(arr,[1])
print(arr2)
#[array([[1, 2, 3]]), array([[4, 5, 6],
       [7, 8, 9]])]

9.6矩阵运算

函数名称	说明
np.dot	通用的点积函数，适用于多种维度的数组
np.matmul	是专门用于矩阵乘法的函数，适用于二维及更高维度的数组
np.linalg.det	计算一个方阵（行数和列数相等的矩阵）的行列式。

9.6.1 dot

通用的点积函数，适用于多种维度的数组。

对于一维数组（向量），np.dot 计算的是向量的点积（内积）。
对于二维数组（矩阵），np.dot 等价于矩阵乘法，需要保证第一个数组的列和第二个数组的行相同。

示例：

#一维数组
arr1=np.array([1,2,3])
arr2=np.array([4,5,6])
x=np.dot(arr1,arr2)
print(x) #32
#二维数组
arr1=np.array([[1,2],[3,4],[5,6]]) #(3,2)
print(arr1)
arr2=np.array([[1,2,3],[4,5,6]]) #(2,3)
print(arr2)
x=np.dot(arr1,arr2)
print(x)
#输出
[[ 9 12 15]
 [19 26 33]
 [29 40 51]]

9.6.2 matmul

是专门用于矩阵乘法的函数，适用于二维及更高维度的数组

示例：

arr1=np.array([[1,2],[3,4],[5,6]]) #(3,2)
print(arr1)
arr2=np.array([[1,2,3],[4,5,6]]) #(2,3)
print(arr2)
x=np.matmul(arr1,arr2)
print(x)
#输出
[[ 9 12 15]
 [19 26 33]
 [29 40 51]]

9.6.3 linalg.deg

计算一个方阵（行数和列数相等的矩阵）的行列式。

示例：

#2*2
arr1=np.array([[1,2],[3,4]]) #(2,2)
x=np.linalg.det(arr1)
print(x) #-2.0000000000000004，有误差，可以使用round来取整

#3*3
arr1=np.array([[1,2,3],[4,5,6],[7,8,9]]) #(2,2)
x=np.linalg.det(arr1)
print(x) #0.0

10.数组元素的操作

10.1 resize

函数名称	参数	说明
resize(arr, new_shape)	arr：操作的数组 new_shape：返回的数组的形状，如果元素数量不够，重复数组元素来填充新的形状	返回指定形状的新数组

示例：

arr=np.arange(1,7).reshape(2,3)
print(np.resize(arr,(3,4)))
#输出，新数组为(3，4)，数组元素不足12个，用原数组的元素按顺序重复补齐
[[1 2 3 4]
 [5 6 1 2]
 [3 4 5 6]]

10.2 append

函数名称	参数	说明
append(arr, values, axis=None)	values：向 arr 数组中添加的和 arr 数组的形状一致的元素 axis：默认为 None，返回的是一维数组；当 axis =0 时，追加的值会被添加到行，而列数保持不变，若 axis=1 则反之	在数组的末尾添加值，返回一个一维数组

示例：

import numpy as np

arr1=np.array([[1,2], [3,4],[5,6]])
#axis=None或不指定，返回一个一维数组
arr2=np.append(arr1,[0,0,0],axis=None)
print(arr2) #[1 2 3 4 5 6 0 0 0]

#axis=0,按行添加
#添加的元素的维度必须与原数组的维度相同才能添加
#arr3=np.append(arr1,[0,0],axis=0) #报错，维度不一致
arr3=np.append(arr1,[[0,0]],axis=0)
print(arr3)
#输出
[[1 2]
 [3 4]
 [5 6]
 [0 0]]

#axis=1,按列添加
#添加的元素的形状必须与原数组相同才能添加
#arr4=np.append(arr1,[[0,0],[0,0]],axis=1) #报错，形状不一致
arr4=np.append(arr1,[[0,0],[0,0],[0,0]],axis=1)
print(arr4)
#输出
[[1 2 0 0]
 [3 4 0 0]
 [5 6 0 0]]

10.3 insert

函数名称	参数	说明
insert(arr, index, values, axis)	index：表示索引值，在该索引值之前插入 values 值 values：要插入的值 axis同理	沿规定的轴将元素值插入到指定的元素前

示例：

import numpy as np
#一维数组
arr1=np.array([1,2,3,4,5,6])
arr2=np.insert(arr1,1,0)
print(arr2) #[1 0 2 3 4 5 6]
#二维数组
arr1=np.array([[1,2,3],[4,5,6]])
arr2=np.insert(arr1,1  ,[0,0,0],axis=0) #在第二行前插入数组[0,0,0]
print(arr2)
arr1=np.array([[1,2,3],[4,5,6]])
arr2=np.insert(arr1,1  ,0,axis=0) #在第二行前插入标量1，广播自动扩增
print(arr2)

10.4 delete

函数名称	参数	说明
delete(arr, index, axis)	index：表示索引值，要删除数据的索引 axis同理	删掉某个轴上的子数组，并返回删除后的新数组

示例：

#一维数组

arr1=np.array([1,2,3,4,5,6])
arr2=np.delete(arr1,[0,5])
print(arr2) #[2,3,4,5]

#二维及多维数组
import numpy as np

arr1=np.array([[1,2,3],[4,5,6]])
arr2=np.delete(arr1,1 ,axis=0)
print(arr2) #[[1,2,3]]

10.5 argwhere

返回数组中非 0 元素的索引，若是多维数组则返回行、列索引组成的索引坐标
与前面的nditer遍历的参数flags='multi_index’作区分，这个主要用来取出非0元素的坐标
也可以使用布尔索引来取，来设定条件取值

示例：

import numpy as np

arr1=np.array([[0,1,2],[0,3,4],[0,5,6]])
arr2=np.argwhere(arr1)
print(arr2)
#输出
[[0 1]
 [0 2]
 [1 1]
 [1 2]
 [2 1]
 [2 2]]

**拓展：**argmax():找列表里最大值的索引值

import numpy as np
#一维
arr1=np.array([0,1,2,3,4,5,6])
arr2=np.argmax(arr1)
print(arr2) #6
#二维
arr1=np.array([[0,1,2],[0,3,4],[0,5,6]])
arr2=np.argmax(arr1,axis=0)
print(arr2) #[0 2 2]

拓展：where():和argwhere类似，但返回的是由行列组成的元组

10.6 unique

函数名称	参数	说明
unique(arr, return_index=False, return_inverse=False, return_counts=False, axis=None)	return_index：如果为 True，则返回新数组元素在原数组中的位置（索引） return_inverse：如果为 True，则返回原数组元素在新数组中的位置（逆索引） return_counts：如果为 True，则返回去重后的数组元素在原数组中出现的次数	数组去重，删掉某个轴上的子数组，并返回删除后的新数组

案例1：返回唯一元素的索引

import numpy as np
arr = np.array([0, 1, 1, 2, 3, 4, 4, 5])
unique_elements, index = np.unique(arr, return_index=True)
print(unique_elements) #[0 1 2 3 4 5]，去重后的数组
print(index) #[0 1 3 4 5 7]，索引值

案例2：返回唯一元素及其逆索引

import numpy as np
arr = np.array([0, 1, 1, 2, 3, 4, 4, 5])
unique_elements, re_index = np.unique(arr, return_inverse=True)
print(unique_elements) #[0 1 2 3 4 5]
print(re_index) #[0 1 1 2 3 4 4 5]

案例3：返回唯一元素的计数

import numpy as np
arr = np.array([0, 1, 1, 2, 3, 4, 4, 5])
unique_elements, counts = np.unique(arr, return_counts=True)
print(unique_elements)
print(counts)

对于多维数组，unique 函数同样适用。默认unique 函数会将多维数组展平为一维数组，然后查找唯一元素。

import numpy as np

arr = np.array([[1,2],[2,3],[3,4]])
unique_elements = np.unique(arr)
print(unique_elements) #[1,2,3,4]

11.统计函数

numpy里有很多统计函数，这里仅列出一部分

11.1 amin() 和 amax()

计算数组沿指定轴的最小值与最大值，并以数组形式返回
对于二维数组来说，axis=1 表示沿着水平方向，axis=0 表示沿着垂直方向

示例：

import numpy as np

arr = np.array([[1,2,30],[0,3,10],[3,4,20]])
#垂直方向，axis=0
print(np.amin(arr,axis=0))
print(np.amax(arr,axis=0))
#水平方向，axis=1
print(np.amin(arr,axis=1))
print(np.amax(arr,axis=1))
#axis=None，变成一维来求
print(np.amax(arr,axis=None))

11.2 ptp()

计算数组元素中最值之差值，即最大值 - 最小值
对于二维数组来说，axis=1 表示沿着水平方向，axis=0 表示沿着垂直方向

示例：

import numpy as np

arr = np.array([[1,2,3],[4,5,6]])
#垂直方向，axis=0
print(np.ptp(arr,axis=0)) #[3 3 3]
#水平方向，axis=1
print(np.ptp(arr,axis=1)) #[2 2]
#axis=None，变成一维来求
print(np.ptp(arr,axis=None)) #5

11.3 median()

用于计算中位数，中位数是指将数组中的数据按从小到大的顺序排列后，位于中间位置的值。如果数组的长度是偶数，则中位数是中间两个数的平均值。

#为奇数的几种情形：
arr = np.array([[1,2,3],[4,5,6],[7,8,9]])
print(np.median(arr)) #5.0
print(np.median(arr,axis=0)) #[4. 5. 6.]
print(np.median(arr,axis=1)) #[2. 5. 8.]

#为偶数的几种情形：
arr = np.array([[1,2,3,4],[4,5,6,7],[7,8,9,10]])
print(np.median(arr)) #5.5
print(np.median(arr,axis=0)) #[2.5 5.5 8.5]
print(np.median(arr,axis=1)) #[4. 5. 6. 7.]

11.4 mean()

沿指定的轴，计算数组中元素的算术平均值（即元素之总和除以元素数量）

import numpy as np

arr = np.array([[1,2,3],[4,5,6],[7,8,9]])
print(np.mean(arr,axis=None)) #5.0
print(np.mean(arr,axis=0)) #[4. 5. 6.]
print(np.mean(arr,axis=1))#[2. 5. 8.]

11.5 average()

加权平均值是将数组中各数值乘以相应的权数，然后再对权重值求总和，最后以权重的总和除以总的单位数（即因子个数）；根据在数组中给出的权重，计算数组元素的加权平均值。该函数同样可以接受一个轴参数 axis。

 arr = np.array([1, 2, 3, 4, 5])
 # 创建权重数组
weights = np.array([0.1, 0.2, 0.3, 0.2, 0.2])
# 使用 np.average 计算加权平均值
average_value = np.average(arr, weights=weights)
print(average_value) # 3.2

11.6 var()

NumPy 的设计目标是处理实际数据集，而不是概率分布。

np.var 函数默认计算的是总体方差，而不是**样本方差，**若要改变计算方式，则需要改变参数ddof的值。

总体方差：

arr = np.array([1,2,3,4,5,6,7,8,9])
print(np.var(arr,ddof=0)) #6.666666666666667

样本方差：

在样本数据中，样本均值的估计会引入一定的偏差。通过使用 n−1作为分母，可以校正这种偏差，得到更确的总体方差估计。

arr = np.array([1,2,3,4,5,6,7,8,9])
print(np.var(arr,ddof=1)) #7.5

11.7 std()

标准差是方差的算术平方根，用来描述一组数据平均值的离散程度。

arr = np.array([1,2,3,4,5,6,7,8,9])
print(np.std(arr)) #2.581988897471611