3.1.2 数据操作
面对如此多样与多量的数据,本小节介绍一些常见的数据操作方法,有助于面对数据时,可以快速并准确的的处理数据,主要的操作所使用的包是第二章所介绍的 Numpy。
广播(Broadcast)
numpy 可以利用广播 (Broadcast) 这个方法对不同形状(shape)的数组进行数值计算的方式,比方说向量与标量的算术运算。
实例
import numpy as np
s = 10
v = np.array([1,2,3,4])
print(v + s)
# 输出结果如下:
[11 12 13 14]
矩阵与标量的算术运算。
实例
import numpy as np
s = 10
m = np.array([[1,2,3],[2,3,4]])
print(m + s)
# 输出结果如下:
[[11 12 13]
[12 13 14]]
张量与标量的算术运算
实例
import numpy as np
s = 10
t = np.array([[[1,2,3],[2,3,4]],
[[1,2,3],[2,3,4]]])
t + s
# 输出结果如下:
array([[[11, 12, 13],
[12, 13, 14]],
[[11, 12, 13],
[12, 13, 14]]])
从以上案例来看,广播这个方法是可以在张量之间进行运算的,因为标量、向量、矩阵都是张量的一种,以下实例是一个 2 * 3 与 1 * 3 的矩阵进行运算的结果。
实例
import numpy as np
m1 = np.array([[1,2,3],
[2,3,4]])
m2 = np.array([5,6,7])
print(m1 + m2)
print(m1 * m2)
# 输出结果如下:
[[ 6 8 10]
[ 7 9 11]]
[[ 5 12 21]
[10 18 28]]
加法计算方式如下所示:
- m1[0] + m2[0] = [1+5 2+6 3+7] = [ 6 8 10 ]
- m1[1] + m2[0] = [2+5 3+6 4+7] = [ 7 9 11 ]
乘法计算方式如下所示:
- m1[0] * m2[0] = [1*5 2*6 3*7] = [ 5 12 21 ]
- m1[1] * m2[0] = [2*5 3*6 4*7] = [10 18 28 ]
修改形状
函数 | 描述 |
---|---|
reshape | 不改变数据的条件下修改形状 |
flat | 回传数组元素迭代器 |
flatten | 返回一份数组拷贝,对拷贝所做的修改不会影响原始数组 |
ravel | 返回展开数组 |
reshape 函数格式如下:
reshape(arr, newshape, order=‘C’)
- arr:要修改形状的数组
- newshape:整数或者整数数组,新的形状应当兼容原有形状
- order:‘C’ – 按行,‘F’ – 按列,‘A’ – 原顺序。
reshape 可以直接修改数组的形状,以下实例将一个 0 到 7 的 一维数组,变更为 4 * 2 的二维数组。
实例
import numpy as np
a = np.arange(8).reshape(4,2)
print ('原始数组:')
print (a)
print ('\n')
# 输出结果如下:
原始数组:
[[0 1]
[2 3]
[4 5]
[6 7]]
flat 是 numpy.ndarray 对象的一个属性,会回传数组元素迭代器,所以对其进行修改会直接修改到原始数组。以下实例会修改 flat 属性所回传的值,并检查是否会影响到原来的数组,观察输出结果是有影响的。
实例
f1 = a.flat
# 显示 flat 的数据形态,是 numpy.flatiter 数组元素迭代器
print(type(f1))
f1[0] = 10
print ('修改 flat 后的数组:')
print (a)
# 输出结果如下:
<class 'numpy.flatiter'>
修改 flat 后的数组:
[[10 1]
[ 2 3]
[ 4 5]
[ 6 7]]
flatten() 方法返回一份数组拷贝,对拷贝所做的修改不会影响原始数组,格式如下:
flatten(order=‘C’)
- order:‘C’ – 按行,‘F’ – 按列,‘A’ – 原顺序。
以下实例会修改 flatten 方法所回传的值,显示其数据形态,是 numpy.ndarray,回传的值以列为主来展平,并检查是否会影响到原来的数组,观察输出结果是没有影响的。
实例
f2 = a.flatten(order='F')
print(type(f2))
print(f2)
f2[1] = 11
print ('修改 flatten 后的数组:')
print (a)
# 输出结果如下:
<class 'numpy.ndarray'>
[10 2 4 6 1 3 5 7]
修改 flatten 后的数组:
[[10 1]
[ 2 3]
[ 4 5]
[ 6 7]]
ravel() 方法展平的数组元素,顺序通常是"C风格",返回的是数组视图(view,有点类似 C/C++引用reference的意味),修改会影响原始数组。,格式如下:
ravel(a, order=‘C’)
- order:‘C’ – 按行,‘F’ – 按列,‘A’ – 原顺序。
以下实例会修改 ravel 方法所回传的值,显示其数据形态,是 numpy.ndarray,回传的值以行为主来展平,并检查是否会影响到原来的数组,观察输出结果是有影响的。
实例
f3 = a.ravel(order='C')
print(type(f3))
print(f3)
f3[2] = 12
print ('修改 ravel 后的数组:')
print (a)
# 输出结果如下:
<class 'numpy.ndarray'>
[10 1 2 3 4 5 6 7]
修改 ravel 后的数组:
[[10 1]
[12 3]
[ 4 5]
[ 6 7]]
修改维度
函数 | 描述 |
---|---|
expand_dims | 扩展数组的形状 |
squeeze | 从数组的形状中删除一维条目 |
expand_dims() 函数通过在指定位置插入新的轴来扩展数组形状,函数格式如下:
expand_dims(arr, axis)
- arr:输入数组
- axis:新轴插入的轴位置
以下我们建立一个二维数组,大小为 3 * 2 ( 3 行,2 列),而所谓的 轴 0,就是针对"行"进行操作,轴 1 ,就是针对"列"进行操作,比较简单的判断方法就是 shape 的第 1 的数就是 axis 0,第 2 的数就是 axis 1。分别创建两个数组 x1, x2,分别新增一个轴在轴 0 以及轴 1。
axis 1 | axis 1 | |
---|---|---|
axis 0 | 1 | 2 |
axis 0 | 3 | 4 |
axis 0 | 5 | 6 |
实例
import numpy as np
x = np.array([[1, 2], [3, 4], [5, 6]])
print ('数组 x:')
print (x)
print('\n x 数组的维度(轴)的数量', x.ndim)
print('\n x 数组的形状为 ', x.shape)
print('\n 针对轴 0 进行加总\n', x.sum(axis=0))
# 在轴 0 位置插入一个轴
print('\n 在轴 0 位置插入一个轴')
x1 = np.expand_dims(x, axis = 0)
print ('\n 新数组 x1 的形状', x1.shape)
print('\n 针对 x1 轴 1 进行加总\n', x1.sum(axis=1))
# 在轴 1 位置插入一个轴
print('\n 在轴 1 位置插入一个轴')
x2 = np.expand_dims(x, axis = 1)
print ('\n 新数组 x2 的形状', x2.shape)
print('\n 针对 x2 轴 0 进行加总\n', x2.sum(axis=0))
输出结果为:
数组 x:
[[1 2]
[3 4]
[5 6]]
x 数组的维度(轴)的数量 2
x 数组的形状为 (3, 2)
针对轴 0 进行加总
[ 9 12]
在轴 0 位置插入一个轴
新数组 x1 的形状 (1, 3, 2)
针对 x1 轴 1 进行加总
[[ 9 12]]
在轴 1 位置插入一个轴
新数组 x2 的形状 (3, 1, 2)
针对 x2 轴 0 进行加总
[[ 9 12]]
squeeze() 函数从给定数组的形状中删除一维的条目,这一维条目的子集形状如果大于 1 则是引发错误。函数格式如下:
squeeze(arr, axis)
- arr:输入数组
- axis:整数或整数元组,用于选择形状中一轴条目的子集 (single-dimensional entries)
继续上述的实例,有两个数组 x1, x2,形状分别为 (1, 3, 2) 与 (3, 1, 2),因为只有一个轴为单一元素,所以在不指定第二个参数 axis 的情况下,都可以正常运行,但如果指定到非一个元素的轴,会生成错误。
实例
import numpy as np
x = np.array([[1, 2], [3, 4], [5, 6]])
x1 = np.expand_dims(x, axis = 0)
x2 = np.expand_dims(x, axis = 1)
print ('数组 x:')
print (x)
# 对 x1 进行 squeeze 运算
print ('\n 新数组 x1 的形状', x1.shape)
print('\n 针对 x1 进行 squeeze 运算\n', np.squeeze(x1))
# 对 x2 进行 squeeze 运算
print ('\n 新数组 x2 的形状', x2.shape)
print('\n 针对 x2 进行 squeeze 运算\n', np.squeeze(x2))
# 对 x1 指定轴 (>1) 进行 squeeze 运算
print ('\n 新数组 x1 的形状', x1.shape)
print('\n 指定针对 x1 的轴 1 进行 squeeze 运算\n', np.squeeze(x1,axis = 1))
输出结果为:
数组 x:
[[1 2]
[3 4]
[5 6]]
新数组 x1 的形状 (1, 3, 2)
针对 x1 进行 squeeze 运算
[[1 2]
[3 4]
[5 6]]
新数组 x2 的形状 (3, 1, 2)
针对 x2 进行 squeeze 运算
[[1 2]
[3 4]
[5 6]]
新数组 x1 的形状 (1, 3, 2)
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-28-4fbbc9c10cd7> in <module>
1 print ('\n 新数组 x1 的形状', x1.shape)
----> 2 print('\n 指定针对 x1 的轴 1 进行 squeeze 运算\n', np.squeeze(x1,axis = 1))
<__array_function__ internals> in squeeze(*args, **kwargs)
~\AppData\Roaming\Python\Python37\site-packages\numpy\core\fromnumeric.py in squeeze(a, axis)
1493 return squeeze()
1494 else:
-> 1495 return squeeze(axis=axis)
1496
1497
ValueError: cannot select an axis to squeeze out which has size not equal to one
翻转数组
函数 | 描述 |
---|---|
transpose | 对换数组的维度 |
ndarray.T | 和 self.transpose() 相同 |
moveaxis | 函数将数组的轴移动到新的位置 |
transpose() 函数用于对换数组的维度,格式如下:
transpose(arr, axes)
- arr:要操作的数组
- axes:整数,列表或是元祖,对应维度,通常所有维度都会对换。
实例
import numpy as np
x = np.array([[1, 2], [3, 4], [5, 6]])
print ('数组 x:')
print (x)
print('\n x 数组的维度(轴)的数量', x.ndim)
print('\n x 数组的形状为 ', x.shape)
print('\n 在轴 0 位置插入一个轴')
x1 = np.expand_dims(x, axis = 0)
print ('\n 新数组 x1 的形状', x1.shape)
print ('对换数组 x :')
print (np.transpose(x))
print ('对换数组 x1 ,指定维度将原来的 (1, 3, 2) 改为 (3, 2, 1):')
print ('对换数组后的 x1 形状与内容', np.transpose(x1,[1,2,0]).shape)
print (np.transpose(x1,[1,2,0]))
输出结果如下:
数组 x:
[[1 2]
[3 4]
[5 6]]
x 数组的维度(轴)的数量 2
x 数组的形状为 (3, 2)
在轴 0 位置插入一个轴
新数组 x1 的形状 (1, 3, 2)
对换数组 x :
[[1 3 5]
[2 4 6]]
对换数组 x1 ,指定维度将原来的 (1, 3, 2) 改为 (3, 2, 1):
对换数组后的 x1 形状与内容 (3, 2, 1)
[[[1]
[2]]
[[3]
[4]]
[[5]
[6]]]
numpy.ndarray.T 类似 numpy.transpose,差别为 T 是属性,transpose()是方法;transpose()有更大的弹性,可以任意调整轴数的对应。
实例
import numpy as np
x = np.array([[1, 2], [3, 4], [5, 6]])
print ('数组 x:')
print (x)
print ('转置数组 x.T :')
print (x.T)
输出结果如下:
数组 x:
[[1 2]
[3 4]
[5 6]]
转置数组 x.T :
[[1 3 5]
[2 4 6]]
moveaxis() 函数将数组的轴移动到新的位置,其他坐标轴保持原来的顺序。格式如下:
moveaxis(arr, source, destination)
- arr:数组
- source:移动轴的原始位置。
- destination:每个原始轴的目标位置。
以下实例将轴 0 移到 最后一个轴 (-1),以及将最后一个轴 (-1) 移到轴 0 。
实例
import numpy as np
x = np.arange(24).reshape(2,3,4)
print(x.shape)
print(np.moveaxis(x, 0, -1).shape)
print(np.moveaxis(x, -1, 0).shape)
输出结果如下:
(2, 3, 4)
(3, 4, 2)
(4, 2, 3)
连接数组
函数 | 描述 |
---|---|
concatenate | 连接沿现有轴的数组序列 |
stack | 沿着新的轴加入一系列数组。 |
hstack | 水平堆叠序列中的数组(列方向) |
vstack | 竖直堆叠序列中的数组(行方向) |
concatenate() 函数用于沿指定轴连接相同形状的两个或多个数组,格式如下:
numpy.concatenate((a1, a2, …), axis)
- a1, a2, …:相同类型的数组
- axis:沿着它连接数组的轴,默认为 0
实例
import numpy as np
x = np.arange(6).reshape(2,3)
y = np.arange(6,12).reshape(2,3)
print ('第 1 个数组:\n',x)
print ('第 2 个数组:\n',y)
# 沿轴 0 连接两个数组
print ('沿轴 0 连接两个数组:')
print (np.concatenate((x, y)))
# 沿轴 1 连接两个数组
print ('沿轴 1 连接两个数组:')
print (np.concatenate((x, y),axis = 1))
输出结果为:
第 1 个数组:
[[0 1 2]
[3 4 5]]
第 2 个数组:
[[ 6 7 8]
[ 9 10 11]]
沿轴 0 连接两个数组:
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
沿轴 1 连接两个数组:
[[ 0 1 2 6 7 8]
[ 3 4 5 9 10 11]]
stack() 函数用于沿新轴连接数组序列,格式如下:
numpy.stack(arrays, axis)
- arrays相同形状的数组序列
- axis:返回数组中的轴,输入数组沿着它来堆叠
实例
import numpy as np
x = np.arange(6).reshape(2,3)
y = np.arange(6,12).reshape(2,3)
print ('第 1 个数组:\n',x)
print ('第 2 个数组:\n',y)
print ('沿轴 0 堆叠两个数组:')
s1 = np.stack((x,y),0)
print ('新数组形状与内容', s1.shape)
print (s1)
print ('沿轴 1 堆叠两个数组:')
s2 = np.stack((x,y),1)
print ('新数组形状与内容', s2.shape)
print (s2)
输出结果如下:
第 1 个数组:
[[0 1 2]
[3 4 5]]
第 2 个数组:
[[ 6 7 8]
[ 9 10 11]]
沿轴 0 堆叠两个数组:
新数组形状与内容 (2, 2, 3)
[[[ 0 1 2]
[ 3 4 5]]
[[ 6 7 8]
[ 9 10 11]]]
沿轴 1 堆叠两个数组:
新数组形状与内容 (2, 2, 3)
[[[ 0 1 2]
[ 6 7 8]]
[[ 3 4 5]
[ 9 10 11]]]
hstack() 是 stack() 函数的变体,它通过水平堆叠来生成数组。
实例
import numpy as np
x = np.arange(6).reshape(2,3)
y = np.arange(6,12).reshape(2,3)
print ('第 1 个数组:\n',x)
print ('第 2 个数组:\n',y)
print ('水平堆叠:')
hs = np.hstack((x, y))
print ('新数组形状与内容', hs.shape)
print (hs)
输出结果如下:
第 1 个数组:
[[0 1 2]
[3 4 5]]
第 2 个数组:
[[ 6 7 8]
[ 9 10 11]]
水平堆叠:
新数组形状与内容 (2, 6)
[[ 0 1 2 6 7 8]
[ 3 4 5 9 10 11]]
vstack() 是 stack() 函数的变体,它通过垂直堆叠来生成数组。
实例
import numpy as np
x = np.arange(6).reshape(2,3)
y = np.arange(6,12).reshape(2,3)
print ('第 1 个数组:\n',x)
print ('第 2 个数组:\n',y)
print ('竖直堆叠:')
vs = np.vstack((x,y))
print ('新数组形状与内容', vs.shape)
print (vs)
输出结果为:
第 1 个数组:
[[0 1 2]
[3 4 5]]
第 2 个数组:
[[ 6 7 8]
[ 9 10 11]]
竖直堆叠:
新数组形状与内容 (4, 3)
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
分割数组
函数 | 数组及操作 |
---|---|
split | 将一个数组分割为多个子数组 |
hsplit | 将一个数组水平分割为多个子数组(按列) |
vsplit | 将一个数组垂直分割为多个子数组(按行) |
split() 函数沿特定的轴将数组分割为子数组,格式如下:
split(ary, indices_or_sections, axis)
- ary:被分割的数组
- indices_or_sections:如果是一个整数,就用该数平均切分,如果无法均分会出错,如果是一个数组,为沿轴切分的位置(左开右闭)
- axis:沿着哪个维度进行切向,默认为 0,横向切分。为 1 时,纵向切分
实例
import numpy as np
x = np.arange(6)
print ('数组 x :\n',x)
print ('将数组分为 2 个大小相等的子数组:')
s1,s2 = np.split(x,2)
print ('第 1 个数组:',s1,'\n第 2 个数组:',s2)
print ('\n')
print ('将数组在一维数组中表明的位置 [2,3] 分割:')
s3, s4, s5 = np.split(x,[2,3])
print ('第 1 个数组:',s3,'\n第 2 个数组:',s4,'\n第 3 个数组:',s5)
print ('\n')
输出结果为:
数组 x :
[0 1 2 3 4 5]
将数组分为 2 个大小相等的子数组:
第 1 个数组: [0 1 2]
第 2 个数组: [3 4 5]
将数组在一维数组中表明的位置 [2,3] 分割:
第 1 个数组: [0 1]
第 2 个数组: [2]
第 3 个数组: [3 4 5]
hsplit() 函数用于水平分割数组,通过指定要返回的相同形状的数组数量来拆分原数组。
hsplit(ary, indices_or_sections)
- ary:被分割的数组
- indices_or_sections:如果是一个整数,就用该数平均切分,如果是一个数组,为沿轴切分的位置(左开右闭)
实例
import numpy as np
x = np.arange(12).reshape(3,4)
print ('数组 x :\n',x)
print ('将数组分为 2 个大小相等的子数组:')
h1,h2 = np.hsplit(x,2)
print ('第 1 个数组:',h1,'\n第 2 个数组:',h2)
print ('\n')
print ('将数组在一维数组中表明的位置 [2,3] 分割:')
h3, h4, h5 = np.hsplit(x,[2,3])
print ('第 1 个数组:\n',h3,'\n第 2 个数组:\n',h4,'\n第 3 个数组:\n',h5)
print ('\n')
输出结果为:
数组 x :
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
将数组分为 2 个大小相等的子数组:
第 1 个数组: [[0 1]
[4 5]
[8 9]]
第 2 个数组: [[ 2 3]
[ 6 7]
[10 11]]
将数组在一维数组中表明的位置 [2,3] 分割:
第 1 个数组:
[[0 1]
[4 5]
[8 9]]
第 2 个数组:
[[ 2]
[ 6]
[10]]
第 3 个数组:
[[ 3]
[ 7]
[11]]
numpy.vsplit() 沿着垂直轴分割,其分割方式与 hsplit() 用法相同。
实例
import numpy as np
x = np.arange(10).reshape(3,4)
print ('数组 x :\n',x)
print ('将数组分为 2 个大小相等的子数组:')
h1,h2 = np.hsplit(x,2)
print ('第 1 个数组:\n',h1,'\n第 2 个数组:\n',h2)
print ('\n')
print ('将数组在一维数组中表明的位置 [2,3] 分割:')
h3, h4, h5 = np.hsplit(x,[2,3])
print ('第 1 个数组:\n',h3,'\n第 2 个数组:\n',h4,'\n第 3 个数组:\n',h5)
print ('\n')
输出结果为:
数组 x :
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
将数组分为 2 个大小相等的子数组:
第 1 个数组:
[[0 1]
[4 5]
[8 9]]
第 2 个数组:
[[ 2 3]
[ 6 7]
[10 11]]
将数组在一维数组中表明的位置 [2,3] 分割:
第 1 个数组:
[[0 1]
[4 5]
[8 9]]
第 2 个数组:
[[ 2]
[ 6]
[10]]
第 3 个数组:
[[ 3]
[ 7]
[11]]
元素的添加与删除
函数 | 元素及描述 |
---|---|
resize | 返回指定形状的新数组 |
append | 将值添加到数组末尾 |
insert | 沿指定轴将值插入到指定下标之前 |
delete | 删掉某个轴的子数组,并返回删除后的新数组 |
unique | 查找数组内的唯一元素 |
resize() 函数返回指定大小的新数组。如果新数组大小大于原始大小,则包含原始数组中的元素的副本。
resize(arr, shape)
- arr:要修改大小的数组
- shape:返回数组的新形状
实例
import numpy as np
x = np.arange(6).reshape(2,3)
print ('原始数组:\n', x)
print ('缩小为 2*2 数组:\n', np.resize(x, (2,2)))
print ('扩增为 3*3 数组:\n', np.resize(x, (3,3)))
输出结果为:
原始数组:
[[0 1 2]
[3 4 5]]
缩小为 2*2 数组:
[[0 1]
[2 3]]
扩增为 3*3 数组:
[[0 1 2]
[3 4 5]
[0 1 2]]
append() 函数在数组的末尾添加值。 追加操作会分配整个数组,并把原来的数组复制到新数组中。 此外,输入数组的维度必须匹配否则将生成ValueError。append 函数返回的始终是一个一维数组。
numpy.append(arr, values, axis=None)
- arr:输入数组
- values:要向 arr 添加的值,需要和 arr 形状相同(除了要添加的轴)
- axis:默认为 None。当 axis 无定义时,是横向加成,返回总是为一维数组!当 axis 有定义的时候,为 0 的时候(列数要相同);为 1 时,数组是加在右边(行数要相同)。
实例
import numpy as np
x = np.arange(6).reshape(2,3)
print ('原始数组:\n', x)
print ('向数组添加元素:')
print (np.append(x, [7,8,9]))
print ('沿轴 0 添加元素:')
print (np.append(x, [[7,8,9]],axis = 0))
print ('沿轴 1 添加元素:')
print (np.append(x, [[5,5,5],[7,8,9]],axis = 1))
输出结果为:
原始数组:
[[0 1 2]
[3 4 5]]
向数组添加元素:
[0 1 2 3 4 5 7 8 9]
沿轴 0 添加元素:
[[0 1 2]
[3 4 5]
[7 8 9]]
沿轴 1 添加元素:
[[0 1 2 5 5 5]
[3 4 5 7 8 9]]
insert() 函数在给定索引之前,沿给定轴在输入数组中插入值。如果值的类型转换为要插入,则它与输入数组不同。 插入没有原地的,函数会返回一个新数组。 此外,如果未提供轴,则输入数组会被展开。
insert(arr, obj, values, axis)
- arr:输入数组
- obj:在其之前插入值的索引
- values:要插入的值
- axis:沿着它插入的轴,如果未提供,则输入数组会被展开
实例
import numpy as np
x = np.arange(6).reshape(3,2)
print ('原始数组:\n', x)
print ('未传递 Axis 参数。 在插入之前输入数组会被展开。')
print (np.insert(x,1,[11,12]))
print ('传递了 Axis 参数。 会广播值数组来配输入数组。')
print ('沿轴 0 广播:\n',np.insert(x,2,[9,10],axis = 0))
print ('沿轴 1 广播:\n',np.insert(x,1,8,axis = 1))
输出结果如下:
原始数组:
[[0 1]
[2 3]
[4 5]]
未传递 Axis 参数。 在插入之前输入数组会被展开。
[ 0 11 12 1 2 3 4 5]
传递了 Axis 参数。 会广播值数组来配输入数组。
沿轴 0 广播:
[[ 0 1]
[ 2 3]
[ 9 10]
[ 4 5]]
沿轴 1 广播:
[[0 8 1]
[2 8 3]
[4 8 5]]
delete() 函数返回从输入数组中删除指定子数组的新数组。 与 insert() 函数的情况一样,如果未提供轴参数,则输入数组将展开。
Numpy.delete(arr, obj, axis)
- arr:输入数组
- obj:可以被切片,整数或者整数数组,表明要从输入数组删除的子数组
- axis:沿着它删除给定子数组的轴,如果未提供,则输入数组会被展开
实例
import numpy as np
x = np.arange(6).reshape(3,2)
print ('原始数组:\n', x)
print ('未传递 Axis 参数。 在删除之前输入数组会被展开。')
print (np.delete(x,5))
print ('删除第二列:\n',np.delete(x,1,axis = 1))
print ('使用切片的语法 [::3] 删除数组中内容(每三个删除一个:')
print (np.delete(x, np.s_[::3]))
输出结果为:
原始数组:
[[0 1]
[2 3]
[4 5]]
未传递 Axis 参数。 在删除之前输入数组会被展开。
[0 1 2 3 4]
删除第二列:
[[0]
[2]
[4]]
使用切片的语法删除数组中内容:
[1 2 4 5]
unique() 函数用于去除数组中的重复元素。
unique(arr, return_index, return_inverse, return_counts)
- arr:输入数组,如果不是一维数组则会展开
- return_index:如果为 True ,返回新列表元素在旧列表中的位置 (index),并以列表形式储
- return_inverse:如果为 True ,返回旧列表元素在新列表中的位置 (index),并以列表形式储
- return_counts:如果为 True ,返回去重数组中的元素在原数组中的出现次数
实例
import numpy as np
x = np.array([1, 2, 6, 2, 3, 5, 6, 8, 2, 9])
indices = np.arange(len(x))
print ('原始数组:\n', x)
print ('原始数组索引:\n', indices)
print ('原始数组的去重值:\n',np.unique(x))
_ , indices_res = np.unique(x, return_index = True)
print ('去重数组的索引数组:\n', indices_res)
输出结果为:
原始数组:
[1 2 6 2 3 5 6 8 2 9]
原始数组索引:
[0 1 2 3 4 5 6 7 8 9]
原始数组的去重值:
[1 2 3 5 6 8 9]
去重数组的索引数组:
[0 1 4 5 2 7 9]