Numpy简易教程8——简易分析

使用函数进行简单的统计分析

1．排序

NumPy的排序方式主要可以概括为直接排序和间接排序两种。

• 直接排序指对数值直接进行排序。
• 间接排序是指根据一个或多个键对数据集进行排序。
  在NumPy中，直接排序经常使用sort函数，间接排序经常使用argsort函数和lexsort函数。

1.1 sort函数

sort 函数是最常用的排序方法，无返回值。
如果目标函数是一个视图，则原始数据将会被修改。

使用sort函数排序时可以指定一个axis参数，使得sort函数可以沿着指定轴对数据集进行排序。

案例：使用sort函数进行排序

np.random.seed(42)  #设置随机种子
arr = np.random.randint(1,10,size = 10)  #生成随机数
print('创建的数组为：',arr)

arr.sort()  #直接排序
print('排序后数组为：',arr)

arr = np.random.randint(1,10,size = (3,3))  #生成3行3列的随机数
print('创建的数组为：',arr)

arr.sort(axis = 1)  #沿着横轴排序
print('排序后数组为：',arr)

arr.sort(axis = 0)  #沿着纵轴排序
print('排序后数组为：',arr)

创建的数组为： [7 4 8 5 7 3 7 8 5 4]
排序后数组为： [3 4 4 5 5 7 7 7 8 8]
创建的数组为： [[8 8 3]
 [6 5 2]
 [8 6 2]]
排序后数组为： [[3 8 8]
 [2 5 6]
 [2 6 8]]
排序后数组为： [[2 5 6]
 [2 6 8]
 [3 8 8]]

1.2 argsort函数和lexsort函数

使用argsort函数和lexsort函数，可以在给定一个或多个键时，得到一个由整数构成的索引数组，索引值表示数据在新的序列中的位置。

lexsort函数可以一次性对满足多个键的数组执行间接排序。

案例：使用argsort函数进行排序

arr = np.array([2,3,6,8,0,7])
print('创建的数组为：',arr)
print('排序后数组为：',arr.argsort())  #返回值为重新排序值的下标

创建的数组为： [2 3 6 8 0 7]
排序后数组为： [4 0 1 2 5 3]

案例：使用lexsort函数排序

a = np.array([3,2,6,4,5])
b = np.array([50,30,40,20,10])
c = np.array([400,300,600,100,200])
d = np.lexsort((a,b,c))  #lexsort函数只接受一个参数，即（a,b,c）
#多个键值排序是按照最后一个传入数据计算的
print('排序后数组为：',list(zip(a[d],b[d],c[d])))

排序后数组为： [(4, 20, 100), (5, 10, 200), (2, 30, 300), (3, 50, 400), (6, 40, 600)]

2．去重与重复数据

在统计分析的工作中，难免会出现“脏”数据的情况。重复数据就是“脏”数据的情况之一。若一个一个地手动删除，耗时费力，效率低。

2.1 使用unique函数去重

在NumPy中，可以通过unique函数找出数组中的唯一值并返回已排序的结果。

案例：数组内数据去重

names = np.array(['小明', '小黄', '小花', '小明', 
    '小花', '小兰', '小白'])
print('创建的数组为：',names)

print('去重后的数组为：',np.unique(names))

#跟np.unique等价的Python代码实现过程
print('去重后的数组为：',sorted(set(names)))

创建的数组为： ['小明' '小黄' '小花' '小明' '小花' '小兰' '小白']
去重后的数组为： ['小兰' '小明' '小白' '小花' '小黄']
去重后的数组为： ['小兰', '小明', '小白', '小花', '小黄']

2.2 使用tile函数和repeat函数实现数据重复

另一种情况，在统计分析中也经常遇到，即需要把一个数据重复若干次。在NumPy中主要使用tile函数和repeat函数实现数据重复。

tile函数

tile函数的格式如下：numpy.tile(A, reps)。tile函数主要有两个参数，参数A指定重复的数组，参数reps指定重复的次数。

案例：使用tile函数实现数据重复

arr = np.arange(5)
print('创建的数组为：',arr)
print('重复后数组为：',np.tile(arr,3))  #对数组进行重复

创建的数组为： [0 1 2 3 4]
重复后数组为： [0 1 2 3 4 0 1 2 3 4 0 1 2 3 4]

arr = np.arange(9).reshape(3,3)
print('创建的数组为：',arr)
print('重复后数组为：',np.tile(arr,3))  #对数组进行重复

创建的数组为： [[0 1 2]
 [3 4 5]
 [6 7 8]]
重复后数组为： [[0 1 2 0 1 2 0 1 2]
 [3 4 5 3 4 5 3 4 5]
 [6 7 8 6 7 8 6 7 8]]

repeat函数

repeat函数的格式如下：numpy.repeat(a, repeats, axis=None)
repeat函数主要有3个参数，参数a指定需要重复的数组元素，参数repeats指定重复次数，参数axis指定沿着哪个轴进行重复。

案例：使用repeat函数实现数据重复

np.random.seed(42)  #设置随机种子
arr = np.random.randint(0,10,size = (3,3))
print('创建的数组为：',arr)
print('重复后数组为：',arr.repeat(2, axis = 0))  #按行进行元素重复
print('重复后数组为：',arr.repeat(2, axis = 1))  #按列进行元素重复

创建的数组为： [[6 3 7]
 [4 6 9]
 [2 6 7]]
重复后数组为： [[6 3 7]
 [6 3 7]
 [4 6 9]
 [4 6 9]
 [2 6 7]
 [2 6 7]]
重复后数组为： [[6 6 3 3 7 7]
 [4 4 6 6 9 9]
 [2 2 6 6 7 7]]

这两个函数的主要区别在于，tile函数是对数组进行重复操作，repeat函数是对数组中的每个元素进行重复操作。

3．常用的统计函数

在NumPy中，有许多可以用于统计分析的函数。常见的统计函数有sum、mean、std、var、min和max等。

几乎所有的统计函数在针对二维数组计算的时候都需要注意轴的概念。当axis参数为0时，表示沿着纵轴进行计算。当axis为1时，表示沿着横轴进行计算。但在默认时，函数并不按照任一轴向计算，而是计算一个总值。

函数	说明
sum	计算数组的和
mean	计算数组均值
std	计算数组标准差
var	计算数组方差
min	计算数组最小值
max	计算数组最大值
argmin	返回数组最小元素的索引
argmax	返回数组最小元素的索引
cumsum	计算所有元素的累计和
cumprod	计算所有元素的累计积

案例：常用统计函数

arr = np.arange(20).reshape(4,5)
print('创建的数组为：',arr)
print('数组的和为：',np.sum(arr))  #计算数组的和
print('数组横轴的和为：',arr.sum(axis = 0))  #沿着横轴计算求和
print('数组纵轴的和为：',arr.sum(axis = 1))  #沿着纵轴计算求和
print('数组的均值为：',np.mean(arr))  #计算数组均值
print('数组横轴的均值为：',arr.mean(axis = 0))  #沿着横轴计算数组均值
print('数组纵轴的均值为：',arr.mean(axis = 1))  #沿着纵轴计算数组均值
print('数组的标准差为：',np.std(arr))  #计算数组标准差
print('数组的方差为：',np.var(arr))  #计算数组方差
print('数组的最小值为：',np.min(arr))  #计算数组最小值
print('数组的最大值为：',np.max(arr))  #计算数组最大值
print('数组的最小元素为：',np.argmin(arr))  #返回数组最小元素的索引
print('数组的最大元素为：',np.argmax(arr))  #返回数组最大元素的索引

创建的数组为： [[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]]
数组的和为： 190
数组横轴的和为： [30 34 38 42 46]
数组纵轴的和为： [10 35 60 85]
数组的均值为： 9.5
数组横轴的均值为： [ 7.5  8.5  9.5 10.5 11.5]
数组纵轴的均值为： [ 2.  7. 12. 17.]
数组的标准差为： 5.766281297335398
数组的方差为： 33.25
数组的最小值为： 0
数组的最大值为： 19
数组的最小元素为： 0
数组的最大元素为： 19

在NumPy中，cumsum 函数和 cumprod 函数采用不聚合计算，产生一个由中间结果组成的数组。

arr = np.arange(2,10)
print('创建的数组为：',arr)
print('数组元素的累计和为：',np.cumsum(arr))  #计算所有元素的累计和
print('数组元素的累计积为：',np.cumprod(arr))  #计算所有元素的累计积

创建的数组为： [2 3 4 5 6 7 8 9]
数组元素的累计和为： [ 2  5  9 14 20 27 35 44]
数组元素的累计积为： [     2      6     24    120    720   5040  40320 362880]