numpy高阶函数笔记（持续更新）

1. np.histogram

官方文档：https://numpy.org/doc/stable/reference/generated/numpy.histogram.html

numpy.histogram(a, bins=10, range=None, normed=False, weights=None, density=None)

a：是待统计数据的数组；

bins：指定统计的区间个数；默认为10

range：是一个长度为2的元组，表示统计范围的最小值和最大值，默认值None，表示范围由数据的范围决定

weights：为数组的每个元素指定了权值,histogram()会对区间中数组所对应的权值进行求和

density为True时，返回每个区间的概率密度；为False，返回每个区间中元素的个数

返回值，有两个，

• hist : array 直方图每个区间个数的数组
• bin_edges : 区间范围，区间边界数比区域多一个值

---

>>> a = np.random.rand(100)      #表示在（0,1）之间随机产生100个数
>>> np.histogram(a,bins=5,range=(0,1))
(array([10, 24, 17, 19, 30]), array([0. , 0.2, 0.4, 0.6, 0.8, 1. ]))	#表示在[0,0.2)之间有10个数，以此类推
>>> 

np.histogram()在深度学习中，常用于每个类别标签数量的计数，这里以点云为例，每个点都对应一个类别标签，利用np.histogram()可将标签数量依次统计出来。方便计算每个标签预测的实际正确率。

---

2.np.bincount

它大致说bin的数量比x中的最大值大1，每个bin给出了它的索引值在x中出现的次数。下面，我举个例子让大家更好的理解一下：

# 我们可以看到x中最大的数为7，因此bin的数量为8，那么它的索引值为0->7
x = np.array([0, 1, 1, 3, 2, 1, 7])
# 索引0出现了1次，索引1出现了3次......索引5出现了0次......
np.bincount(x)
#因此，输出结果为：array([1, 3, 1, 1, 0, 0, 0, 1])

# 我们可以看到x中最大的数为7，因此bin的数量为8，那么它的索引值为0->7
x = np.array([7, 6, 2, 1, 4])
# 索引0出现了0次，索引1出现了1次......索引5出现了0次......
np.bincount(x)
#输出结果为：array([0, 1, 1, 0, 1, 0, 1, 1])

下面，我来解释一下weights这个参数。文档说，如果weights参数被指定，那么x会被它加权，也就是说，如果值n发现在位置i，那么out[n] += weight[i]而不是out[n] += 1.**因此，我们weights的大小必须与x相同，否则报错。**下面，我举个例子让大家更好的理解一下：

w = np.array([0.3, 0.5, 0.2, 0.7, 1., -0.6])
# 我们可以看到x中最大的数为4，因此bin的数量为5，那么它的索引值为0->4
x = np.array([2, 1, 3, 4, 4, 3])
# 索引0 -> 0
# 索引1 -> w[1] = 0.5
# 索引2 -> w[0] = 0.3
# 索引3 -> w[2] + w[5] = 0.2 - 0.6 = -0.4
# 索引4 -> w[3] + w[4] = 0.7 + 1 = 1.7
np.bincount(x,  weights=w)
# 因此，输出结果为：array([ 0. ,  0.5,  0.3, -0.4,  1.7])

最后，我们来看一下minlength这个参数。文档说，如果minlength被指定，那么输出数组中bin的数量至少为它指定的数（如果必要的话，bin的数量会更大，这取决于x）。下面，我举个例子让大家更好的理解一下：

# 我们可以看到x中最大的数为3，因此bin的数量为4，那么它的索引值为0->3
x = np.array([3, 2, 1, 3, 1])
# 本来bin的数量为4，现在我们指定了参数为7，因此现在bin的数量为7，所以现在它的索引值为0->6
np.bincount(x, minlength=7)
# 因此，输出结果为：array([0, 2, 1, 2, 0, 0, 0])

# 我们可以看到x中最大的数为3，因此bin的数量为4，那么它的索引值为0->3
x = np.array([3, 2, 1, 3, 1])
# 本来bin的数量为4，现在我们指定了参数为1，那么它指定的数量小于原本的数量，因此这个参数失去了作用，索引值还是0->3
np.bincount(x, minlength=1)
# 因此，输出结果为：array([0, 2, 1, 2])

该函数内容感谢博主Xurtle撰写的博客教程numpy.bincount详解

---

3.np.searchsorted()

定义：

np.searchsorted ( a , v , side = ‘left’ , sorter = None )

在数组a中插入数组v（并不执行插入操作），返回一个下标列表，这个列表指明了v中对应元素应该插入在a中哪个位置上

searchsorted()是查找数组元素时，经常用到的函数。查找一个合适的位置，将元素插入已排好序的一维数组中，并且保持数组元素的顺序不被打乱。

1.参数详解

a : 1-D array_like

输入数组。当sorter参数为None的时候，a必须为升序数组；否则，sorter不能为空，存放a中元素的index，用于反映a数组的升序排列方式。

v : array_like
插入a数组的值，可以为单个元素，list或者array。

side : {‘left’, ‘right’}, optional

查询方向：

当为left时，将返回第一个符合条件的元素下标；默认从左开始检索

当为right时，将返回最后一个符合条件的元素下标，如果没有符合的元素，将返回0或者N（a的长度）

side	returned index i satisfies
left	a[i-1] < v <= a[i]
right	a[i-1] <= v < a[i]

side returned index i satisfies

存放a数组元素的index，index对应元素为升序。

2.示例

import numpy as np
 
a = np.array([0,1,5,9,11,18,26,33])
print(a)
result = np.searchsorted(a,15,side='left',sorter=None)
print(result)

>>> [0 1 5 9 11 18 26 33]
>>> 5 

15在a数组中排序为第5个位置索引

b = a
np.random.shuffle(b)
b_sort = np.argsort(b)
print(b)
print(b_sort)
result2 = np.searchsorted(a,[15.0,2],side='left',sorter=b_sort)
print(result2)

将a数组赋值给b，并打乱，利用argsort（）从小到大排序，再对无序的b进行searchsorted（）

>>>[11 18 5 26 9 33 1 0]
>>>[7 6 2 4 0 1 3 5]
>>>[5 2]

感谢该博主提供的教程

---

4.np.hstack() 和 np.vastack()

np.vstack:按垂直方向（行顺序）堆叠数组构成一个新的数组

import numpy as np

In[4]:
a = np.array([[1,2,3]])
a.shape
Out[4]:
(1, 3)

In [5]:
b = np.array([[4,5,6]])
b.shape
Out[5]:
(1, 3)

In [6]:
c = np.vstack((a,b)) # 将两个（1,3）形状的数组按垂直方向叠加
print(c)
c.shape # 输出形状为（2,3）
[[1 2 3]
 [4 5 6]]
Out[6]:
(2, 3)

In [7]:
a = np.array([[1],[2],[3]])
a.shape
Out[7]:
(3, 1)

In [9]:
b = np.array([[4],[5],[6]])
b.shape
Out[9]:
(3, 1)

In [10]:
c = np.vstack((a,b))  # 将两个（3,1）形状的数组按垂直方向叠加
print(c)
c.shape # 输出形状为（6,1）
[[1]
 [2]
 [3]
 [4]
 [5]
 [6]]
Out[10]:
(6, 1)

np.hstack:按水平方向（列顺序）堆叠数组构成一个新的数组

In[11]:
a = np.array([[1,2,3]])
a.shape
Out[11]:
(1, 3)

In [12]:
b = np.array([[4,5,6]])
b.shape
Out[12]:
(1, 3)

In [16]:
c = np.hstack((a,b)) # 将两个（1,3）形状的数组按水平方向叠加
print(c)
c.shape  # 输出形状为（1,6）
[[1 2 3 4 5 6]]
Out[16]:
(1, 6)

In [17]:
a = np.array([[1],[2],[3]])
a.shape
Out[17]:
(3, 1)
In [18]:
b = np.array([[4],[5],[6]])
b.shape
Out[18]:
(3, 1)
In [19]:
c = np.hstack((a,b)) 将两个（3,1）形状的数组按水平方向叠加
print(c)
c.shape  # 输出形状为（3,2）
[[1 4]
 [2 5]
 [3 6]]
Out[19]:
(3, 2)

---

5.np.ndim

>>>data1 = [1,2,3,4,5,6]
>>>data2 = [[1,2,3],[4,5,6]]
>>>data3 = [[[1,2,3],[4,5,6]][[7,8,9],[10,11,12]]]

>>>arr1 = np.array(data1)
>>>arr2 = np.array(data2)
>>>arr3 = np.array(data3)

>>>print(arr1.ndim,arr2.ndim,arr3.ndim)
[out]
1 2 3

ndim返回的是数组的维度，返回的只有一个数，该数即表示数组的维度

6.np.equal()

在矩阵或者向量x和y中，如果相同位置元素相等，返回True，否则返回False。和**tf.equal()**用法一致。

[in]
a = np.equal(np.array([1,2]),np.array([1,4]))
print(a)

[out]
[True False]

7.np.all()

np.all（）返回的是一个布尔类型的值,测试沿给定轴的所有数组元素是否都计算为True。

[in]
a = np.equal(np.array([1,2]),np.array([1,4]))
print(a)

b = np.all(a)
print(b)

[out]
[True False]
False

np.all([[True,False],[True,True]])
False
默认为对数组里的每个元素进行与运算

np.all([[True,False],[True,True]], axis=0)
array([ True, False], dtype=bool)
当给定axis的值时，则是按照给定方向进行与运算

8.np.tofile() 和np.fromfile()

我们知道numpy的array是可以保存到文件的，一个常用的做法是通过tofile()保存到.bin文件中，然后再通过fromfile()从.bin文件中将其读取出来，下面看一个例子。

如下图所示spatiallyRepresentation是一个二维numpy数组，其shape为[31762, 8]

接下来将其存入文件中，使用tofile方法即可，参数填入想要保存到的文件路径，然后使用fromfile可以将其从文件中读取出来。

但是可以发现，读取出来的test的shape变成1维了，更细心点会发现test的最前面几个值和之前看到的spatiallyRepresentation的值也不一样啊，这是为什么呢？

首先，使用tofile方法，会默认将所有数据按顺序排成一个向量，然后以二进制形式存入文件中，而读取的时候自然会变成1维了，如果已知原始数组的维数，将它reshape一下就行了。

然而即便是reshape后，test也不等于spatiallyRepresentation，即我读取出来的和存进去的数据不一样！
这个解决办法很简单，这是因为读取数据的时候需要指定数据类型。如第一张图里看到的，原始数据是float32类型的。

感谢该博客提供的学习教程

---