##链接数组
###1、concatenate((arr1, arr2…), axis)
前面跟数组组成的元组，后面跟想要链接的维度(即保持其他维度不变，在axis维度上进行合并),默认是0

1
2
3
4
5
6
7
8
9
10
11
12
13
14
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
arr = np.concatenate((arr1, arr2))
print(arr)
res:
[1 2 3 4 5 6]

arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5, 6], [7, 8]])
arr = np.concatenate((arr1, arr2), axis=1)
print(arr)
res:
[[1 2 5 6]
 [3 4 7 8]]

###2、stack((arr1, arr2…), axis)
前面也是跟链接的数组，后面链接的维度，在axis维度上进行链接，axis默认为0，stack堆叠，顾名思义是要在axis维度上进行堆叠，保持其他维度不变，在axis维度上的元素进行堆叠形成一个新的维度，这个堆叠是竖直上的堆叠，也就是待链接的数组竖直放在一起，将元素同一列的整合成一个数组，可能有点抽象，结合一个例子可能好理解一点

1
2
3
4
5
6
7
8
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
arr = np.stack((arr1, arr2), axis=1)
print(arr)
res:
[[1 4]
 [2 5]
 [3 6]]

###3、hstack((arr1, arr2…), axis)
基本上和上面的一样，但是这个堆叠是水平的(即按照第二个维度进行堆叠，axis=1)，而且不会形成新的维度，即将axis=1上的数组求并得到一个新数组放到原来数组的位置上，维度不发生变化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
arr1 = np.array([[1, 2, 3], [1, 2, 3]])
arr2 = np.array([[4, 5, 6], [4, 5, 6]])
arr = np.hstack((arr1, arr2))
print(arr)
res:
[[1 2 3 4 5 6]
 [1 2 3 4 5 6]]

arr1 = np.array([[[1, 2, 3], [1, 2, 3]]])
arr2 = np.array([[[4, 5, 6], [4, 5, 6]]])
arr = np.hstack((arr1, arr2))
print(arr)
res:
[[[1 2 3]
  [1 2 3]
  [4 5 6]
  [4 5 6]]]

###4、vstack()
也是类似的，在axis=0上进行堆叠，即在axis=0上取并，实际上这种可以通过np.concatenate来实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
arr1 = np.array([[[1, 2, 3], [1, 2, 3]]])
arr2 = np.array([[[4, 5, 6], [4, 5, 6]]])
arr = np.vstack((arr1, arr2))
print(arr)
print(arr1.shape)
print(arr.shape)
res:
[[[1 2 3]
  [1 2 3]]

 [[4 5 6]
  [4 5 6]]]
(1, 2, 3)
(2, 2, 3)

###5、dstack()
也是类似，在第三维上进行堆叠，即在axis=2上取并，如果是一维，就相当于reshape成(1，n，1)再在axis=2上堆叠，如果是二维则是reshape成(n，m，1)再开始堆叠，通过reshape和np.concatenate也可以完成一样的工作，这几种特殊的stack只有dstack有可能会形成新的维度(即传入的数组都是一维或者二维)

##数组拆分
###1、array_split(arr，num，axis)
将一个数组在axis维度上分成num份，默认axis=0(这个如果你在axis上的元素的数量不能平分成num份，会根据元素数量进行微调)

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
arr = np.array([1, 2, 3, 4, 5, 6])
newarr = np.array_split(arr, 4)
print(newarr)
res:
[array([1, 2]), array([3, 4]), array([5]), array([6])]  # 返回的是套数组的数组

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15], [16, 17, 18]])
newarr = np.array_split(arr, 3, axis=1)
print(newarr)
res:
[array([[ 1],
       [ 4],
       [ 7],
       [10],
       [13],
       [16]]), array([[ 2],
       [ 5],
       [ 8],
       [11],
       [14],
       [17]]), array([[ 3],
       [ 6],
       [ 9],
       [12],
       [15],
       [18]])]

###2、hsplit()、vsplit()、dsplit()
同样的，有hsplit()对应hstack()(axis=1),vsplit()对应vstack()(axis=0)，dsplit()对应dstack()(axis=2)
##搜索数组元素
###1、np.where(condition)
返回值是一个元组，里面只有一个元素，即满足条件的数组的下标所组成的数组，后面会跟它的类型

1
2
3
4
5
6
7
8
9
10
11
arr = np.array([1, 2, 3, 4, 5, 4, 4])
x = np.where(arr == 4)
print(x)
res:
(array([3, 5, 6], dtype=int64),)

arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])
x = np.where(arr%2 == 0)
print(x)
res:
(array([1, 3, 5, 7], dtype=int64),)

2、searchsorted()
它在数组中执行二分查找，并返回指定值插入位置的索引，以保持搜索顺序。似乎对排好序的数组用处比较大

1
2
3
4
5
arr = np.array([6, 7, 8, 9])
x = np.searchsorted(arr, 7)
print(x)
res: #应该将数字7插入索引1以保持排序顺序。该方法从左开始搜索，返回第一个索引，即数字7不再大于下一个值的位置。
1

默认情况下返回最左边的索引，但我们可以指定side=’right’来返回最右边的索引。

1
2
3
4
5
arr = np.array([6, 7, 8, 9])
x = np.searchsorted(arr, 7, side='right')
print(x)
res:
2  # 数字7应该插入索引2以保持排序顺序。该方法从右边开始搜索，返回第一个索引，即数字7不再小于下一个值。

而且，这个方法还可以同时搜索多个值应当插入的位置

1
2
3
4
5
arr = np.array([1, 3, 5, 7])
x = np.searchsorted(arr, [2, 4, 6])
print(x)
res:  # 返回值是一个数组:[1 2 3]，包含3个索引，其中2、4、6将被插入到原始数组中以保持顺序。
[1 2 3]

##数组排序
###1、np.sort(arr)
这个方法返回的是数组的拷贝，改变不会影响原数组

1
2
3
4
arr = np.array([3, 2, 0, 1])
print(np.sort(arr))
res:
[0 1 2 3]

同样可以对字符串等其他数据类型排序

1
2
3
4
5
6
7
8
9
arr = np.array(['banana', 'cherry', 'apple'])
print(np.sort(arr))
res:
['apple' 'banana' 'cherry']

arr = np.array([True, False, True])
print(np.sort(arr))
res:
[False  True  True]

如果是高维的数组，会将最里面的所有’一维数组‘进行排序

1
2
3
4
5
arr = np.array([[3, 2, 4], [5, 0, 1]])
print(np.sort(arr))
res:
[[2 3 4]
 [0 1 5]]

##过滤数组
从现有数组中获取一些元素并从中创建一个新数组，这称为过滤。在NumPy中，使用布尔索引列表来过滤数组。
如果某个索引的值为True，则该元素包含在过滤后的数组中;如果该索引的值为False，则该元素不包含在过滤后的数组中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
arr = np.array([41, 42, 43, 44])
x = [True, False, True, False]
newarr = arr[x]
print(newarr)
res:
[41 43]

arr = np.array([41, 42, 43, 44])
filter_arr = arr > 42  # 直接创建过滤数组
newarr = arr[filter_arr]
print(filter_arr)
print(newarr)
res:
[False False  True  True]
[43 44]