NumPy学习4

今天学习NumPy相关数组操作

NumPy 中包含了一些处理数组的常用方法，大致可分为以下几类：
(1)数组变维操作
(2)数组转置操作
(3)修改数组维度操作
(4)连接与分割数组操作

numpy_test4.py :

import numpy as np

'''
10, NumPy相关数组操作
NumPy 中包含了一些处理数组的常用方法，大致可分为以下几类：

(1)数组变维操作
(2)数组转置操作
(3)修改数组维度操作
(4)连接与分割数组操作
'''

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

1) reshape数组变维
数组的形状指的是多维数组的行数和列数。Numpy 模块提供 reshape(i, j) 函数可以改变多维数组行数i和列数j，
从而达到数组变维的目的。因此数组变维即对数组形状的重塑。
2 × 3 --reshape函数数组变维-> 3 × 2
'''
print("----(1) 数组变维操作----")
print("----1) reshape数组变维----")
arr1 = np.array([[1, 3], [2, 4], [3, 6]])    # 3行2列
print("arr1：", arr1)
#变维 2行3列，并不是矩阵的转置方式变维，而是下面最近的数据往上移动变维.
arr2 = arr1.reshape(2, 3)
print("arr2：", arr2)
'''
arr1： [[1 3]
 [2 4]
 [3 6]]
arr2： [[1 3 2]
 [4 3 6]]
'''

'''
2) numpy.ndarray.flat
numpy.ndarray.flat 返回一个数组迭代器
'''
print("----2) numpy.ndarray.flat 数组迭代器----")
print("arr1.flat: ")
#使用flat属性：类似循环输出数组元素
for e in arr1.flat:
    print (e,end="，")
print("\n")
'''
arr1.flat:
1，3，2，4，3，6，
'''

'''
3) numpy.ndarray.flatten()
numpy.ndarray.flatten 返回一份数组副本，对副本修改不会影响原始数组，其语法格式如下：

ndarray.flatten(order='C') 默认按行C风格展开的数组
C-order（行优先顺序）与 F-order（列优先顺序）
'''
print("----3) numpy.ndarray.flatten() 数组副本----")
arr3 = np.arange(9).reshape(3,3)
print("arr3", arr3)
#默认按行C风格展开的数组
arr4 = arr3.flatten()
print("arr4", arr4)
#以F风格顺序展开的数组
arr5 = arr3.flatten(order='F')
print("arr5", arr5)
'''
arr3 [ [0 1 2]
       [3 4 5]
       [6 7 8]]
arr4 [0 1 2 3 4 5 6 7 8]
arr5 [0 3 6 1 4 7 2 5 8]
'''

'''
4) numpy.ravel()
numpy.ravel() 将多维数组中的元素以一维数组的形式展开，该方法返回数组的视图（view），如果修改，则会影响原始数组。

numpy.ravel(arr, order='C') 默认按行C风格展开的数组
C-order（行优先顺序）与 F-order（列优先顺序）
'''
print("----4) numpy.ravel() 数组的视图（view）----")
arr6 = np.arange(9).reshape(3, 3)
print("arr6: ", arr6)
print ('调用 ravel 函数后：')
arr7 = arr6.ravel()
print("arr7: ", arr7)
print ('F 风格顺序调用 ravel 函数之后：')
arr8 = arr6.ravel(order='F')
print("arr8: ", arr8)
'''
arr6:  [ [0 1 2]
         [3 4 5]
         [6 7 8]]
调用 ravel 函数后：
arr7:  [0 1 2 3 4 5 6 7 8]
F 风格顺序调用 ravel 函数之后：
arr8:  [0 3 6 1 4 7 2 5 8]
'''

'''
(2) 数组转置操作

函数名称    说明
transpose    将数组的维度值进行对换，比如二维数组维度(2,4)使用该方法后为(4,2)。
ndarray.T    与 transpose 方法相同。
rollaxis    沿着指定的轴向后滚动至规定的位置。
swapaxes    对数组的轴进行对换。
'''

'''
1) numpy.transpose()
numpy.transpose() 用于对换多维数组的维度，比如二维数组使用此方法可以实现矩阵转置，语法格式如下：

numpy.transpose(arr, axes)
参数说明如下：
arr：要操作的数组
axes：可选参数，元组或者整数列表，将会按照该参数进行转置。
'''
print("----(2) 数组转置操作----")
arr9 = np.arange(6).reshape(3,2)
print("arr9: ", arr9)
print("----1) numpy.transpose() 矩阵转置----")
arr10 = np.transpose(arr9)
print("arr10: ", arr10)
'''
arr9:  [ [0 1]
         [2 3]
         [4 5]]
----1) numpy.transpose() 矩阵转置----
arr10:  [[0 2 4]
         [1 3 5]]
'''
'''
2) ndarray.T 的使用方法与其类似
'''
print("----2) ndarray.T 矩阵转置----")
arr11 = np.transpose(arr9)
print("arr11: ", arr11)
'''
----2) ndarray.T 矩阵转置----
arr11:  [[0 2 4]
         [1 3 5]]
'''

'''
3) numpy.rollaxis()
该方法表示定位沿着指定的轴，向后滚动至一个特置，格式如下：

numpy.rollaxis(arr, axis, start)
参数说明：
arr：要传入的数组；
axis：沿着哪条轴向后滚动，其它轴的相对位置不会改变；
start：默认以 0 轴开始，可以根据数组维度调整它的值。
'''
# 创建了三维的 ndarray
arr12 = np.arange(27).reshape(3, 3, 3)
print("arr12: ", arr12)
print("----3) numpy.rollaxis() 定位沿着指定的轴，向后滚动至一个特置----")
arr13 = np.rollaxis(arr12, 2)
print("arr13: ", arr13)
'''
arr12:  [[[ 0  1  2]
          [ 3  4  5]
          [ 6  7  8]]

         [[ 9 10 11]
          [12 13 14]
          [15 16 17]]

         [[18 19 20]
          [21 22 23]
          [24 25 26]]]
----3) numpy.rollaxis() 定位沿着指定的轴，向后滚动至一个特置----
arr13:  [[[ 0  3  6]
          [ 9 12 15]
          [18 21 24]]

         [[ 1  4  7]
          [10 13 16]
          [19 22 25]]

         [[ 2  5  8]
          [11 14 17]
          [20 23 26]]]
'''

'''
4) numpy.swapaxes()
该方法用于交换数组的两个轴，其语法格式如下：
numpy.swapaxes(arr, axis1, axis2)
'''
print("----4) numpy.swapaxes() 交换数组的两个轴----")
#对换0轴与2轴
arr14 = np.swapaxes(arr12, 2, 0)
print("arr14: ", arr14)
'''
----4) numpy.swapaxes() 交换数组的两个轴----
arr14:  [[[ 0  9 18]
          [ 3 12 21]
          [ 6 15 24]]

         [[ 1 10 19]
          [ 4 13 22]
          [ 7 16 25]]

         [[ 2 11 20]
          [ 5 14 23]
          [ 8 17 26]]]
'''

'''
(3) 修改数组维度操作
修改数组维度的操作，主要有以下方法：

数组维度修改
函数名称    描述说明
broadcast    生成一个模拟广播的对象。
broadcast_to    将数组广播为新的形状。
expand_dims    扩展数组的形状。
squeeze    从数组的形状中删除一维项。
'''
print("----(3) 修改数组维度操作----")
'''
1) numpy.broadcast()
该函数以两个数组作为输入参数,返回值是数组被广播后的对象
'''
print("----1) numpy.broadcast() 数组被广播----")
a1 = np.array([[1], [2], [3]])
b1 = np.array([4, 5, 6])
# 对b1广播a1
d1 = np.broadcast(a1, b1)
print("d1: ", d1)
#d1它拥有 iterator 属性
r1, c1 = d1.iters
print("next(r1), next(c1): ", next(r1), next(c1))
print("next(r1), next(c1): ", next(r1), next(c1))
# 使用broadcast将a1与b1相加
e1 = np.broadcast(a1, b1)
print("e1: ", e1)
f = np.empty(e1.shape)
print("f: ", f)
f.flat = [x+y for (x,y) in e1]
print("f.flat: ", f)
print("a1+b1: ", a1+b1)
'''
d1:  <numpy.broadcast object at 0x000001EFFEEB58A0>
next(r1), next(c1):  1 4
next(r1), next(c1):  1 5
e1:  <numpy.broadcast object at 0x000001EFFEEB7160>
f:  [[0.00000000e+000 0.00000000e+000 0.00000000e+000]
 [0.00000000e+000 0.00000000e+000 3.02368175e-321]
 [0.00000000e+000 0.00000000e+000 5.97409933e-299]]
f.flat:  [[5. 6. 7.]
 [6. 7. 8.]
 [7. 8. 9.]]
a1+b1:  [[5 6 7]
 [6 7 8]
 [7 8 9]]
'''

'''
2) numpy.broadcast_to()
该函数将数组广播到新形状中，它在原始数组的基础上返回一个只读视图。
如果新形状不符合 NumPy 的广播规则，则会抛出 ValueError 异常。函数的语法格式如下：

numpy.broadcast_to(array, shape, subok)
'''
a1 = np.arange(4).reshape(1,4)
print("a1: ",a1)
print("----2) numpy.broadcast_to() 数组广播到新形状----")
a2 = np.broadcast_to(a1, (3, 4))
print("a2: ",a2)
'''
a1: [[0 1 2 3]]
调用 broadcast_to 函数之后：
a2: [[0 1 2 3]
     [0 1 2 3]
     [0 1 2 3]]
'''

'''
3) numpy.expand_dims()
在指定位置插入新的轴，从而扩展数组的维度，语法格式如下:

numpy.expand_dims(arr, axis)
参数说明：
arr：输入数组
axis：新轴插入的位置
'''
print("----3) numpy.expand_dims() 在指定位置插入新的轴，从而扩展数组的维度----")
x1 = np.array(([1, 2], [3, 4]))
print('数组 x1 ：', x1)
# 在 0 轴处插入新的轴
y1 = np.expand_dims(x1, axis=0)
print('数组 y1 ：', y1)
print('数组 x1 的形状：', x1.shape)
print('数组 y1 的形状：', y1.shape)
'''
数组 x1 ： [[1 2]
 [3 4]]
数组 y1 ： [[[1 2]
  [3 4]]]
数组 x1 的形状： (2, 2)
数组 y1 的形状： (1, 2, 2)
'''

'''
4) numpy.squeeze()
删除数组中维度为 1 的项，例如，一个数组的 shape 是 (5,1)，经此函数后，shape 变为 (5,) 。
其函数语法格式如下：
numpy.squeeze(arr, axis)

参数说明：
arr：输入数的组；
axis：取值为整数或整数元组，用于指定需要删除的维度所在轴，指定的维度值必须为 1 ，否则将会报错，
    若为 None，则删除数组维度中所有为 1 的项。
'''
print("----4) numpy.squeeze() 删除数组中维度为 1 的项----")
a1 = np.arange(9).reshape(1, 3, 3)
print('a1 ：', a1)
print('数组 a1 的形状：', a1.shape)
b1 = np.squeeze(a1)
print('b1 ：', b1)
print('数组 b1 的形状：', b1.shape)
'''
a1 ： [[[0 1 2]
  [3 4 5]
  [6 7 8]]]
数组 a1 的形状： (1, 3, 3)
b1 ： [[0 1 2]
 [3 4 5]
 [6 7 8]]
数组 b1 的形状： (3, 3)
'''

'''
(4) 连接与分割数组操作
连接与分割数组是数组的两种操作方式，如下所示：

连接与分割数组
类型    函数名称    描述说明
连接数组方法
    concatenate    沿指定轴连接两个或者多个相同形状的数组
    stack    沿着新的轴连接一系列数组
    hstack    按水平顺序堆叠序列中数组（列方向）
    vstack    按垂直方向堆叠序列中数组（行方向）
分割数组方法
    split    将一个数组分割为多个子数组
    hsplit    将一个数组水平分割为多个子数组（按列）
    vsplit    将一个数组垂直分割为多个子数组（按行）
'''

'''
1) 连接数组操作
numpy.concatenate() 沿指定轴连接相同形状的两个或多个数组，格式如下：

numpy.concatenate((a1, a2, ...), axis)
参数说明：
a1, a2, ...：表示一系列相同类型的数组；
axis：沿着该参数指定的轴连接数组，默认为 0。

实例说明：创建两个 a 、b 数组，并沿指定轴将它们连接起来。注意两个数组的形状要保持一致。
'''
print("----(4) 连接与分割数组操作----")
print("----1) 连接数组操作----")
#创建数组a
a1 = np.array([[1, 2], [3, 4]])
print('a1: ', a1)
#创建数组b
b1 = np.array([[5, 6], [7, 8]])
print('b1: ', b1)
#沿轴 0 连接两个数组
print('np.concatenate((a1,b1)): ', np.concatenate((a1, b1)))
#沿轴 1 连接两个数组
print('np.concatenate((a,b),axis = 1): ', np.concatenate((a1, b1),axis=1))
#垂直堆叠
print('np.vstack((a1,b1)): ', np.vstack((a1,b1)))
'''
a1:  [[1 2]
 [3 4]]
b1:  [[5 6]
 [7 8]]
np.concatenate((a1,b1)):  [[1 2]
 [3 4]
 [5 6]
 [7 8]]
np.concatenate((a,b),axis = 1):  [[1 2 5 6]
 [3 4 7 8]]
np.vstack((a1,b1)):  [[1 2]
 [3 4]
 [5 6]
 [7 8]]
数组连接操作至少需要两个维度相同的数组，才允许对它们进行垂直或者水平方向上的操作。
'''

'''
2) 分割数组操作
numpy.split() 沿指定的轴将数组分割为多个子数组，语法格式如下：

numpy.split(ary, indices_or_sections, axis)
参数说明：
ary：被分割的数组
indices_or_sections：若是一个整数，代表用该整数平均切分，若是一个数组，则代表沿轴切分的位置（左开右闭）；
axis：默认为0，表示横向切分；为1时表示纵向切分。
'''
print("----2) 分割数组操作----")
a1 = np.arange(8)
#原数组
print('a1: ', a1)
#将数组分为二个形状大小相等的子数组
b1 = np.split(a1, 2)
print('b1: ', b1)
#将数组在一维数组中标明要位置分割
b2 = np.split(a1, [3, 4])
print('b2: ', b2)
a2 = a1.reshape(2,4)
print('a2: ', a2)
b3 = np.hsplit(a2, 4)
print('b3: ', b3)
'''
a1:  [0 1 2 3 4 5 6 7]
b1:  [array([0, 1, 2, 3]), array([4, 5, 6, 7])]
b2:  [array([0, 1, 2]), array([3]), array([4, 5, 6, 7])]
a2:  [[0 1 2 3]
 [4 5 6 7]]
b3:  [array([[0],
       [4]]), array([[1],
       [5]]), array([[2],
       [6]]), array([[3],
       [7]])]
'''