numpy入门<二>

链接数组

1、concatenate((arr1, arr2…), axis)

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

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维度上的元素`进行堆叠形成一个新的维度，这个堆叠是竖直上的堆叠，也就是待链接的数组竖直放在一起，将元素同一列的整合成一个数组，可能有点抽象，结合一个例子可能好理解一点

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上的数组求并得到一个新数组放到原来数组的位置上，维度不发生变化

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来实现

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份，会根据元素数量进行微调)

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)  
返回值是一个元组，里面只有一个元素，即满足条件的数组的下标所组成的数组，后面会跟它的类型

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

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

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

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

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

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)  
这个方法返回的是数组的拷贝，改变不会影响原数组

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

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

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]

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

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

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

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]