小白认识numpy库，保姆级讲解（主要讲解在人工智能方面）

最新推荐文章于 2025-07-19 16:30:00 发布

头发不掉光

最新推荐文章于 2025-07-19 16:30:00 发布

阅读量1k

点赞数 31

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/m0_74994555/article/details/143123885

python 同时被 3 个专栏收录

2 篇文章

订阅专栏

numpy

1 篇文章

订阅专栏

人工智能

1 篇文章

订阅专栏

NumPy (Numerical Python) 是一个用于科学计算的核心库，提供了支持高效数组和矩阵运算的功能。它是 Python 生态系统中数据处理的基础工具，尤其在数据科学、机器学习和人工智能领域，具有重要地位。下面请跟随我一起来了解它：

1.概念

(1) NumPy 的全称是“ Numeric Python”，它是 Python 的第三方扩展包，主要用来计算、处理一维或多维数组,下面是安装numpy库的指令：

pip install numpy

(2)在数组算术计算方面， NumPy 提供了大量的数学函数
(3)NumPy 的底层主要用 C语言编写，因此它能够高速地执行数值计算
(4)NumPy 还提供了多种数据结构，这些数据结构能够非常契合的应用在数组和矩阵的运算上

2. 与python列表区别

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

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

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

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

3. array创建对象

通过 NumPy 的内置函数 array() 可以创建 ndarray 对象，其语法格式如下：

numpy.array(object, dtype = None, copy = True, order = None,ndmin = 0)

参数说明：

序号	参数	描述说明
1	object	表示一个数组序列
2	dtype	可选参数，通过它可以更改数组的数据类型
3	copy	可选参数，表示数组能否被复制，默认是 True
4	order	以哪种内存布局创建数组，有 3 个可选值，分别是 C(行序列)/F(列序列)/A(默认)
5	ndmin	用于指定数组的维度

案例：

import numpy as np

# 创建一个一维数组
def np_array():
    arr = np.array([1,2,3,4,5])
    print(arr)

if __name__ == '__main__':
    np_array()

dtype参数

import numpy as np
def np_array():
    arr = np.array([1,2,3,4,5],dtype=bool)
    print(arr)
    #查看数据类型
    print('查看类型:',arr.dtype)

if __name__ == '__main__':
    np_array()

2.2 ndim指定/查看数组维度

数组的维度就是一个数组中的某个元素，当用数组下标表示的时候，需要用几个数字来表示才能唯一确定这个元素，这个数组就是几维

案例：

import numpy as np
def np_array():
    #二行*三列的二维数组
    arr = np.array([[1,2,3],
                    [4,5,1]],
                   dtype=int)
    print(arr)
    print('查看维度:',arr.ndim)

if __name__ == '__main__':
    np_array()

2.3 reshape数组变维

reshape() 函数允许你在不改变数组数据的情况下，改变数组的维度。

reshape() 返回的是一个新的数组，原数组不会被修改。reshape() 可以用于多维数组，例如将一个一维数组重塑为二维数组。

元素总数必须匹配：新形状中的元素总数必须与原数组中的元素总数相同。

例如，一个长度为6的一维数组可以被重塑为 (2, 3) 或 (3, 2)，但不能被重塑为 (2, 2)。

案例：

将二维数组改变为三维数组：

import numpy as np
def np_array():
    #二行*三列的二维数组
    #从外到内，最外层的中括号叫做轴0（axis=0）,内层的中括号叫做轴1（axis=1），内层的数据元素叫列，以此类推
    #对于二维数组，最外层的中括号可以理解为矩阵的行，内层的中括号可以理解为矩阵的列
    arr = np.array([[1,2,3],
                    [4,5,1]],
                   dtype=int,ndmin = 3)
    print(arr)
    print('查看维度:',arr.ndim)

if __name__ == '__main__':
    np_array()

3.数组属性

3.1 shape

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

shape 属性功能：

未传入参数，返回一个由数组维度构成的元组
传入参数，可以用来调整数组维度的大小

import numpy as np
#改变数组的形状，eg：将1维数组变为2维数组
def np_reshape():
    arr1 = np.array([1,2,3,4,5,6,7,8])
    #reahape表示修改数组的形状，例如：（2,3）表示为2行3列
    #reshape((2,4)的数量要与原数组的个数相同
    arr1.shape = (2, 4)  # 这里修改为 2 行 4 列
    print(arr1)

if __name__ == '__main__':
    np_reshape()

如果使用shape属性修改数组的形状，则修改的是原数组的形状，reshape修改数组的形状会返回一个新数组，不修改原数组的形状。

3.2 itemsize

itemsize 属性功能：

返回数组中每个元素的大小（以字节为单位）

def item_size():
    arr = np.array([[1,2,3,4],
                    [5,6,7,8],
                    [9,10,11,12]],dtype='i1')
    print(arr.itemsize)
    print(arr.dtype)

if __name__ == '__main__':
    item_size()

3.3 flags

flags 属性功能：

返回 ndarray 数组的内存信息

'''
    flags 属性功能：
        1、返回 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

4.创建数组的其他方法

4.1 empty()

empty() 方法用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组（数组元素为随机值）

格式：

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

参数	描述
shape	数组的形状，可以是整数或整数元组
dtype	数组的数据类型，默认为 float
order	数组的内存布局，有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序

案例：

def arr_empty():
    arr = np.empty((2,3),dtype='i2')
    print(arr)

if __name__ == '__main__':
    arr_empty()

4.2 zeros()

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

格式：

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

参数	描述
shape	数组形状
dtype	数据类型，可选
order	‘C’ 用于 C 的行数组，或者 ‘F’ 用于 FORTRAN 的列数组

案例：

def arr_zeros():
    err = np.zeros((2,3),dtype='i4',order = 'C')
    print(err)

if __name__ == '__main__':
    arr_zeros()

4.3 ones()

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

格式：

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

参数	描述
shape	数组形状
dtype	数据类型，可选
order	‘C’ 用于 C 的行数组，或者 ‘F’ 用于 FORTRAN 的列数组

案例：

def arr_ones():
    err = np.ones((2,3),dtype='i4',order = 'C')
    print(err)

if __name__ == '__main__':
    arr_ones()

4.4 arange()

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

格式：

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

根据 start 与 stop 指定的范围以及 step 设定的步长，生成一个 ndarray。

参数	描述
start	起始值，默认为 0
stop	终止值（不包含）
step	步长，默认为 1
dtype	返回 ndarray 的数据类型，如果没有提供，则会使用输入数据的类型

案例1：

import numpy as np

# 创建一个从 0 到 9 的数组
arr = np.arange(10)

print(arr)
# 输出:
# [0 1 2 3 4 5 6 7 8 9]


**注意：**

- arange() 函数生成的数组不包含 stop 值。
- 如果 step 为负数，则 start 必须大于 stop，否则生成的数组为空。
- arange() 函数在处理浮点数时可能会出现精度问题，因为浮点数的表示和计算存在精度误差。

说明：以上几个函数通常用于创建数字类型的数组，也可以用于创建布尔、字符串等类型的数组。但更适合用于创建数字数组。

5.切片

ndarray 对象的内容可以通过索引或切片来访问和修改，与 Python 中 list 的切片操作一样；

slice()

在 Python 中，slice 可以作为一个对象来使用。你可以创建一个 slice 对象，然后使用它来获取序列的片段。

参数：

start 是切片开始的位置（包含该位置）。
stop 是切片结束的位置（不包含该位置）。
step 是切片的步长，即选取元素的间隔。

案例：

import numpy as np

'''
    slice 函数：
        1、从原数组的上切割出一个新数组
'''
def slice_test():
    array_one = np.array([1,2,3,4])
    print("array_one 数组内容：",array_one)
    result = slice(0,len(array_one),2)
    print("slice 截取 array_one 数组内容：",array_one[result])

slice 操作也可通过 [start:stop:step] 的形式来实现

import numpy as np

def two():
    array_one = np.array([[1, 2, 3], [4, 5, 6]])
    print(array_one)
    print(array_one[..., 1])  # 第2列元素
    print(array_one[1,...]) # 第2行元素
    print(array_one[1:2, 1:2])  # 第2行第2列元素
    print(array_one[..., 1:])  # 第2列及剩下的所有元素

冒号 : 的作用

表示范围: 冒号用于表示一个范围。例如，array[1:3] 表示从索引 1 到索引 3（不包括 3）的元素。
表示所有元素: 单独使用冒号表示所有元素。例如，array[:, 1] 表示所有行的第 1 列。
步长: 双冒号后面可以跟一个步长值，表示每隔多少个元素取一个。例如，array[::2] 表示每隔一个元素取一个。

注：冒号对于一维数组按索引号截取，二维数组按行和列截取。

省略号 … 的作用

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

6.高级索引

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

6.1 整数数组索引

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

案例：

import numpy as np

def one():
    array_one = np.array([[1,2,3],[4,5,6]])
    print(array_one)
    # [0,1,0]代表行索引、[0,1,2]代表列索引；即取出索引坐标 (0,0)、(1,1)、(0,2) 的元素
    array_one = array_one[[0,1,0],[0,1,2]]
    print(array_one)

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

import numpy as np

def two():
    array_one = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]])
    print('原数组：\n',array_one)
    array_one = array_one[[0,0,-1,-1], [0,-1,0,-1]]
    print('这个数组的四个角元素是：')
    print(array_one)

6.2 布尔索引

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

案例1：一维数组的布尔索引

import numpy as np

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

# 使用布尔索引筛选大于 5 的元素
bool_idx = arr > 5
print(bool_idx)  # 输出: [False False False False False  True  True  True  True  True]

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

案例2：多维数组的布尔索引

import numpy as np

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

# 使用布尔索引筛选大于 5 的元素
bool_idx = arr > 5
print(bool_idx)
# 输出:
# [[False False False]
#  [False False  True]
#  [ True  True  True]]

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

案例3：

使用逻辑运算符（如 &、|、~）组合多个条件。

import numpy as np

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

# 使用布尔索引筛选大于 5 且小于 9 的元素
bool_idx = (arr > 5) & (arr < 9)
print(bool_idx)  # 输出: [False False False False False  True  True  True False False]

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

逻辑运算符：

&：与运算，组合多个条件。
|：或运算，组合多个条件。
~：非运算，取反条件。

7.广播

广播（Broadcast）是 numpy 对不同形状（shape）的数组进行数值计算的方式，对数组的算术运算通常在相应的元素上进行。这要求维数相同，且各维度的长度相同，如果不相同，可以通过广播机制，这种机制的核心是对形状较小的数组，在横向或纵向上进行一定次数的重复，使其与形状较大的数组拥有相同的维度。

广播规则

维度匹配：如果两个数组的维度数不同，维度数较少的数组会在前面补上长度为 1 的维度。
长度匹配：如果两个数组在某个维度上的长度不同，但其中一个数组在该维度上的长度为 1，则该数组会沿着该维度进行广播。
不匹配：如果两个数组在某个维度上的长度既不相同也不为 1，则广播失败，抛出 ValueError。

案例1：一维数组与标量相加

import numpy as np

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

# 标量相加
result = arr + 1

print(result)  # 输出: [2 3 4]

标量 1 被广播到与 arr 相同的形状，然后进行逐元素相加。

案例2：二维数组与一维数组相加

import numpy as np

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

# 创建一个一维数组
arr1d = np.array([10, 20, 30])

# 相加
result = arr2d + arr1d

print(result)
# 输出:
# [[11 22 33]
#  [14 25 36]]

arr1d 被广播到与 arr2d 相同的形状，然后进行逐元素相加。

案例3：二维数组与二维数组相加

import numpy as np

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

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

# 相加
result = arr2d + arr2d_broadcast

print(result)
# 输出:
# [[11 22 33]
#  [14 25 36]]

arr2d_broadcast 被广播到与 arr2d 相同的形状，然后进行逐元素相加。

案例4：广播失败

import numpy as np

# 创建一个二维数组
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.迭代数组

nditer 是 NumPy 中的一个强大的迭代器对象，用于高效地遍历多维数组。nditer 提供了多种选项和控制参数，使得数组的迭代更加灵活和高效。

控制参数

nditer 提供了多种控制参数，用于控制迭代的行为。

1.order 参数

order 参数用于指定数组的遍历顺序。默认情况下，nditer 按照 C 风格（行优先）遍历数组。

C 风格（行优先）: order=‘C’
Fortran 风格（列优先）: order=‘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 参数

flags 参数用于指定迭代器的额外行为。

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

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

    # 使用 nditer 遍历数组并获取多维索引
    it = np.nditer(arr, flags=['multi_index'])
    for x in it:
        print(f"Element: {x}, Index: {it.multi_index}")

# 输出：
# Element: 1, Index: (0, 0, 0)
# Element: 2, Index: (0, 0, 1)
# Element: 3, Index: (0, 1, 0)
# Element: 4, Index: (0, 1, 1)
# Element: 5, Index: (1, 0, 0)
# Element: 6, Index: (1, 0, 1)
# Element: 7, Index: (1, 1, 0)
# Element: 8, Index: (1, 1, 1)


# 创建一个二维数组
arr = np.array([[1, 2, 3], [4, 5, 6]])
# 使用外部循环遍历数组
for x in np.nditer(arr, flags=['external_loop'], order='F'):
    print(x)
# 输出:
# [1 4]
# [2 5]
# [3 6]

3.op_flags 参数

op_flags 参数用于指定操作数的行为。

readonly: 只读操作数。
readwrite: 读写操作数。
writeonly: 只写操作数。

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

# 使用读写操作数遍历数组
for x in np.nditer(arr, op_flags=['readwrite']):
    x[...] = 2 * x

print(arr)
# 输出:
# [[ 2  4  6]
#  [ 8 10 12]]

9.数组操作

9.1 数组变维

函数名称	函数介绍
reshape	在不改变数组元素的条件下，修改数组的形状
flat	返回是一个迭代器，可以用 for 循环遍历其中的每一个元素
flatten	以一维数组的形式返回一份数组的副本，对副本的操作不会影响到原数组
ravel	返回一个连续的扁平数组（即展开的一维数组），与 flatten不同，它返回的是数组视图（修改视图会影响原数组）

9.1.1 flat

返回一个一维迭代器，用于遍历数组中的所有元素。无论数组的维度如何，ndarray.flat属性都会将数组视为一个扁平化的一维数组，按行优先的顺序遍历所有元素。

语法：

ndarray.flat

案例：

import numpy as np

def flat_test():
    array_one = np.arange(4).reshape(2,2)
    print("原数组元素：")
    for i in array_one:
        print(i,end=" ")
    print()
    print("使用flat属性，遍历数组：")
    for i in array_one.flat:
        print(i,end=" ")

9.1.2 flatten()

用于将多维数组转换为一维数组。flatten() 返回的是原数组的一个拷贝，因此对返回的数组进行修改不会影响原数组。

语法：

ndarray.flatten(order='C')

参数

order: 指定数组的展开顺序。

'C'：按行优先顺序展开（默认）。
'F'：按列优先顺序展开。
'A'：如果原数组是 Fortran 连续的，则按列优先顺序展开；否则按行优先顺序展开。
'K'：按元素在内存中的顺序展开。

案例：

import numpy as np

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

# 使用 flatten 方法按行优先顺序展开
flat_arr = arr.flatten(order='C')

print(flat_arr)
# 输出:
# [1 2 3 4 5 6]

9.2 ravel()

用于将多维数组转换为一维数组。与 flatten() 不同，ravel() 返回的是原数组的一个视图（view），而不是拷贝。因此，对返回的数组进行修改会影响原数组。

语法：

ndarray.ravel()

参数

order: 指定数组的展开顺序。

'C'：按行优先顺序展开（默认）。
'F'：按列优先顺序展开。
'A'：如果原数组是 Fortran 连续的，则按列优先顺序展开；否则按行优先顺序展开。
'K'：按元素在内存中的顺序展开。

案例：

import numpy as np

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

# 使用 ravel 方法按行优先顺序展开
ravel_arr = arr.ravel()

print(ravel_arr)
# 输出:
# [1 2 3 4 5 6]

ravel_arr[-1] = 7
print(arr)
# 输出:
# [[1 2 3]
#  [4 5 7]]

9.3 数组转置

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

案例：

import numpy as np

def transpose_test():
    array_one = np.arange(12).reshape(3, 4)
    print("原数组：")
    print(array_one)
    print("使用transpose()函数后的数组：")
    print(np.transpose(array_one))


def T_test():
    array_one = np.arange(12).reshape(3, 4)
    print("原数组：")
    print(array_one)
    print("数组转置：")
    print(array_one.T)

9.4 修改数组维度

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

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

案例：

import numpy as np

def expand_dims_test():
    array_one = np.arange(4).reshape(2,2)
    print('原数组：\n', array_one)
    print('原数组维度情况：\n', array_one.shape)
    # 在 1 轴处插入新的轴
    array_two = np.expand_dims(array_one, axis=1)
    print('在 1 轴处插入新的轴后的数组：\n', array_two)
    print('在 1 轴处插入新的轴后的数组维度情况：\n', array_two.shape)

def squeeze_test():
    array_one = np.arange(6).reshape(2,1,3)
    print('原数组：\n', array_one)
    print('原数组维度情况：\n', array_one.shape)
    # 删除
    array_two = np.squeeze(array_one,1)
    print('从数组的形状中删除一维项后的数组：\n', array_two)
    print('从数组的形状中删除一维项后的数组维度情况：\n', array_two.shape)

9.5 连接数组

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

hstack函数要求堆叠的数组在垂直方向（行）上具有相同的形状。如果行数不一致，hstack() 将无法执行，并会抛出 ValueError 异常。

hstack() 要求堆叠的数组在垂直方向（行）上具有相同的形状。如果列数不一致，将无法执行堆叠操作。

vstack() 和 hstack() 要求堆叠的数组在某些维度上具有相同的形状。如果维度不一致，将无法执行堆叠操作。

案例：

hstack：

import numpy as np

# 创建两个形状不同的数组
arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5], [6]])
print(arr1.shape) 	# (2, 2)
print(arr2.shape)	# (2, 1)

# 使用 hstack 水平堆叠数组
result = np.hstack((arr1, arr2))
print(result)
# 输出：
# [[1 2 5]
#  [3 4 6]]

# 创建两个形状不同的数组
arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5], [6], [7]])
print(arr1.shape)	# (2, 2)
print(arr2.shape)	# (3, 1)

# 使用 hstack 水平堆叠数组
result = np.hstack((arr1, arr2))

print(result)

# ValueError: all the input array dimensions except for the concatenation axis must match exactly
# 第一个数组在第0维有2个元素，而第二个数组在第0维有3个元素，因此无法直接连接。

vstack：

# 创建两个一维数组
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])

# 使用 vstack 垂直堆叠数组
result = np.vstack((arr1, arr2))

print(result)
# 输出:
# [[1 2 3]
#  [4 5 6]]

# 创建两个形状不同的数组
arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5, 6, 7], [8, 9, 10]])

# 使用 vstack 垂直堆叠数组
result = np.vstack((arr1, arr2))

print(result)
# ValueError: all the input array dimensions except for the concatenation axis must match exactly
# 第一个数组在第1维有2个元素，而第二个数组在第1维有3个元素，因此无法直接连接。

9.6 分割数组

函数名称	参数	说明
hsplit(ary, indices_or_sections)	ary：原数组 indices_or_sections：按列分割的索引位置	将一个数组水平分割为多个子数组（按列）
vsplit(ary, indices_or_sections)	ary：原数组 indices_or_sections：按列分割的索引位置	将一个数组垂直分割为多个子数组（按行）

案例：

import numpy as np

'''
    hsplit 函数：
        1、将一个数组水平分割为多个子数组（按列）
        2、ary：原数组
        3、indices_or_sections：按列分割的索引位置
'''
# 创建一个二维数组
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

# 使用 np.hsplit 将数组分割成三个子数组
# 分割点在索引1和3处，这意味着：
# 第一个子数组将包含从第0列到索引1（不包括索引1）的列，即第0列。
# 第二个子数组将包含从索引1（包括索引1）到索引3（不包括索引3）的列，即第1列到第2列。
# 第三个子数组将包含从索引3（包括索引3）到末尾的列，即第3列。
result = np.hsplit(arr, [1, 3])

# 查看结果
print("第一个子数组:\n", result[0])  # 输出包含第0列的子数组
print("第二个子数组:\n", result[1])  # 输出包含第1列和第2列的子数组
print("第三个子数组:\n", result[2])  # 输出包含第3列的子数组


'''
    vsplit 函数：
        1、将一个数组垂直分割为多个子数组（按行）
        2、ary：原数组
        3、indices_or_sections：按列分割的索引位置
'''
array_one = np.arange(12).reshape(2,6)
print('array_one 原数组：\n', array_one)
array_two = np.vsplit(array_one,[1])
print('vsplit 之后的数组：\n', array_two)

10.数组元素的增删改查

10.1 resize

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

案例：

import numpy as np

array_one = np.arange(6).reshape(2, 3)
print(array_one)
print('resize 后数组：\n', np.resize(array_one, (3, 4)))

# 输出：
# [[0 1 2 3]
#  [4 5 0 1]
#  [2 3 4 5]]

最后一行代码将数组形状修改为(3, 4)，原数组的元素数量不够，则重复原数组的元素填充。

10.2 append

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

案例：

'''
    append(arr, values, axis=None) 函数：
        1、将元素值添加到数组的末尾，返回一个一维数组
        2、arr：输入的数组
        3、values：向 arr 数组中添加的值，需要和 arr 数组的形状保持一致
        4、axis：默认为 None，返回的是一维数组；当 axis =0 时，追加的值会被添加到行，而列数保持不变，若 axis=1 则与其恰好相反
'''
def append_test():
    array_one = np.arange(6).reshape(2,3)
    print('原数组：\n', array_one)
    array_two = np.append(array_one,[[1,1,1],[1,1,1]],axis=None)
    print('append 后数组 axis=None：\n', array_two)
    array_three = np.append(array_one, [[1, 1, 1], [1, 1, 1]], axis=0)
    print('append 后数组 axis=0：\n', array_three)
    array_three = np.append(array_one, [[1, 1, 1], [1, 1, 1]], axis=1)
    print('append 后数组 axis=1：\n', array_three)

10.3 insert

函数名称	参数	说明
insert(arr, obj, values, axis)	arr：输入的数组 obj：表示索引值，在该索引值之前插入 values 值 values：要插入的值 axis：默认为 None，返回的是一维数组；当 axis =0 时，追加的值会被添加到行，而列数保持不变，若 axis=1 则与其恰好相反	沿规定的轴将元素值插入到指定的元素前

案例：

import numpy as np

def insert_test():
    array_one = np.arange(6).reshape(2,3)
    print('原数组：\n', array_one)
    array_two = np.insert(array_one, 1, [6],axis=None)
    print('insert 后数组 axis=None：\n', array_two)
    array_three = np.insert(array_one,1, [6], axis=0)
    print('insert 后数组 axis=0：\n', array_three)
    array_three = np.insert(array_one, 1, [6,7], axis=1)
    print('insert 后数组 axis=1：\n', array_three)

如果obj为-1，表示插入在倒数第一个元素之前。

10.4 delete

函数名称	参数	说明
delete(arr, obj, axis)	arr：输入的数组 obj：表示索引值，在该索引值之前插入 values 值 axis：默认为 None，返回的是一维数组；当 axis =0 时，删除指定的行，若 axis=1 则与其恰好相反	删掉某个轴上的子数组，并返回删除后的新数组

案例：

一维数组：

import numpy as np

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

# 删除索引为 2 和 4 的元素
new_arr = np.delete(arr, [2, 4])

print(new_arr)

二维数组：

import numpy as np


def delete_test():
    array_one = np.arange(6).reshape(2,3)
    print('原数组：\n', array_one)
    array_two = np.delete(array_one,1,axis=None)
    print('delete 后数组 axis=None：\n', array_two)
    array_three = np.delete(array_one,1, axis=0)
    print('delete 后数组 axis=0：\n', array_three)
    array_three = np.delete(array_one, 1, axis=1)
    print('delete 后数组 axis=1：\n', array_three)

10.5 argwhere

返回数组中非 0 元素的索引，若是多维数组则返回行、列索引组成的索引坐标

案例：

import numpy as np

'''
    argwhere(a) 函数：
        1、返回数组中非 0 元素的索引，若是多维数组则返回行、列索引组成的索引坐标
'''
def argwhere_test():
    array_one = np.arange(6).reshape(2,3)
    print('原数组：\n', array_one)
    print('argwhere 返回非0元素索引：\n', np.argwhere(array_one))
    print('argwhere 返回所有大于 1 的元素索引：\n', np.argwhere(array_one > 1))

10.6 unique

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

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

import numpy as np

# 创建一个 NumPy 数组
arr = np.array([1, 2, 2, 3, 4, 4, 5])
unique_elements, indices = np.unique(arr, return_index=True)
print(unique_elements)
print(indices)

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

mport numpy as np

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

# 使用 np.unique 查找唯一元素及其逆索引
unique_elements, inverse_indices = np.unique(arr, return_inverse=True)

print(unique_elements)
# 输出:
# [1 2 3 4]

print(inverse_indices)
# 输出:
# [0 1 1 2 2 2 3 3 3 3]
# 逆索引数组，表示原始数组中的每个元素在唯一元素数组中的位置。

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

import numpy as np

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

# 使用 np.unique 查找唯一元素及其计数
unique_elements, counts = np.unique(arr, return_counts=True)

print(unique_elements)
# 输出:
# [1 2 3 4]

print(counts)
# 输出:
# [1 2 3 4]

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

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

# 查找数组中的唯一元素
unique_elements = np.unique(arr)
print(unique_elements)

11.统计函数

11.1 amin() 和 amax()

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

案例：

'''
    numpy.amin() 和 numpy.amax() 函数：
        1、计算数组沿指定轴的最小值与最大值，并以数组形式返回
        2、对于二维数组来说，axis=1 表示沿着水平方向，axis=0 表示沿着垂直方向
'''
def amin_amax_test():
    array_one = np.array([[1,23,4,5,6],[1,2,333,4,5]])
    print('原数组元素：\n', array_one)
    print('原数组水平方向最小值：\n', np.amin(array_one, axis=1))
    print('原数组水平方向最大值：\n', np.amax(array_one, axis=1))
    print('原数组垂直方向最小值：\n', np.amin(array_one, axis=0))
    print('原数组垂直方向最大值：\n', np.amax(array_one, axis=0))

输出：

原数组元素：
 [[  1  23   4   5   6]
 [  1   2 333   4   5]]
原数组水平方向最小值：
 [1 1]
原数组水平方向最大值：
 [ 23 333]
原数组垂直方向最小值：
 [1 2 4 4 5]
原数组垂直方向最大值：
 [  1  23 333   5   6]

按1轴求最小值，表示在最内层轴中（每列中）分别找最小值；按0轴求最小值表示在最外层轴中（所有行中按列）找最小值。求最大值类似。

11.2 ptp()

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

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

# 使用 np.ptp 计算峰峰值
ptp_value = np.ptp(arr)

print(ptp_value)
# 输出:
# 5

# 使用 np.ptp 按行计算峰峰值
ptp_values_row = np.ptp(arr, axis=1)

# 使用 np.ptp 按列计算峰峰值
ptp_values_col = np.ptp(arr, axis=0)

print(ptp_values_row)
# 输出:
# [2 2]

print(ptp_values_col)
# 输出:
# [3 3 3]

11.3 median()

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

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

# 使用 np.median 计算中位数
median_value = np.median(arr,axis=None)

print(median_value)
# 输出:
# 3.5

# 使用 np.median 按行计算中位数
median_values_row = np.median(arr, axis=1)

# 使用 np.median 按列计算中位数
median_values_col = np.median(arr, axis=0)

print(median_values_row)
# 输出:
# [2. 5.]

print(median_values_col)
# 输出:
# [2.5 3.5 4.5]

11.4 mean()

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

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

# 使用 np.mean 计算平均值
mean_value = np.mean(arr)

print(mean_value)
# 输出:
# 3.0


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

# 使用 np.mean 计算平均值
mean_value = np.mean(arr)

print(mean_value)
# 输出:
# 3.5


# 使用 np.mean 按行计算平均值
mean_values_row = np.mean(arr, axis=1)

# 使用 np.mean 按列计算平均值
mean_values_col = np.mean(arr, axis=0)

print(mean_values_row)
# 输出:
# [2. 5.]

print(mean_values_col)
# 输出:
# [2.5 3.5 4.5]