手机软件制作网站平台,关于门户网站建设方案,网站推广服务方案,网站建设小程序湖南一、 Numpy库简介
1.1、概念 NumPy(Numerical Python)是一个开源的Python科学计算库#xff0c;旨在为Python提供 高性能的多维数组对象和一系列工具。NumPy数组是Python数据分析的基础#xff0c;许多 其他的数据处理库#xff08;如Pandas、SciPy#xff09;都依赖于Num…一、 Numpy库简介
1.1、概念 NumPy(Numerical Python)是一个开源的Python科学计算库旨在为Python提供 高性能的多维数组对象和一系列工具。NumPy数组是Python数据分析的基础许多 其他的数据处理库如Pandas、SciPy都依赖于NumPy。
NumPy的一些主要特点
1. 高性能NumPy底层主要采用C语言编写相比于python来说运算速度快性能 优越并且保留了python的易用性。
2. 多维数组NumPy提供了强大的n维数组对象ndarray可进行高效的数据处 理这是Numpy进行数据处理的核心对象。
3. 丰富的函数NumPy内置了大量数学、统计和线性代数函数方便进行数据计 算除此之外还具有广播功能可以允许不同形状的数组进行算术运算。
4. 广泛的接口NumPy与许多其他科学计算库如Matplotlib、SciPy兼容可 轻松实现数据交换和集成此外在人工智能领域中也可以很方便的和神经网络 中使用的张量进行结构转换。
1.2、安装 pip install numpy -i https://pypi.tuna.tsinghua.edu.cn/simple/ 二、Numpy-array与list的区别 Python中的list虽然可以灵活的处理多个元素但它的效率很低一般情况下 的科学运算的数据量是非常庞大的所以list的效率低会导致整个科学运算的过程变 得非常慢。与之相比Ndarray数组具有以下特点
1. Ndarray数组所有元素的数据类型相同、数据地址连续批量操作数组元素时速 度更快而list中元素的数据类型可能不同需要通过寻址的方式找到下一个元 素。
2. Ndarray数组支持广播机制矩阵运算时不需要写for循环。
3. 底层主要使用C语言实现运行速度远高于Python代码。
三、数组的创建
3.1、array创建数组 创建一个数组可以转换任何形式的序列如列表或元组为NumPy数组。
numpy.array(object, dtype None, copy True, order None, subok False, ndmin 0)名称描述object数组或嵌套的数列dtype数组元素的数据类型可选copy对象是否需要复制可选order创建数组的样式C为行方向F为列方向A为任意方向默认subok默认返回一个与基类类型一致的数组ndmin指定生成数组的最小维度
import numpy as nparr1np.array([1,2,3,4,5,6]
)
arr2np.array([[1,2,3],[4,5,6],[7,8,9]]
)print(arr1)
print(arr2)
[1 2 3 4 5 6]
[[1 2 3][4 5 6][7 8 9]]3.2、arange创建数组
创建一个均匀间隔的数值数组类似于Python的内置 range 函数。
numpy.arange([start,] stop[, step,], dtypeNone)参数描述start起始值默认为0stop终止值不包含step步长默认为1dtype返回ndarray的数据类型如果没有提供则会使用输入数据的类型。
import numpy as nparr1np.arange(1,10,1)print(arr1)
[1 2 3 4 5 6 7 8 9]3.3、zeros函数
创建一个指定形状的数组所有元素初始化为0。
numpy.zeros(shape, dtypefloat, orderC)
参数描述shape一个整数或整数元组用于指定输出数组的形状dtype可选参数指定数组元素的数据类型。默认为 floatorder可选参数指定数组数据在内存中的存储顺序。‘C’ 表示按行C语言风 格‘F’ 表示按列Fortran风格
import numpy as nparr1np.zeros(10)print(arr1)
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]import numpy as nparr2np.zeros((3,3))print(arr2)
[[0. 0. 0.][0. 0. 0.][0. 0. 0.]]3.4、ones函数
创建一个指定形状的数组所有元素初始化为1。
numpy.ones(shape, dtypefloat, orderC)
参数描述shape一个整数或整数元组用于指定输出数组的形状dtype可选参数指定数组元素的数据类型。默认为 floatorder可选参数指定数组数据在内存中的存储顺序。‘C’ 表示按行C语言风 格‘F’ 表示按列Fortran风格
import numpy as nparr1np.ones(10)
arr2np.ones((3,3))print(farr1{arr1})
print()
print(farr2{arr2})
arr1[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]arr2[[1. 1. 1.][1. 1. 1.][1. 1. 1.]]3.5、empty函数
创建一个指定形状的数组未初始化元素值可能是随机的。
numpy.empty(shape, dtypefloat, orderC)
参数描述shape一个整数或整数元组用于指定输出数组的形状dtype可选参数指定数组元素的数据类型。默认为 floatorder可选参数指定数组数据在内存中的存储顺序。‘C’ 表示按行C语言风 格‘F’ 表示按列Fortran风格
import numpy as nparr1np.empty(10)
arr2np.empty((3,3))print(farr1{arr1})
print()
print(farr2{arr2})
arr1[2.09197419e-076 1.87725413e-009 1.41866238e161 3.56792062e-0575.42801934e-096 5.98147383e-154 3.98454986e252 5.12981117e-1151.02245668e-259 2.25563609e-153]arr2[[0.0000000e000 0.0000000e000 0.0000000e000][0.0000000e000 0.0000000e000 3.1224949e-321][0.0000000e000 0.0000000e000 3.2845213e-287]]3.6、full函数
创建一个指定形状的数组所有元素初始化为用户定义的值。
numpy.full(shape, fill_value, dtypeNone, orderC)
参数描述shape一个整数或整数元组用于指定输出数组的形状fill_value用于填充数组的值dtype可选指定数组元素的数据类型。如果未指定则从 fill_value 推 断。order可选指定数组数据在内存中的存储顺序。‘C’ 表示按行优先顺序‘F’ 表 示按列优先顺序。
import numpy as nparr1np.full(10,10)
arr2np.full((3,3),3)print(farr1{arr1})
print()
print(farr2{arr2})
arr1[10 10 10 10 10 10 10 10 10 10]arr2[[3 3 3][3 3 3][3 3 3]]3.7、eye函数
创建一个单位矩阵对角线为1其余为0。
eye(N, MNone, k0, dtypeclass float, orderC)参数描述N矩阵的行数。如果只指定 N则返回一个 N×N 的单位矩阵M矩阵的列数。如果指定返回一个形状为 (N, M) 的矩阵k对角线的偏移量。k 为 0 时返回主对角线的单位矩阵k 0 时返回主对角线上方的对角线k 0 时返回主对角线下方的对角线dtype可选指定数组元素的数据类型。如果未指定则从 fill_value 推 断。order可选指定数组数据在内存中的存储顺序。‘C’ 表示按行优先顺序‘F’ 表 示按列优先顺序。
import numpy as nparr1np.eye(10)
arr2np.eye(3,3)print(farr1\n{arr1})
print()
print(farr2\n{arr2})
arr1
[[1. 0. 0. 0. 0. 0. 0. 0. 0. 0.][0. 1. 0. 0. 0. 0. 0. 0. 0. 0.][0. 0. 1. 0. 0. 0. 0. 0. 0. 0.][0. 0. 0. 1. 0. 0. 0. 0. 0. 0.][0. 0. 0. 0. 1. 0. 0. 0. 0. 0.][0. 0. 0. 0. 0. 1. 0. 0. 0. 0.][0. 0. 0. 0. 0. 0. 1. 0. 0. 0.][0. 0. 0. 0. 0. 0. 0. 1. 0. 0.][0. 0. 0. 0. 0. 0. 0. 0. 1. 0.][0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]]arr2
[[1. 0. 0.][0. 1. 0.][0. 0. 1.]]3.8、linspace函数
创建一个均匀分布的数组包含指定数量的值。
np.linspace(start, stop, num50, endpointTrue, retstepFalse, dtypeNone)参数描述start序列的起始值stop序列的终止值如果endpoint为true该值包含于数列中num要生成的等步长的样本数量默认为50endpoint该值为 ture 时数列中中包含stop值反之不包含默认是True。retstep如果为 True 时生成的数组中会显示间距反之不显示。dtypendarray 的数据类型
import numpy as nparr1np.linspace(10,100,20)
arr2np.linspace(3,3)print(farr1\n{arr1})
print()
print(farr2\n{arr2})
arr1
[ 10. 14.73684211 19.47368421 24.21052632 28.9473684233.68421053 38.42105263 43.15789474 47.89473684 52.6315789557.36842105 62.10526316 66.84210526 71.57894737 76.3157894781.05263158 85.78947368 90.52631579 95.26315789 100. ]arr2
[3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3.3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3.3. 3.]3.9、logspace函数
创建一个对数均匀分布的数组指定范围的对数数值。
np.logspace(start, stop, num50, endpointTrue, base10.0, dtypeNone)参数描述start序列的起始值为base ** startstop序列的终止值为base ** stop。如果endpoint为true该值包含于数列中num要生成的等步长的样本数量默认为50endpoint该值为 ture 时数列中中包含stop值反之不包含默认是True。base对数 log 的底数。dtypendarray 的数据类型
import numpy as nparr1np.logspace(10,100,10)
arr2np.logspace(3,3)print(farr1\n{arr1})
print()
print(farr2\n{arr2})
arr1
[1.e010 1.e020 1.e030 1.e040 1.e050 1.e060 1.e070 1.e080 1.e0901.e100]arr2
[1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000.1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000.1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000.1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000.1000. 1000.]四、随机数组的创建
函数说明seed确定随机生成器种子rand产生均匀分布的样本值random(sizeNone)该方法返回[0.0, 1.0)范围的随机数。randn(d0,d1,…,dn)randn函数返回一个或一组样本具有标准正态分布期望为0方差为1。dn表格每个维度返回值为指定维度的arraynormal用于从具有指定平均值mean和标准差standard deviation的正态分 布也称为高斯分布中抽取样本。randint该方法有三个参数low、high、size三个参数。默认high是None,如果只有low那范围就是[0,low)。如果有high范围就是[low,high)。uniform该函数用于从均匀分布中抽取一个浮点数shuffle对一个序列就地随机排列
4.1、seed函数 随机数种子random seed是一个用于初始化随机数生成器random number generator, RNG的值。在计算机科学中大多数的随机数生成器实际上是伪随机 数生成器pseudo-random number generators, PRNGs它们通过一个算法来 生成一系列看似随机的数字。伪随机数生成器的特点是可以重现生成的随机数序列 这是通过设置相同的随机数种子来实现的。
设置随机数种子种子值可以是任何整数通常是正整数。 特点 1. 可重现性通过设置相同的随机数种子每次程序运行时生成的随机数序列都是 相同的。这对于调试程序、进行科学计算或模拟时保持实验结果的一致性非常有 用。 2. 算法确定性伪随机数生成器是确定性的这意味着给定的种子会总是产生相同 的随机数序列这与真正的随机数生成器不同后者总会生成不同的随机数。 3. 种子来源随机数种子的值可以是任意的。在许多编程环境中如果不显式设置 种子通常会使用当前时间作为种子这样每次程序运行时都会产生不同的随机 数序列。 4. 跨平台差异不同的操作系统或硬件平台可能会产生不同的随机数序列即使种 子相同。这是因为不同的平台可能有不同的PRNG算法。 import numpy as np
np.random.seed(42)
4.2、rand函数
生成均匀分布的随机数0到1之间可以指定形状。
numpy.random.rand(d0, d1, ..., dn)
函数说明d0, d1, ..., dn这些参数定义了输出数组的形状。它们是整数指定了每个 维度的大小。例如d0 是第一个维度的大小d1 是第二个维度的大小依此类 推。
import numpy as nparr1np.random.rand(10)print(farr1\n{arr1})
arr1
[0.92463939 0.94486905 0.74476479 0.25784553 0.85425486 0.571607250.95990865 0.36395052 0.41709035 0.82599918]4.3、random函数
与 rand 类似但提供更灵活的随机数生成。
numpy.random.random(sizeNone)
函数说明size这是一个可选参数用于指定输出数组的形状。它可以是一个整数也 可以是一个元组。如果 size 是一个整数则返回一个一维数组如果 一个元组则返回一个多维数组其形状与元组指定的一致
import numpy as nparr1np.random.random(10)arr2np.random.random((3,3))print(farr1\n{arr1})
print()
print(farr2\n{arr2})
arr1
[0.62721499 0.21350623 0.83140219 0.41729457 0.70818569 0.550753530.57016909 0.42416555 0.11372102 0.7405065 ]arr2
[[0.96151613 0.96612422 0.49951694][0.9377553 0.61001206 0.88551393][0.22225505 0.51794861 0.36731721]]4.4、randn函数
生成标准正态分布均值为0标准差为1的随机数。
numpy.random.randn(d0, d1, ..., dn)
函数说明d0, d1, ..., dn这些参数指定了输出数组的维度。如果你只提供一个数字 它将返回一个一维数组如果你提供多个数字它将返回一个多维数组其中每 个维度的大小由对应的参数指定
import numpy as nparr1np.random.randn(10)arr2np.random.randn(3,4)print(farr1\n{arr1})
print()
print(farr2\n{arr2})
arr1
[-0.49202485 -0.26029324 0.46349285 -1.4871595 -1.15332575 0.48229266-1.04077328 0.52712378 -0.40422044 1.82175024]arr2
[[ 0.0348239 0.96843211 0.41392382 0.51399037][ 1.13157601 -1.35735621 -2.2765836 -0.52266114][-0.8062335 -0.55222009 -1.00520723 -1.84433436]]4.5、normal函数
生成给定均值和标准差的正态分布随机数。
numpy.random.normal(loc0.0, scale1.0, sizeNone)
函数说明loc正态分布的均值对应于分布的中心位置默认值为 0.0scale正态分布的标准差对应于分布的宽度默认值为 1.0size输出数组的形状。如果是一个整数返回一维数组。如果是一个元组返回多维数组。默认为None返回一个随机数
import numpy as nparr1np.random.normal(size10)arr2np.random.normal(size(3,4))print(farr1\n{arr1})
print()
print(farr2\n{arr2})
arr1
[-0.23383662 0.97632058 0.48245764 -1.71405263 0.0625902 2.32371938-1.16770879 0.20876465 -2.16149186 -0.05048533]arr2
[[-0.68925419 -2.12716386 -1.06562238 1.11568077][ 0.02078178 -0.31270599 -1.90545882 -0.850884 ][ 0.66213069 2.28670915 -0.88748761 0.13641803]]4.6、randint函数
生成指定范围内的随机整数。
numpy.random.randint(low, highNone, sizeNone, dtypeint)
函数说明low生成随机数的起始点包含。如果只提供了low参数而没有提供high参数那么随机整数的范围将是从 0 到low 不包含 low本身high生成随机数的结束点不包含size定义输出数组形状的整数或元组。例如size(mn)将生成 一个 m 行 n 列的数组dtype指定返回数组的数据类型默认为int
import numpy as nparr1np.random.randint(0,10,size10)arr2np.random.randint(0,10,size(3,4))print(farr1\n{arr1})
print()
print(farr2\n{arr2})
arr1
[3 1 3 7 2 7 0 5 4 8]arr2
[[4 7 9 6][3 8 2 0][2 0 4 5]]
4.7、uniform函数
生成指定范围内的均匀分布随机数。
numpy.random.uniform(low0.0, high1.0, sizeNone)
函数说明low浮点数或类似浮点数的数组表示样本抽取区间的下限默认值为 0high浮点数或类似浮点数的数组表示样本抽取区间的上限默认值为 1size整数或元组可选参数表示输出的形状。如果未提供则返回单个浮 点数。如果提供了一个整数则返回一个一维数组如果提供了一个元组则返 回一个多维数组
import numpy as nparr1np.random.uniform(0,10,size5)arr2np.random.uniform(0,10,size(3,4))print(farr1\n{arr1})
print()
print(farr2\n{arr2})
arr1
[7.96891358 0.19647614 5.42047937 1.49001317 9.04060667]arr2
[[3.44988119 0.82911361 7.53272753 2.65165757][6.13385131 2.30715477 0.73983801 7.05093042][5.82714561 2.25635848 3.37875838 8.62424195]]4.8、shuffle函数
对数组进行随机重排原地改变数组顺序。
numpy.random.shuffle(x)
函数说明x要打乱的数组
import numpy as nparr1np.array([[1,2,3],[4,5,6],[7,8,9]
])
print(改变之前)
print(farr1\n{arr1})np.random.shuffle(arr1)print(改变之后)
print(farr1\n{arr1})
arr1
改变之前
arr1
[[1 2 3][4 5 6][7 8 9]]
改变之后
arr1
[[1 2 3][7 8 9][4 5 6]]
五、数组的索引和切片 Ndarray数组中的元素是可以被修改的如果需要访问或者修改Ndarray数组某个位 置的元素则需要使用Ndarray数组的索引来完成如果需要访问或者修改一些区域 的元素则需要使用Ndarray数组的切片。
5.1、一维数组的索引与切片
5.1.1、索引 一维数组的索引方式与Python列表的索引方式类似Ndarray数组使用方括号 行索引索引值从左向右从0开始从右向左从-1开始。
# 一维数组的索引方式
import numpy as np# 创建了一个一维数组
arr np.array([1, 2, 3, 4, 5])
print(arr[0])
print(arr[4])
print(arr[-1])
print(arr[-3])
arr[0] 10
print(arr)1
5
5
3
[10 2 3 4 5]5.1.2、切片 与Python列表的切片方式类似使用冒号:进行切片格式为 start:stop:step 其中start、stop、step可根据情况省略。
# 一维数组的切片方式
import numpy as nparr np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])arr1 arr[4:7]
print(arr1数组元素为, arr1)arr2 arr[1:6:2]
print(arr2数组元素为, arr2)# 将一个标量值赋值给一个切片时该值会自动传播到整个选区。
arr[4:7] 6
print(arr数组元素为, arr)# 也可以使用:代表全部元素
arr[:] 10
print(arr数组元素为, arr)arr[:4] 1
print(arr)
arr1数组元素为 [5 6 7]
arr2数组元素为 [2 4 6]
arr数组元素为 [ 1 2 3 4 6 6 6 8 9 10]
arr数组元素为 [10 10 10 10 10 10 10 10 10 10]
[ 1 1 1 1 10 10 10 10 10 10]5.2、多维数组的索引与切片
5.2.1、索引 对于多维数组可以通过逗号分隔的索引来访问特定元素也可以使用连续的[]来访 问特定元素例如对于一个二维数组第一个索引表示行第二个索引表示列。
# 二维数组的索引
import numpy as nparr np.array([[1, 2, 3], [4, 5, 6]])print(arr数组为\n, arr)# 只有一个索引指标时会在第0维上索引后面的维度保持不变
print(arr[0]为, arr[0])# 两个索引指标
print(arr[0][0]为, arr[0][0])
print(arr[0][0])# 两个索引指标
print(arr[0, 1]为, arr[0, 1])arr[0][2] 5
print(arr)arr数组为[[1 2 3][4 5 6]]
arr[0]为 [1 2 3]
arr[0][0]为 1
1
arr[0, 1]为 2
[[1 2 5][4 5 6]]5.2.2、切片 多维数组切片时可以分别为每个维度指定切片。
# 二维数组的切片
import numpy as nparr np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(arr: \n, arr)# 选择特定的一行
row1 arr[1]
print(row1)# 选择连续的多行
rows arr[1:3]
print(rows)# 选择不连续的多行
rows arr[[0, 2]]
print(rows)# 选择特定的一列
col1 arr[:, 1]
print(col1)# 选择连续的多列
cols arr[:, 1:3]
print(cols)# 选择不连续的多列
cols arr[:, [0, 2]]
print(cols)# 同时选择行和列
subset arr[1:3, 1:3]
print(subset)
arr: [[1 2 3][4 5 6][7 8 9]]
[4 5 6]
[[4 5 6][7 8 9]]
[[1 2 3][7 8 9]]
[2 5 8]
[[2 3][5 6][8 9]]
[[1 3][4 6][7 9]]
[[5 6][8 9]]
六、数组的属性
6.1、shape 通过调用Ndarray.shape即可返回一个表示数组维度大小的元组。
import numpy as nparr1 np.array([[1, 2, 3], [4, 5, 6]])print(arr1)
print(arr1.shape)
[[1 2 3][4 5 6]]
(2, 3)6.2、dtype 通过调用Ndarray.dtype即可返回一个Ndarray数组中元素的数据类型。
import numpy as np# 可以在创建的时候去指定数据类型
arr1 np.array([[1, 2, 3], [4, 5, 6]], dtypenp.float32)print(arr1)
print(arr1.dtype)
[[1. 2. 3.][4. 5. 6.]]
float326.3、size 该属性是指数组中包含的元素个数其大小等于调用shape函数返回的元组中的所有 元素的乘积。
import numpy as nparr1 np.array([[1, 2, 3], [4, 5, 6]])print(arr1)
print(arr1.shape)
print(arr1.size)
[[1 2 3][4 5 6]]
(2, 3)
66.4、ndim 该属性是指数组的维度大小其大小等于调用shape函数返回的元组中的元素的个数。
import numpy as nparr1 np.array([[[[1, 2, 3], [4, 5, 6]]]])print(arr1)
print(arr1.shape)
print(arr1.ndim)[[[[1 2 3][4 5 6]]]]
(1, 1, 2, 3)
4七、改变数组的数据类型和形状
7.1、数据类型的修改
numpy.ndarray.astype(dtype, orderK, castingunsafe, subokTrue, copyTrue)
函数说明dtype表示新数据类型的对象。这可以是 NumPy 的 dtype 对象也可以是 Python 的数据类型例如 int 或 floatorder一个字符指定结果的内存布局。 按列Fortran风格 C 表示按行C风格 F 表示 A 或 K 表示在内存中的顺序与原数组保持一致casting控制数据类型转换的安全性。它可以是 no、 equiv、 safe、 same_kind 或 unsafe 之一 。subok如果为True子类将被传递否则返回的数组将强制转换为基类数组copy布尔值指定是否复制数据。 casting参数说明 no表示根本不应该进行转换数据类型。 equiv允许数值上等价的类型转换即转换前后数据的位表示相同。这意味着转 换不会导致数据丢失。 safe允许安全的类型转换即转换过程中不会丢失信息。 same_kind允许相同数据类型类别内的转换。例如允许整型和整型之间、浮点 型和浮点型之间的转换但是不允许整型和浮点型之间的转换。 unsafe允许任何类型的转换不考虑是否会导致数据丢失或改变。这是最不安全 的选项因为它可能会静默地丢弃数据。 比如 从 int64 到 int32 的转换 no不允许。 equiv不允许。 safe不允许。 same_kind允许。 unsafe允许。 从 float64 到 int32 的转换 no不允许因为会丢失小数部分。 equiv、safe、same_kind不允许因为这不是数值上等价或安全的转换。 unsafe允许但会丢失小数部分。 import numpy as np# 创建一个浮点数数组
arr np.array([1.1, 2.2, 3.3])# 使用 astype 方法将数组转换为整数类型
new_arr arr.astype(np.int32)print(Original array:, arr)
print(old type:, arr.dtype)
print(New array:, new_arr)
print(new type:, new_arr.dtype)Original array: [1.1 2.2 3.3]
old type: float64
New array: [1 2 3]
new type: int327.2、形状的修改
7.2.1、reshape reshape方法用于给数组一个新的形状而不改变其数据它返回一个新的数组但是 如果给定的形状与原始数组的数据不兼容会抛出异常
numpy.ndarray.reshape(newshape, orderC)
函数说明newshape整数或整数元组新的形状应该与原始数组中的元素数量相匹配order可选参数‘C’ 表示按行C-style‘F’ 表示按列Fortran-style‘A’ 表示原数组内存顺序‘K’ 表示元素在内存中的出现顺序
import numpy as np
a np.array([[1, 2, 3], [4, 5, 6]])
print(a)
print(shape--a, a.shape)b a.reshape((3, 2))
print(a)
print(b)
print(shape--b,b.shape)[[1 2 3][4 5 6]]
shape--a (2, 3)
[[1 2 3][4 5 6]]
[[1 2][3 4][5 6]]
shape--b (3, 2)
7.2.2、resize resize 方法用于改变数组的大小与 reshape类似但它会直接修改调用它的原始数 组。如果新形状大于原始形状则会在数组的末尾添加新的元素这些元素的值未定 义如果新形状小于原始形状则会截断数组。
numpy.ndarray.resize(newshape)
函数说明newshape整数或整数元组新的形状。
import numpy as np
a np.array([[1, 2, 3], [4, 5, 6]])
print(a)
print(before:, a.shape)a.resize((3, 2))print(after:, a.shape)
print(a)a.resize((2, 2))
print(a)a.resize((5, 5))
print(a)
[[1 2 3][4 5 6]]
before: (2, 3)
after: (3, 2)
[[1 2][3 4][5 6]]
[[1 2][3 4]]
[[1 2 3 4 0][0 0 0 0 0][0 0 0 0 0][0 0 0 0 0][0 0 0 0 0]]
7.2.3、flatten flatten方法返回一个一维数组它是原始数组的拷贝它默认按行顺序展平数组但 可以通过参数 order 来指定展平顺序。
numpy.ndarray.flatten(orderC)
函数说明order可选参数‘C’ 表示按行‘F’ 表示按列‘A’ 或 ‘K’ 表示与原数组相同的顺序
import numpy as np
a np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])
print(a)
b a.flatten()
print(b)
b[0] 10
print(a)
print(b)[[ 1 2 3][ 4 5 6][ 7 8 9][10 11 12]]
[ 1 2 3 4 5 6 7 8 9 10 11 12]
[[ 1 2 3][ 4 5 6][ 7 8 9][10 11 12]]
[10 2 3 4 5 6 7 8 9 10 11 12]7.2.4、ravel ravel方法返回一个连续的数组它尝试以最低的复制操作来返回展平后的数组
numpy.ndarray.ravel(orderC)
函数说明order可选参数‘C’ 表示按行‘F’ 表示按列 ravel和flatten的区别 flatten 方法返回的是原数组的副本。这意味着返回的新数组与原数组是两个独 立的对象对新数组的修改不会影响原数组。 ravel 方法返回的是原数组的视图view或副本copy这取决于数组的 顺序。如果数组是连续的C-style行优先则 ravel 返回的是视图这意 味着对返回数组的修改会影响到原数组。如果数组不是连续的则 的是副本。可以通过传递 orderF 参数来请求列优先的视图。 import numpy as np
a np.array([[1, 2, 3], [4, 5, 6]])
b a.flatten()
c a.ravel()
d a.ravel(orderF)a[0][0] 100
a[1][0] 50
print(a, a)
print(b, b)
print(c, c)
print(d, d)
a [[100 2 3][ 50 5 6]]
b [1 2 3 4 5 6]
c [100 2 3 50 5 6]
d [1 4 2 5 3 6]7.2.5、T Ndarray 对象的 T 属性是一个特殊的属性它返回数组的转置transpose。 转置是一个操作它将数组的维度进行交换。对于二维数组这意味着行变为列列 变为行。对于更高维度的数组转置操作涉及到交换数组的轴。
import numpy as np# 创建一个二维数组
arr_2d np.array([[1, 2], [3, 4], [5, 6]])# 获取转置
transposed_arr arr_2d.Tprint( array:)
print(arr_2d)
print(T array:)
print(transposed_arr)array:
[[1 2][3 4][5 6]]
T array:
[[1 3 5][2 4 6]]八、数组的运算
8.1、标量和数组的运算
8.1.1、加法运算
import numpy as np# 生成一个2行3列的Ndarray数组
arr np.array([[1, 2, 3], [4, 5, 6]])# 数组加上标量会使数组的每一个元素都加上该标量得到一个新数组
b arr 2print(original: \n, arr)
print(new: \n, b)
original: [[1 2 3][4 5 6]]
new: [[3 4 5][6 7 8]]8.1.2、减法运算
import numpy as np# 生成一个2行3列的Ndarray数组
arr np.array([[1, 2, 3], [4, 5, 6]])# 数组加上标量会使数组的每一个元素都加上该标量得到一个新数组
b arr - 2print(original: \n, arr)
print(new: \n, b)
original: [[1 2 3][4 5 6]]
new: [[-1 0 1][ 2 3 4]]8.1.3、乘法运算
import numpy as np# 生成一个2行3列的Ndarray数组
arr np.array([[1, 2, 3], [4, 5, 6]])# 数组加上标量会使数组的每一个元素都加上该标量得到一个新数组
b arr * 2print(original: \n, arr)
print(new: \n, b)
original: [[1 2 3][4 5 6]]
new: [[ 2 4 6][ 8 10 12]]8.1.4、除法运算
import numpy as np# 生成一个2行3列的Ndarray数组
arr np.array([[1, 2, 3], [4, 5, 6]])# 数组加上标量会使数组的每一个元素都加上该标量得到一个新数组
b arr / 2print(original: \n, arr)
print(new: \n, b)
original: [[1 2 3][4 5 6]]
new: [[0.5 1. 1.5][2. 2.5 3. ]]8.2、数组和数组的运算
8.2.1、加法运算
8.2.1.1、符号
import numpy as nparr1 np.array([[11, 12, 13], [14, 15, 16]])
arr2 np.array([[1, 2, 3], [4, 5, 6]])arr3 arr1 arr2print(arr1)
print(arr2)
print(运算的结果为\n, arr3)
[[11 12 13][14 15 16]]
[[1 2 3][4 5 6]]
运算的结果为[[12 14 16][18 20 22]]8.2.1.2、函数
numpy.add(x1, x2, /, outNone, *, whereTrue, castingsame_kind, orderK, dtypeNone, subokTrue)
函数说明x1第一个输入数组或标量x2第二个输入数组或标量out输出数组数据类型必须与预期输出相符。如果提供它必须具有与输出 相同形状的适当类型来接收结果where表示计算加法的条件如果设置为True则在相应位置进行计算如果 设置为False则在相应位置不进行计算casting定义如何处理数据类型转换例如 ‘no’, ‘equiv’, ‘safe’, ‘same_kind’, ‘unsafe’order指定结果的内存布局‘C’ 表示 C 风格‘F’ 表示 Fortran 风格‘A’ 表示原 数组样式‘K’ 表示元素在内存中的出现顺序dtype指定输出数组的类型subok控制返回数组是否可以是输入数组的子类
import numpy as nparr1 np.array([[11, 12, 13], [14, 15, 16]])
arr2 np.array([[1, 2, 3], [4, 5, 6]])arr3 np.add(arr1,arr2)print(arr1)
print(arr2)
print(运算的结果为\n, arr3)
[[11 12 13][14 15 16]]
[[1 2 3][4 5 6]]
运算的结果为[[12 14 16][18 20 22]]8.2.2、减法运算
8.2.2.1、符号
import numpy as nparr1 np.array([[11, 12, 13], [14, 15, 16]])
arr2 np.array([[1, 2, 3], [4, 5, 6]])arr3 arr1 - arr2print(arr1)
print(arr2)
print(运算的结果为\n, arr3)
[[11 12 13][14 15 16]]
[[1 2 3][4 5 6]]
运算的结果为[[10 10 10][10 10 10]]
8.2.2.2、函数
numpy.subtract(x1, x2, /, outNone, *, whereTrue, castingsame_kind, orderK, dtypeNone, subokTrue)
函数说明x1第一个输入数组或标量x2第二个输入数组或标量out输出数组数据类型必须与预期输出相符。如果提供它必须具有与输出 相同形状的适当类型来接收结果where表示计算加法的条件如果设置为True则在相应位置进行计算如果 设置为False则在相应位置不进行计算casting定义如何处理数据类型转换例如 ‘no’, ‘equiv’, ‘safe’, ‘same_kind’, ‘unsafe’order指定结果的内存布局‘C’ 表示 C 风格‘F’ 表示 Fortran 风格‘A’ 表示原 数组样式‘K’ 表示元素在内存中的出现顺序dtype指定输出数组的类型subok控制返回数组是否可以是输入数组的子类
import numpy as nparr1 np.array([[11, 12, 13], [14, 15, 16]])
arr2 np.array([[1, 2, 3], [4, 5, 6]])arr3 np.subtract(arr1,arr2)print(arr1)
print(arr2)
print(运算的结果为\n, arr3)
[[11 12 13][14 15 16]]
[[1 2 3][4 5 6]]
运算的结果为[[10 10 10][10 10 10]]8.2.3、乘法运算
8.2.3.1、符号
import numpy as nparr1 np.array([[11, 12, 13], [14, 15, 16]])
arr2 np.array([[1, 2, 3], [4, 5, 6]])arr3 arr1 * arr2print(arr1)
print(arr2)
print(运算的结果为\n, arr3)
[[11 12 13][14 15 16]]
[[1 2 3][4 5 6]]
运算的结果为[[11 24 39][56 75 96]]
8.2.3.2、函数
numpy.multiply(x1, x2, /, outNone, *, whereTrue, castingsame_kind, orderK, dtypeNone, subokTrue)
函数说明x1第一个输入数组或标量x2第二个输入数组或标量out输出数组数据类型必须与预期输出相符。如果提供它必须具有与输出 相同形状的适当类型来接收结果where表示计算加法的条件如果设置为True则在相应位置进行计算如果 设置为False则在相应位置不进行计算casting定义如何处理数据类型转换例如 ‘no’, ‘equiv’, ‘safe’, ‘same_kind’, ‘unsafe’order指定结果的内存布局‘C’ 表示 C 风格‘F’ 表示 Fortran 风格‘A’ 表示原 数组样式‘K’ 表示元素在内存中的出现顺序dtype指定输出数组的类型subok控制返回数组是否可以是输入数组的子类
import numpy as nparr1 np.array([[11, 12, 13], [14, 15, 16]])
arr2 np.array([[1, 2, 3], [4, 5, 6]])arr3 np.multiply(arr1,arr2)print(arr1)
print(arr2)
print(运算的结果为\n, arr3)
[[11 12 13][14 15 16]]
[[1 2 3][4 5 6]]
运算的结果为[[11 24 39][56 75 96]]8.2.4、除法运算
8.2.4.1、符号
import numpy as nparr1 np.array([[11, 12, 13], [14, 15, 16]])
arr2 np.array([[1, 2, 3], [4, 5, 6]])arr3 arr1 / arr2print(arr1)
print(arr2)
print(运算的结果为\n, arr3)
[[11 12 13][14 15 16]]
[[1 2 3][4 5 6]]
运算的结果为[[11. 6. 4.33333333][ 3.5 3. 2.66666667]]8.2.4.2、函数
numpy.divide(x1, x2, /, outNone, *, whereTrue, castingsame_kind, orderK, dtypeNone, subokTrue)
函数说明x1第一个输入数组或标量x2第二个输入数组或标量out输出数组数据类型必须与预期输出相符。如果提供它必须具有与输出 相同形状的适当类型来接收结果where表示计算加法的条件如果设置为True则在相应位置进行计算如果 设置为False则在相应位置不进行计算casting定义如何处理数据类型转换例如 ‘no’, ‘equiv’, ‘safe’, ‘same_kind’, ‘unsafe’order指定结果的内存布局‘C’ 表示 C 风格‘F’ 表示 Fortran 风格‘A’ 表示原 数组样式‘K’ 表示元素在内存中的出现顺序dtype指定输出数组的类型subok控制返回数组是否可以是输入数组的子类
import numpy as nparr1 np.array([[11, 12, 13], [14, 15, 16]])
arr2 np.array([[1, 2, 3], [4, 5, 6]])arr3 np.divide(arr1,arr2)print(arr1)
print(arr2)
print(运算的结果为\n, arr3)
[[11 12 13][14 15 16]]
[[1 2 3][4 5 6]]
运算的结果为[[11. 6. 4.33333333][ 3.5 3. 2.66666667]]8.2.5、开根号
8.2.5.1、符号
import numpy as np# 生成一个2行3列的数组
arr1 np.array([[4, 9, 16], [25, 36, 49]])# 开根号操作就是让一个数组进行0.5次方的幂运算
arr2 arr1 ** 0.5print(arr1)
print(运算的结果为\n, arr2)
[[ 4 9 16][25 36 49]]
运算的结果为[[2. 3. 4.][5. 6. 7.]]8.2.5.2、函数
函数说明x1第一个输入数组或标量x2第二个输入数组或标量out输出数组数据类型必须与预期输出相符。如果提供它必须具有与输出 相同形状的适当类型来接收结果where表示计算加法的条件如果设置为True则在相应位置进行计算如果 设置为False则在相应位置不进行计算casting定义如何处理数据类型转换例如 ‘no’, ‘equiv’, ‘safe’, ‘same_kind’, ‘unsafe’order指定结果的内存布局‘C’ 表示 C 风格‘F’ 表示 Fortran 风格‘A’ 表示原 数组样式‘K’ 表示元素在内存中的出现顺序dtype指定输出数组的类型subok控制返回数组是否可以是输入数组的子类
import numpy as np# 生成一个2行3列的数组
arr1 np.array([[4, 9, 16], [25, 36, 49]])# 开根号操作就是让一个数组进行0.5次方的幂运算
arr2 np.pow(arr1,0.5)print(arr1)
print(运算的结果为\n, arr2)
[[ 4 9 16][25 36 49]]
运算的结果为[[2. 3. 4.][5. 6. 7.]]8.2.6、点积
行*列 函数说明a第一个输入数组b第二个输入数组out可选输出数组用于放置运算结果
import numpy as np# 生成两个2行3列的数组
arr1 np.array([[1,2,3],[4,5,6],[7,8,9]]
)
arr2 np.array([[1, 2, 3],[4, 5, 6],[7, 8, 9]]
)# power会使arr1中的每个元素为底数arr2中的对应位置的元素为指数进行运算
arr3 np.dot(arr1, arr2)print(arr1)
print(arr2)
print(运算的结果为\n, arr3)
[[1 2 3][4 5 6][7 8 9]]
[[1 2 3][4 5 6][7 8 9]]
运算的结果为[[ 30 36 42][ 66 81 96][102 126 150]]九、数组的广播机制 通常情况下为了进行元素级的算术运算两个数组的形状必须完全一致Numpy的广播机制它提供了一种规则能够将不同形状的两个计算数 组广播到相同形状然后再去进行元素级的算术运算这种规则使得形状不完全匹配 的数组也能相互运算。通过这个机制Numpy能够在保持效率的同时扩展数组的 操作范围从而无需显式地扩展数组维度或进行循环遍历以实现元素级的计算极大的增强了数组的处理能力。 具体规则为 1. 如果两个数组的维数不同形状较小的数组会在前面补1。 2. 如果两个数组的形状在某个维度上不匹配且其中一个维度长度为1则会沿该 维度复制扩展以匹配另一个数组的形状。 3. 如果在任一维度上不匹配且没有维度等于1则会引发异常。 举例 arr np.array([[1, 2, 3], [4, 5, 6]]) arr和标量2进行相加 标量 2 的形状可以看作是而二维数组 arr的形状是2, 3。根据广播 规则维度较低的标量会在其形状左边添加与高维数组相同的维度数使其维度与高 维数组相同。这里标量 2 被扩展为形状1,1的数组再进一步扩展为形状2,3 的数组即 [[2,2,2],[2,2,2]]。然后这个扩展后的数组与原二维数组 arr进行 对应元素的运算。所以最终结果为 arr 2 [[12,22,32],[42,52,62]] [[3,4,5],[6,7,8]] 十、修改维度
10.1、squeeze
该函数的作用是从数组形状中删除所有单维度的条目即把形状中为1的维度去掉。
numpy.squeeze(a, axisNone)
函数说明a输入数组。它可以是任何形状的数组但至少有一个维度的大小为1。axis可选参数。一个整数或整数元组。如果指定了该参数则只压缩指定的 轴。如果该轴在数组 a 中不是单维度的则不会进行压缩。如果未指定则所有 单维度的轴都将被压缩。
# squeeze: 降维
import numpy as np# 创建一个具有单维度的数组
arr np.array([[[1], [2], [3]]])
print(arr)
print(原始数组形状:, arr.shape)# 使用squeeze函数去掉所有单维度的条目
squeezed_arr np.squeeze(arr, axis(0, 2))
print(squeezed_arr)
print(压缩后的数组形状:, squeezed_arr.shape)
[[[1][2][3]]]
原始数组形状: (1, 3, 1)
[1 2 3]
压缩后的数组形状: (3,)10.2、expand_dims 该函数的作用是在指定的位置增加一个单一维度即在指定的位置增加一个形状为1 的维度。
numpy.expand_dims(a, axis)
函数说明a输入数组。它可以是任何形状的数组但至少有一个维度的大小为1。axis可选参数。一个整数或整数元组。如果指定了该参数则只压缩指定的 轴。如果该轴在数组 a 中不是单维度的则不会进行压缩。如果未指定则所有 单维度的轴都将被压缩。
# expand_dims:升维
import numpy as np# 创建一个一维数组
arr np.array([[1, 2, 3], [4, 5, 6]])
print(原始数组形状:, arr.shape)
print(arr)# 在位置0增加一个维度
expanded_arr np.expand_dims(arr, axis2)
print(增加维度后的数组形状:, expanded_arr.shape)
print(expanded_arr)# 在位置1增加一个维度
expanded_arr np.expand_dims(arr, axis(0, 1))
print(增加维度后的数组形状:, expanded_arr.shape)
print(expanded_arr)原始数组形状: (2, 3)
[[1 2 3][4 5 6]]
增加维度后的数组形状: (2, 3, 1)
[[[1][2][3]][[4][5][6]]]
增加维度后的数组形状: (1, 1, 2, 3)
[[[[1 2 3][4 5 6]]]]十一、连接数组
11.1、concatenate 该函数用于将多个数组沿指定的轴连接起来形成一个更大的数组
numpy.concatenate((a1, a2, ..., arr_n), axis0, outNone)
函数说明(a1, a2, ..., arr_n)这是一个包含数组的元组这些数组需要被连接。所 有数组在除了连接轴之外的其他维度上必须有相同的形状axis整数指定沿着哪个轴进行连接。如果不指定默认为 0表示第一个 轴。out可选参数如果提供结果将直接存储在这个数组中。这个数组必须具有 与输入数组相同的形状和数据类型。 工作原理 1. 输入验证 concatenate 接受一个元组或列表作为输入其中包含一系列数 组。这些数组可以是任意维度但它们在除了要连接的轴之外的所有维度上必须 具有相同的形状。 2. 轴参数 concatenate 有一个必需的参数 axis它指定了沿着哪个轴进行连 接。轴的编号从 0 开始对于一维数组只有一个轴轴 0。对于二维数组 轴 0 是行轴 1 是列。 3. 形状兼容性检查所有输入数组在 axis 参数指定的轴上的维度大小可以不同 但在其他轴上的维度大小必须相同。例如如果 axis1则所有输入数组的行 数必须相同。 4. 内存分配在连接之前 concatenate 会计算输出数组的大小并分配足够的 内存空间来存储结果。 5. 数据复制 concatenate 会将输入数组的数据复制到新分配的内存空间中。具 体来说它将沿着指定的轴顺序地复制每个数组的数据从而形成一个新的数 组。 6. 结果数组输出结果是一个新的数组它在 axis 指定的轴上的维度大小是所有 输入数组在该轴上维度大小的总和而在其他轴上则与输入数组相同。 import numpy as np# 创建两个数组
a np.array([[1, 2], [3, 4]])
b np.array([[5, 6]])print(f数组a的形状为{a.shape}, 数组a为\n, a)
print(f数组b的形状为{b.shape}, 数组b为\n, b)# 沿着第一个轴垂直方向连接数组
c np.concatenate((b, a), axis0)
print(f数组c的形状为{c.shape}, 数组c为\n, c)# 沿着第二个轴水平方向连接数组
d np.concatenate((a, b.T), axis1)
print(f数组b的转置的形状为{b.T.shape}, 数组b的转置为\n, b.T)
print(f数组d的形状为{d.shape}, 数组d为\n, d)
数组a的形状为(2, 2), 数组a为[[1 2][3 4]]
数组b的形状为(1, 2), 数组b为[[5 6]]
数组c的形状为(3, 2), 数组c为[[5 6][1 2][3 4]]
数组b的转置的形状为(2, 1), 数组b的转置为[[5][6]]
数组d的形状为(2, 3), 数组d为[[1 2 5][3 4 6]]11.2、stack 该函数用于沿着新的轴连接一系列数组。与 numpy.concatenate 不同 numpy.stack 总是创建一个新的轴而numpy.concatenate则是在现有轴上进行数组的连接
numpy.stack(arrays, axis0, outNone)
函数说明arrays一系列数组它们将被堆叠在一起。所有数组必须具有相同的形状axis整数表示新轴的位置。默认值为 0out可选参数如果提供结果将直接存储在这个数组中。这个数组必须具有 与输出数组相同的形状和数据类型 工作原理 1. 输入验证 stack 接受一个数组序列例如一个列表或元组作为输入。所有输 入数组必须具有相同的形状。 2. 轴参数 stack 有一个必需的参数 axis它指定了新轴的位置。 3. 形状兼容性检查所有输入数组在除了要创建的新轴外的所有维度上必须具有相 同的形状。 4. 内存分配 stack 会计算输出数组的形状并在内存中为这个新数组分配空间。 新数组的形状将比输入数组的形状多一个维度这个新增的维度的大小等于输入 数组的数量。 5. 数据复制 stack 将输入数组的数据复制到新分配的内存空间中每个输入数组 在新轴上占据一个位置。 6. 结果数组输出结果是一个新的数组其形状在 一个维度。 import numpy as np# 创建两个一维数组
a np.array([1, 2, 3])
b np.array([4, 5, 6])
c np.array([7, 8, 9])print(f数组a的形状为{a.shape}, 数组a为\n, a)
print(f数组b的形状为{b.shape}, 数组b为\n, b)# # 沿着新的轴堆叠数组
d np.stack((a, c, b), axis0)
print(f数组d的形状为{d.shape}, 数组d为\n, d)# 沿着第二个轴堆叠数组
e np.stack((a, b), axis1)
print(f数组e的形状为{e.shape}, 数组e为\n, e)
数组a的形状为(3,), 数组a为[1 2 3]
数组b的形状为(3,), 数组b为[4 5 6]
数组d的形状为(3, 3), 数组d为[[1 2 3][7 8 9][4 5 6]]
数组e的形状为(3, 2), 数组e为[[1 4][2 5][3 6]]11.3、hstack 在 NumPy 中 numpy.hstack水平堆叠函数用于沿着水平方向堆叠数组序列。
numpy.hstack(tup)
函数说明tup一个数组序列它们将被水平堆叠在一起。所有数组在除了第二个轴之外 的轴上必须具有相同的形状。 工作原理 1. 输入验证首先 hstack 会检查所有输入数组是否都是二维的或者至少可以 被视为二维的。如果输入数组是多维的它们将被重新塑造为二维数组。 2. 形状兼容性检查所有输入数组在除了第二个轴列之外的所有其他轴上必须 有相同的形状。这意味着如果输入数组是一系列的矩阵那么这些矩阵的行数 必须相同。例如如果你有两个矩阵 A 和 B它们分别是 3x2 和 3x3 的那么它 们可以在水平方向上堆叠因为它们都有 3 行。 3. 堆叠操作如果输入数组通过了形状兼容性检查 hstack 将沿着第二个轴 列将它们连接起来。这意味着对于每个输入数组它们的列将被依次排列 在一起。 4. 结果数组输出结果是一个新的二维数组其列数是所有输入数组列数的总和 而行数与输入数组中的任何一个相同。 import numpy as np# 创建两个 2x2 的矩阵
a np.array([[1, 2], [3, 4]])
b np.array([[5, 6], [7, 8]])print(f数组a的形状为{a.shape}, 数组a为\n, a)
print(f数组b的形状为{b.shape}, 数组b为\n, b)# 使用 hstack 进行水平堆叠
c np.hstack((a, b))# 输出结果
print(f数组c的形状为{c.shape}, 数组c为\n, c)
数组a的形状为(2, 2), 数组a为[[1 2][3 4]]
数组b的形状为(2, 2), 数组b为[[5 6][7 8]]
数组c的形状为(2, 4), 数组c为[[1 2 5 6][3 4 7 8]]
11.4、vstack numpy.vstack函数用于将多个数组沿垂直方向即沿着第一个轴axis0堆叠成 一个单一的数组
numpy.vstack(tup)
函数说明tup一个包含数组的元组或列表。所有数组在除了第一个轴外的维度上必须具 有相同的形状 工作原理 1. 输入验证 vstack 接受一个数组序列例如一个列表或元组作为输入。所有 输入数组在除了第一个轴外的所有其他维度上必须具有相同的形状。 2. 内存分配 vstack 会计算输出数组的形状并在内存中为这个新数组分配空 间。输出数组的第一个维度将是所有输入数组第一个维度大小的总和其他维度 与输入数组相同。 3. 数据复制 vstack 将输入数组的数据复制到新分配的内存空间中每个输入数 组在新数组中占据连续的块。 4. 结果数组输出结果是一个新的数组其中输入数组沿第一个轴垂直方向堆 叠。 import numpy as np# 创建两个二维数组
a np.array([[1, 2, 3],[4, 5, 6]])
b np.array([[7, 8, 9]])print(f数组a的形状为{a.shape}, 数组a为\n, a)
print(f数组b的形状为{b.shape}, 数组b为\n, b)# 使用 vstack 进行垂直堆叠
c np.vstack((a, b))# 输出结果
print(f数组c的形状为{c.shape}, 数组c为\n, c)
数组a的形状为(2, 3), 数组a为[[1 2 3][4 5 6]]
数组b的形状为(1, 3), 数组b为[[7 8 9]]
数组c的形状为(3, 3), 数组c为[[1 2 3][4 5 6][7 8 9]]
十二、分割数组
12.1、split 该函数用于沿着指定的轴将数组分割成多个子数组可以指定要分割的数组、分割的 位置或子数组的数量。
numpy.split(ary, indices_or_sections, axis0)
函数说明ary要分割的数组indices_or_sections可以是一个整数表示要将数组平均分割成多少个子 数组也可以是一个整数数组表示分割的位置axis沿着哪个轴进行分割默认为 0即第一个轴 工作原理 1. 输入验证 split 接受一个数组 参数 ary 作为输入以及一个指示如何分割数组的 indices_or_sections。如果提供了 axis 参数它指定了沿哪个轴分割 数组默认为 0。 2. 解析分割参数如果 indices_or_sections 是一个整数它表示要将数组分割成多少个大小相等的子数组。如果是一个序列它表示沿指定轴的分割点。 3. 计算分割点如果indices_or_sections是整数split 会计算每个子数组应该包含的元素数量。如果indices_or_sections是一个序列则直接使用这些值作为分割点。 4. 执行分割split 使用计算出的分割点在指定轴上将原始数组分割成多个子数 组。这通常涉及到创建原始数组的视图而不是复制数据。 5. 返回结果 split 返回一个列表其中包含所有分割后的子数组。 # split
import numpy as np# 创建一个一维数组
a np.array([1, 2, 3, 4, 5, 6])# 使用 split 平均分割数组为 3 个子数组
result1 np.split(a, 3, axis0)# 使用 split 按位置分割数组
result2 np.split(a, [1, 2, 4])# 输出结果
print(平均分割为 3 个子数组, result1)
print(按位置分割, result2)
平均分割为 3 个子数组 [array([1, 2]), array([3, 4]), array([5, 6])]
按位置分割 [array([1]), array([2]), array([3, 4]), array([5, 6])]12.2、hsplit numpy.hsplit 用于沿着横向水平方向将数组分割成多个子数组。这个函数是 numpy.split 的一个特化版本专门用于沿着第二个轴axis1进行分割。
numpy.hsplit(ary, indices_or_sections)
函数说明ary要分割的数组indices_or_sections可以是一个整数表示要将数组平均分割成多少个子 数组也可以是一个整数数组表示分割的位置 工作原理 1. 输入验证 hsplit 接受一个数组ary作为输入以及一个指示如何分割数组的参数indices_or_sections。与 split 不同hsplit 不接受axis 参数因为它默认沿着第二个轴axis1进行分割。 2. 解析分割参数如果 indices_or_sections 是一个整数它表示要将数组分割成多少个大小相等的子数组。如果是一个序列它表示沿指定轴的分割点。 3. 计算分割点如果 indices_or_sections 是整数 hsplit 会计算每个子数组 在水平方向上应该包含的列数。如果 indices_or_sections 是一个序列则直 接使用这些值作为分割点。 4. 执行分割 hsplit 使用计算出的分割点在第二个轴上将原始数组分割成多个子 数组。与 split 类似这通常涉及到创建原始数组的视图而不是复制数据。 5. 返回结果 hsplit 返回一个列表其中包含所有分割后的子数组。每个子数组 都是原始数组的一部分沿第二个轴分割而成。 import numpy as np# 创建一个 6x4 的二维数组
arr np.arange(24).reshape(6, 4)# 打印原始数组
print(原始数组:)
print(arr)# 指定每部分应该包含的列数
col_counts [1, 2]# 使用 hsplit 分割数组
subarrays np.hsplit(arr, col_counts)# 打印分割后的子数组
print(\n分割后的子数组:)
print(subarrays)原始数组:
[[ 0 1 2 3][ 4 5 6 7][ 8 9 10 11][12 13 14 15][16 17 18 19][20 21 22 23]]分割后的子数组:
[array([[ 0],[ 4],[ 8],[12],[16],[20]]), array([[ 1],[ 5],[ 9],[13],[17],[21]]), array([[ 2, 3],[ 6, 7],[10, 11],[14, 15],[18, 19],[22, 23]])]12.3、vsplit numpy.vsplit 用于沿着纵向垂直方向将数组分割成多个子数组。这个函数是 numpy.split 的一个特化版本专门用于沿着第一个轴axis0进行分割。
numpy.vsplit(ary, indices_or_sections)
函数说明ary要分割的数组indices_or_sections可以是一个整数表示要将数组平均分割成多少个子 数组也可以是一个整数数组表示分割的位置 工作原理 1. 输入验证 vsplit 接受一个数组 参数 ary 作为输入以及一个指示如何分割数组的 indices_or_sections。与 split 不同 vsplit 不接受 为它默认沿着第一个轴axis0进行分割。 2. 解析分割参数如果 axis 参数因 indices_or_sections 是一个整数它表示要将数组在垂 直方向上平均分割成多少个子数组。如果是一个序列它表示沿第一个轴的分割 点。 3. 计算分割点如果 indices_or_sections 是整数 vsplit 会计算每个子数组 在垂直方向上应该包含的行数。如果 indices_or_sections 是一个序列则直 接使用这些值作为分割点。 4. 执行分割 vsplit 使用计算出的分割点在第一个轴上将原始数组分割成多个子 数组。与 split 类似这通常涉及到创建原始数组的视图而不是复制数据。 5. 返回结果 vsplit 返回一个列表其中包含所有分割后的子数组。每个子数组 都是原始数组的一部分沿第一个轴分割而成。 import numpy as np# 创建一个 6x4 的二维数组
arr np.arange(24).reshape(6, 4)# 打印原始数组
print(原始数组:)
print(arr)# 指定每部分应该包含的列数
col_counts [1, 2]# 使用 hsplit 分割数组
subarrays np.vsplit(arr, col_counts)# 打印分割后的子数组
print(\n分割后的子数组:)
print(subarrays)
原始数组:
[[ 0 1 2 3][ 4 5 6 7][ 8 9 10 11][12 13 14 15][16 17 18 19][20 21 22 23]]分割后的子数组:
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11],[12, 13, 14, 15],[16, 17, 18, 19],[20, 21, 22, 23]])]十三、元素的添加与删除
13.1、append
numpy.append(arr, values, axisNone)
函数说明arr原始数组可以是任何形状values要追加的值它们会被追加到arr的末尾。values的形状必须与arr 在除了要追加的轴之外的所有轴上兼容。axis可选参数指定要追加值的轴。如果axis没有被指定 arr 会被展平values 会被追加到结果数组的末尾。 注意事项 1、numpy.append 在追加元素时如果 arr 的形状。 2、如果 values 是一个数组它的形状必须与 values 是一个标量它会自动广播以匹配 arr 在除了要追加的轴之外的所有 轴上匹配。 3、numpy.append 可能不是最高效的操作因为它涉及到创建一个新的数组。如果 频繁追加元素考虑使用 numpy.concatenate 或 numpy.append 的替代方法 如使用 numpy.resize 和直接赋值。 import numpy as np# 创建一个一维数组
arr np.array([[1, 2, 3], [4, 5, 6]])# 要追加的值
values np.array([[1, 2, 3]])# 使用 numpy.append 追加值
result np.append(arr, values, axis0)# 输出结果
print(result)[[1 2 3][4 5 6][1 2 3]]import numpy as nparr_2d np.array([[1, 2], [3, 4]])# 要追加的值
values_2d np.array([[5], [6]])# 使用 numpy.append 追加值沿着列方向
result_2d np.append(arr_2d, values_2d, axis1)# 输出结果
print(result_2d)[[1 2 5][3 4 6]]13.2、insert 该函数用于在数组的指定位置插入元素。与 numpy.append 不同的是 numpy.insert 允许用户在数组的任意位置插入元素而不仅仅是数组的末尾。
numpy.insert(arr, obj, values, axisNone)
函数说明arr原始数组可以是任何形状。obj表示插入位置的索引。它可以是整数或者整数数组。如果是整数则表示 在哪个位置插入。如果是整数数组则表示在哪些位置插入。values要插入的值。如果 arr 是多维数组则 axis 指定的轴以外的所有轴上与 arr 保持一致。axis可选参数指定插入操作的轴。如果未指定则 values 会被插入到一维数组中。 注意事项 1、如果 obj 是一个整数数组values也会被分割成多个部分每个部分被插入到 对应的索引位置。 2、如果 values 是一个标量它会自动广播以匹配需要插入的位置。 3、插入操作可能会比追加操作更加低效因为它涉及到数组元素的移动。 import numpy as np# 创建一个一维数组
arr np.array([1, 2, 3, 4, 5])
print(arr)result np.insert(arr, 2, 10)print(result)# 在索引 [1, 3] 的位置插入值 [20, 30]
result_2 np.insert(arr, [1, 3], [20, 10])# 输出结果
print(result_2)[1 2 3 4 5]
[ 1 2 10 3 4 5]
[ 1 20 2 3 10 4 5]import numpy as np
# 在二维数组中插入值
arr_2d np.array([[1, 2], [3, 4], [5, 6]])
print(arr_2d)values np.array([[5], [6], [7]])# 在索引 0 的位置沿着列方向插入值 [10]
result_2d np.insert(arr_2d, [0], values, 1)# 输出结果
print(result_2d)[[1 2][3 4][5 6]]
[[5 1 2][6 3 4][7 5 6]]13.3、delete 该函数用于从数组中删除指定的子数组并返回一个新的数组。这个函数允许用户删 除数组中的单个元素或多个连续的元素。 numpy.delete(arr, obj, axisNone) 函数说明arr原始数组可以是任何形状。obj表示要删除的子数组的索引。它可以是单个整数、一个整数列表或一个整 数数组。如果是一个整数它表示要删除单个元素的位置如果是列表或数组 则表示要删除多个元素的位置。axis可选参数指定删除操作的轴。如果未指定则 arr 会被展平然后根 据 obj 指定的索引删除元素。 注意事项 1、如果 obj 是一个列表或数组删除操作会按照索引的顺序进行这意味着删除 操作可能会影响后续索引的位置。 2、如果 obj 中的索引超出数组的范围 numpy.delete 会抛出一个异常。 import numpy as np# 创建一个一维数组
arr np.array([1, 2, 3, 4, 5])# 删除索引 2 的元素
result np.delete(arr, 2)# 输出结果
print(result)# 删除索引 [1, 3] 的元素
result_2 np.delete(arr, [1, 3])# 输出结果
print(result_2)[1 2 4 5]
[1 3 5]import numpy as np# 在二维数组中删除元素
arr_2d np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])# 删除索引 1 的列
result_2d np.delete(arr_2d, 0, axis0)# 输出结果
print(result_2d)[[4 5 6][7 8 9]]
# 删除索引 [0, 2] 的行
result_2d_row np.delete(arr_2d, [0, 2], axis0)# 输出结果
print(result_2d_row)[[4 5 6]]十四、统计计算
14.1、mean 该函数用于计算数组中元素的平均值。它可以计算整个数组的平均值也可以沿着指 定的轴axis计算平均值。
numpy.mean(a, axisNone, dtypeNone, outNone, keepdimsno value)
函数说明a输入数组可以是任何形状的数组。axis可选参数用于指定计算平均值的轴。如果没有指定则计算整个数组 的平均值。如果指定了轴则计算该轴上元素的平均值。dtype可选参数用于指定返回的平均值的数据类型。如果没有指定则通常 返回与输入数组相同的数据类型。out可选参数如果提供结果会直接写入到这个数组中。这个数组必须具有 正确的形状。keepdims可选参数如果设置为 True则计算后的和会保留原始数组的维度其值默认为False
import numpy as np# 创建一个一维数组
arr np.array([1, 2, 3, 4, 5])# 计算整个数组的平均值
mean_arr np.mean(arr)# 输出结果
print(mean_arr)# 创建一个二维数组
arr_2d np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(arr_2d)# 计算整个二维数组的平均值
mean_arr_2d np.mean(arr_2d)# 输出结果
print(mean_arr_2d)# 计算二维数组沿着列的平均值
mean_arr_2d_col np.mean(arr_2d, axis0)# 输出结果
print(mean_arr_2d_col)# 计算二维数组沿着行的平均值
mean_arr_2d_row np.mean(arr_2d, axis1)# 输出结果
print(mean_arr_2d_row)# 使用 keepdimsTrue 保留维度
mean_arr_2d_row_keepdims np.mean(arr_2d, axis1, keepdimsTrue)# 输出结果
print(mean_arr_2d_row_keepdims)a np.array([np.nan, 1, 2, 3])
b np.mean(a)
print(b)
3.0
[[1 2 3][4 5 6][7 8 9]]
5.0
[4. 5. 6.]
[2. 5. 8.]
[[2.][5.][8.]]
nan14.2、sum 该函数用于计算数组中所有元素的和或者沿指定轴计算元素的和。
numpy.sum(a, axisNone, dtypeNone, outNone, keepdimsno value, initialno value, whereno value)
函数说明a输入数组可以是任何形状的数组。axis可选参数用于指定计算和的轴。如果没有指定则计算整个数组的 和。如果指定了轴则计算该轴上元素的和。可以是整数或元组用于指定多个 轴。dtype可选参数指定返回和的数据类型。如果未指定则通常与输入数组的 类型相同除非输入数组为布尔型此时默认返回 int64 或 int32。out可选参数如果提供结果会直接写入到这个数组中。这个数组必须具有 正确的形状。keepdims可选参数如果设置为 True则计算后的和会保留原始数组的维度其值默认为Falseinitial可选参数如果提供则用于指定当数组为空时的初始值。where可选参数用于指定计算和的条件。
import numpy as nparr np.array([[1, 2, 3], [4, 0, 6], [7, 8, 9]])
print(arr)# 计算整个数组的和
total_sum np.sum(arr)
print(total_sum)# 计算每一列的和
sum_col np.sum(arr, axis0, keepdimsTrue)
print(sum_col)# 计算每一行的和
sum_row np.sum(arr, axis1)
print(sum_row)# 保留原始维度
sum_row_keep np.sum(arr, axis1, keepdimsTrue)
print(sum_row_keep)[[1 2 3][4 0 6][7 8 9]]
40
[[12 10 18]]
[ 6 10 24]
[[ 6][10][24]]14.3、max和min numpy.max 和 numpy.min 是 NumPy 库中用于计算数组中元素最大值和最小值的函数
numpy.max(a, axisNone, outNone, keepdimsno value, initialno value, whereno value)
numpy.min(a, axisNone, outNone, keepdimsno value, initialno value, whereno value)
函数说明a输入数组可以是任何形状的数组。axis可选参数用于指定计算最小值、最大值的轴。如果没有指定则计算整个数组 的最小值、最大值。如果指定了轴则计算该轴上元素的最小值、最大值。out可选参数如果提供结果会直接写入到这个数组中。这个数组必须具有 正确的形状。keepdims可选参数如果设置为 True则计算后的最小值、最大值会保留原始数组的维度其默认值为Falseinitial可选参数如果提供则用于指定当数组为空时的初始值。where可选参数用于指定计算最小值、最大值的条件。
import numpy as nparr np.array([[1, 2, 3], [4, 0, 6], [7, 8, 9]])
print(arr)# 计算整个数组的最大值
max_val np.min(arr)
print(max_val)# 计算每一列的最大值
max_val_col np.min(arr, axis0)
print(max_val_col)# 计算每一行的最大值
max_val_row np.min(arr, axis1)
print(max_val_row)[[1 2 3][4 0 6][7 8 9]]
0
[1 0 3]
[1 0 7]14.4、var numpy.var 用于计算数组中所有元素或沿指定轴的方差。方差是衡量一组数值分散 程度的统计量它是各个数值与其平均数差的平方的平均数。
numpy.var(a, axisNone, dtypeNone, outNone, keepdimsno value)
函数说明a输入数组可以是任何形状的数组。axis可选参数用于指定计算方差的轴。如果没有指定则计算整个数组的 方差。如果指定了轴则计算该轴上元素的方差。可以是整数或元组用于指定 多个轴。dtype可选参数指定返回方差的数据类型。如果未指定则通常与输入数组 的类型相同。out可选参数如果提供结果会直接写入到这个数组中。这个数组必须具有 正确的形状。keepdims可选参数如果设置为True,则计算后的方差会保留原始数组的维度其值默认为False
import numpy as nparr np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(arr)# 计算整个数组的方差
total_var np.var(arr)
print(total_var)# 计算每一列的方差
var_col np.var(arr, axis0)
print(var_col)
# 计算每一行的方差
var_row np.var(arr, axis1)
print(var_row)[[1 2 3][4 5 6][7 8 9]]
6.666666666666667
[6. 6. 6.]
[0.66666667 0.66666667 0.66666667]14.5、std numpy.std 用于计算数组中所有元素的标准差或者沿着指定轴计算标准差。标准 差是方差的平方根它也是一种衡量数据分散程度的统计量。
numpy.std(a, axisNone, dtypeNone, outNone, keepdimsno value)
函数说明a输入数组可以是任何形状的数组。axis可选参数用于指定计算标准差的轴。如果没有指定则计算整个数组 的标准差。如果指定了轴则计算该轴上元素的标准差。可以是整数或元组用 于指定多个轴。dtype可选参数指定返回标准差的数据类型。如果未指定则通常与输入数 组的类型相同。out可选参数如果提供结果会直接写入到这个数组中。这个数组必须具有 正确的形状。keepdims可选参数如果设置为True,则计算后的标准差会保留原始数组的维度其值默认为False
import numpy as nparr np.array([[1, 2, 3]])total_var np.var(arr)
print(total_var)
# 计算整个数组的标准差
total_std np.std(arr)
print(total_std)
# 计算每一列的标准差
std_col np.std(arr, axis0)# 计算每一行的标准差
std_row np.std(arr, axis1)print(std_col)
print(std_row)0.6666666666666666
0.816496580927726
[0. 0. 0.]
[0.81649658]14.6、argmax和argmin numpy.argmax 和 numpy.argmin 是 NumPy 库中的两个函数它们分别用于找出 数组中最大值和最小值的索引位置。
numpy.argmax(a, axisNone, outNone)
numpy.argmin(a, axisNone, outNone)
函数说明a输入数组。如果数组是多维的则沿着指定的轴搜索最大值或最小值。axis可选参数用于指定搜索最大值或最小值的轴。如果没有指定则在展 平的数组中进行搜索。如果指定了轴则沿着该轴搜索并返回该轴上的索引位 置。out可选参数如果提供结果会直接写入到这个数组中。这个数组必须具有 正确的形状。
import numpy as nparr np.array([[1, 2, 3], [4, 0, 6], [7, 8, 9]])# 找出整个数组中的最大值和最小值的索引位置
max_index np.argmax(arr)
min_index np.argmin(arr)print(max_index)
print(min_index)# 找出每一列中的最大值和最小值的索引位置
max_index_col np.argmax(arr, axis0)
min_index_col np.argmin(arr, axis0)print(max_index_col)
print(min_index_col)# 找出每一行中的最大值和最小值的索引位置
max_index_row np.argmax(arr, axis1)
min_index_row np.argmin(arr, axis1)print(max_index_row)
print(min_index_row)
8
4
[2 2 2]
[0 1 0]
[2 2 2]
[0 1 0]十五、where函数 numpy.where 是 NumPy 库中的一个非常有用的函数它可以根据指定的条件返回 满足该条件的元素的索引。 当 numpy.where 接受一个条件作为参数时它会返回一个元组其中包含满足该条 件的元素的索引。
numpy.where(condition)
函数说明condition一个布尔数组或条件表达式。
返回值一个元组其中包含满足条件的元素的索引。
import numpy as nparr np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
condition arr 5
print(arr)result np.where(condition)
print(result)[1 2 3 4 5 6 7 8 9]
(array([5, 6, 7, 8]),)十六、思维导图
