Numpy的ndarray的合并与分割

# 导入numpy
import numpy as np

ndarray的合并

定义要使用的数据源

a = np.array([1, 1, 1])
b = np.array([2, 2, 2])

print('a', a)
print('b', b)
<class 'numpy.ndarray'>
a [1 1 1]
b [2 2 2]

numpy.vstack()函数

语法：vstack(tup)，参数是一个元组，它可将元组中指定的数组进行合并

# 将a与b合并
c = np.vstack((a, b))
print('合并结果：\n', c)
print('c的形状：\n', c.shape)
合并结果：
 [[1 1 1]
 [2 2 2]]
c的形状：
 (2, 3)

从结果来看，两上一维数组合并后的结果是一个地维数组

numpy.hstack()函数

语法：hstack(tup)，参数是一个元组

与 vstack不同的是，vstack将数组进行纵向合并，而hstack将数组进行横向合并

vstack 是 vertical stack 的缩写

hstack 是 horizontal stack 的缩写

# 将a与b合并
c = np.hstack((a, b))
print('合并结果：\n', c)
print('c的形状：\n', c.shape)
合并结果：
 [1 1 1 2 2 2]
c的形状：
 (6,)

可以看出，两个一维数组对象横向合并后，还是一个一维的序列，不过，元素的个数是被合并数组元素个数之和

将a或b行转成列

a = a.T
print(a)
[1 1 1]

上面的方式是无法将a进行行转列的，原因是a是个一维数组，它根本就没有列，正确的方式是：

c = a.reshape((3, 1))
print(c)
[[1]
 [1]
 [1]]

重新定义形状后，现在a是一个3行1列的矩阵，即一个二维数据

思考：a.reshape()是将a所指向的数组的形状改变了吗？再来查看a

print(a)
[1 1 1]

实际上，a.reshape()只是创建了一个a的副本，然后将该副本的内存地址赋给了变量c，而a变量所指向的数组还是原来的对象

newaxis属性

还有另外一组方式可以改变a的形状，也是返回一个不置可否；axis表示“轴”的意思

# 在行上增加一个维度（增加一个轴）
c = a[np.newaxis, :]
print(c)
print(c.shape)

print('-'*15)

# 在列上增加一个维度
c = a[:, np.newaxis]
print(c)
print(c.shape)
[[1 1 1]]
(1, 3)
---------------
[[1]
 [1]
 [1]]
(3, 1)

可以看出，返回的新对象的维度都已经发生了变化，在列方向上增加维度以后，将原先的一维数组变成了纵向的二维数组

_a = a[:, np.newaxis]
_b = b[:, np.newaxis]

c = np.hstack((_a, _b))
print(c)
[[1 2]
 [1 2]
 [1 2]]

也可以将同一个对象进行合并

print(np.hstack((_a, _a, _b, _b)))
[[1 1 2 2]
 [1 1 2 2]
 [1 1 2 2]]

concatenate()也可以将数组进行合并，通过axis可以指定合并的方向

# 横向合并 
c = np.concatenate((_a, _a, _b, _b), axis=1)
# 纵向合并 
d = np.concatenate((_a,_b), axis=0)

print(c)
print('-'*10)
print(d)
[[1 1 2 2]
 [1 1 2 2]
 [1 1 2 2]]
----------
[[1]
 [1]
 [1]
 [2]
 [2]
 [2]]

ndarray的分割

定义操作的数据源

# 定义操作的数据源
a = np.arange(12).reshape((3,4))
print(a)
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

按列分割

print(a)
print('-'*15)
print(np.split(a, 2, axis=1))
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
---------------
[array([[0, 1],
       [4, 5],
       [8, 9]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11]])]

split第一个参数指要被分割的数组对象，第二个参数指将该对象分成几份，第三个参数指是从横向分割还是纵向分割，这里按列将其分成了两部分，类似于一个西瓜从上切下，切成了左右两半！按列分割，指定参数axis=1

按行分割

print(a)
print('-'*15)
print(np.split(a, 3, axis=0))
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
---------------
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]

split第一个参数指要被分割的数组对象，第二个参数指将该对象分成几份，第三个参数指是从横向分割还是纵向分割，这里按行将其分成了三部分，类似于一个西瓜肚子上横切两刀，切成了上中下三部分！按行分割，指定参数axis=0

如果要将三行的数据分成2份，是分报错的，如下

print(np.split(a, 2, axis=0))
---------------------------------------------------------------------------

    TypeError                                 Traceback (most recent call last)

    ~\Anaconda3\envs\tensorflow\lib\site-packages\numpy\lib\shape_base.py in split(ary, indices_or_sections, axis)
        534     try:
    --> 535         len(indices_or_sections)
        536     except TypeError:


    TypeError: object of type 'int' has no len()



    During handling of the above exception, another exception occurred:


    ValueError                                Traceback (most recent call last)

    <ipython-input-42-7bb000e8eddf> in <module>()
    ----> 1 print(np.split(a, 2, axis=0))


    ~\Anaconda3\envs\tensorflow\lib\site-packages\numpy\lib\shape_base.py in split(ary, indices_or_sections, axis)
        539         if N % sections:
        540             raise ValueError(
    --> 541                 'array split does not result in an equal division')
        542     res = array_split(ary, indices_or_sections, axis)
        543     return res


    ValueError: array split does not result in an equal division

如果要对数组进行不对等分割，类似于3行分成2份，则需要用到np.array_split()

print(a)
print('-'*15)
print(np.array_split(a, 2, axis=0))
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
---------------
[array([[0, 1, 2, 3],
       [4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]

在不对等的分割中，并不会出现1.5行这样的情况，所以会分成2行和1行

vsplit()和hsplit()

# 纵向分割
print(np.vsplit(a, 3))
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]

vsplit()中的v是指Vertical的意思，指纵向的，垂直的；按行分割就是纵向分割，因为数据被分成了上下部分，类似于西瓜横切

# 横向分割
print(np.hsplit(a, 2))
[array([[0, 1],
       [4, 5],
       [8, 9]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11]])]

hsplit()中的h是Horizontal的意思，指横向；按列分割就是横向的意思，因为将数据分成了左右两半，就像西瓜纵切