3-01-2 数据操作

Yehchitsai

已于 2022-04-19 09:57:36 修改

阅读量315

点赞数

分类专栏： Python数据处理文章标签： Python

于 2022-04-17 15:17:16 首次发布

本文链接：https://blog.csdn.net/m0_50614038/article/details/124230069

版权

Python数据处理专栏收录该内容

42 篇文章 4 订阅

订阅专栏

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]

Python数据处理-文章目录

Yehchitsai

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
3-01-2 数据操作

3.1.2 数据操作面对如此多样与多量的数据，本小节介绍一些常见的数据操作方法，有助于面对数据时，可以快速并准确的的处理数据，主要的操作所使用的包是第二章所介绍的 Numpy。广播(Broadcast)numpy 可以利用广播 (Broadcast) 这个方法对不同形状(shape)的数组进行数值计算的方式，比方说向量与标量的算术运算。实例import numpy as np s = 10v = np.array([1,2,3,4]) print(v + s) # 输出结果如下：
复制链接

扫一扫

专栏目录