分类： numpy

numpy random multinomial 多项式分布 函数入门介绍

NumPy是一个开源的Python科学计算库,我们在之前的文章中已经对其做了基本的介绍，而且也对numpy的数据结构、基础函数等做了入门的讲解。

numpy random是其很重要的一个模块，在此模块中有很多有实际应用价值的函数，每个函数都会对应一个或者多个数学场景。本篇旨在介绍其中的一个关于多项式分布取样本的函数– multinomial

1、multinomial介绍

numpy.random.multinomial(n, pvals, size=None)

  • n : int：实验次数
  • pvals：浮点数序列，长度p。P个不同结果的概率。这些值应该和为1（但是，只要求和（pvals[：-1]）<=1，最后一个元素总是被假定为考虑剩余的概率）。
  • size : int 或 int的元组，可选。 输出形状。如果给定形状为（m，n，k），则绘制 mnk 样本。默认值为无，在这种情况下返回单个值。

返回值： ndarray，每个条目 [i，j，…，：] 都是从分布中提取的一个n维值。

多项式分布，从多项式分布中提取样本。

多项式分布是二项式分布的多元推广。做一个有P个可能结果的实验。这种实验的一个例子是掷骰子，结果可以是1到6。从分布图中提取的每个样本代表n个这样的实验。其值x_i = [x_0，x_1，…，x_p] 表示结果为i的次数。

2、实例介绍

官方文档中已经给出了非常简洁易懂的实例，我们直接拿过来摆一下。这个实例就是掷骰子。

场景描述：我们知道骰子一共是6面，每个面代表一个数字，分别是1、2、3、4、5、6.我们每次抛骰子得到的数字公概率上来讲都是等概率的1/6；那么我们做一组实验，抛20次骰子得到的样本会是什么样的呢？通过 numpy.random.multinomial 函数将此场景再现出来就是以下代码：

>>> np.random.multinomial(20, [1/6.]*6, size=1)
array([[4, 1, 7, 5, 2, 1]])

以上的代码和结果输出表示的是：我们得到数字是1的次数是4次，得到2的次数是1词，得到3的次数是7次，以此类推。

返回值的数字表示样本值的次数，而对应数字的数组索引位置表示的是实际的值。

如果我们循环来对同一场景做多次样本实验呢？

for i in range(4):
    a =np.random.multinomial(20, [1/6.]*6, size=1)
    print(a)

#[[2 6 3 5 3 1]]
#[[4 4 1 3 4 4]]
#[[0 4 3 5 2 6]]
#[[4 3 2 5 3 3]]

我们可以看出每次的实验结果都是不一样的。这也体现了实际情况下有限实现取样的随机性。

多次取样在官方实验的代码demo是通过参数来控制的。

>>> np.random.multinomial(20, [1/6.]*6, size=2)
array([[3, 4, 3, 3, 4, 3],
       [2, 4, 3, 4, 0, 7]])

size在这个地方跟我们通过循环多次实验是一样的效果。

numpy array sort 数组操作的基本函数入门(三)

NumPy 是 Python 科学计算的基础包。之前我们已经介绍过了三角函数、算术函数、统计函数等基础函数；此外NumPy还提供了多种排序的方法。 这些排序函数实现不同的排序算法，每个排序算法的特征在于执行速度，最坏情况性能，所需的工作空间和算法的稳定性。

1、numpy.sort()：函数返回输入数组的排序副本。

numpy.sort(a, axis, kind, order)

参数说明：

a: 要排序的数组
axis: 沿着它排序数组的轴，如果没有数组会被展开，沿着最后的轴排序， axis=0 按列排序，axis=1 按行排序
kind: 默认为'quicksort'（快速排序）
order: 如果数组包含字段，则是要排序的字段
种类速度最坏情况工作空间稳定性
'quicksort'（快速排序）1O(n^2)0否
'mergesort'（归并排序）2O(n*log(n))~n/2是
'heapsort'（堆排序）3O(n*log(n))0否
三种排序算法比较
    a = np.array([[3, 7], [8, 6]])
    print("a = ", a)
    print("np.sort(a) = ", np.sort(a))
    print("np.sort(a, axis=0) = ", np.sort(a, axis=0))
    print("np.sort(a, axis=1) = ", np.sort(a, axis=1))

    # 在 sort 函数中排序字段
    dt = np.dtype([('maoxian', 'S10'), ('age', int)])
    a = np.array([("raju", 21), ("anil", 25), ("ravi", 17), ("amar", 27)], dtype=dt)
    print(np.sort(a, order='age'))

2、numpy.argsort() 函数返回的是数组值从小到大的索引值。

    x = np.array([6, 4, 8])
    print("np.argsort(x) = ", np.argsort(x))

3、msort、sort_complex、partition、argpartition、numpy.lexsort()

函数描述
msort(a)数组按第一个轴排序，返回排序后的数组副本。np.msort(a) 相等于 np.sort(a, axis=0)。
sort_complex(a)对复数按照先实部后虚部的顺序进行排序。
partition(a, kth[, axis, kind, order])指定一个数，对数组进行分区
argpartition(a, kth[, axis, kind, order])可以通过关键字 kind 指定算法沿着指定轴对数组进行分区
其它排序函数介绍

numpy.lexsort() 用于对多个序列进行排序。把它想象成对电子表格进行排序，每一列代表一个序列，排序时优先照顾靠后的列。

这里举一个应用场景：小升初考试，重点班录取学生按照总成绩录取。在总成绩相同时，数学成绩高的优先录取，在总成绩和数学成绩都相同时，按照英语成绩录取…… 这里，总成绩排在电子表格的最后一列，数学成绩在倒数第二列，英语成绩在倒数第三列。

    a = np.array([3, 4, 2, 1])
    np.partition(a, 3)  # 将数组 a 中所有元素（包括重复元素）从小到大排列，3 表示的是排序数组索引为 3 的数字，比该数字小的排在该数字前面，比该数字大的排在该数字的后面
    np.partition(a, (1, 3))  # 小于 1 的在前面，大于 3 的在后面，1和3之间的在中间

4、numpy.argmax() 和 numpy.argmin()

numpy.argmax() 和 numpy.argmin()函数分别沿给定轴返回最大和最小元素的索引。

5、numpy.nonzero()、numpy.where()、numpy.extract()

numpy.nonzero() 函数返回输入数组中非零元素的索引。
numpy.where() 函数返回输入数组中满足给定条件的元素的索引。
numpy.extract() 函数根据某个条件从数组中抽取元素，返回满条件的元素。
    a = np.array([[30, 40, 0], [0, 20, 10], [50, 0, 60]])
    print("np.nonzero(a) = ", np.nonzero(a))
    print("np.where(a > 20) =", np.where(a > 20))
    condition = np.mod(a, 6) == 0
    print("'np.mod(a, 6) == 0' =", condition)
    print(np.extract(condition, a))
# 返回两个数组对象，两个数组对应索引位置的值组成一个原始数组元素的位置
np.nonzero(a) =  (array([0, 0, 1, 1, 2, 2], dtype=int64), array([0, 1, 1, 2, 0, 2], dtype=int64))
np.where(a > 20) = (array([0, 0, 2, 2], dtype=int64), array([0, 1, 0, 2], dtype=int64))
'np.mod(a, 6) == 0' = [[ True False  True]
 [ True False False]
 [False  True  True]]
[30  0  0  0 60]

numpy statistic functions 数组操作的基本函数入门(二)

NumPy 是 Python 科学计算的基础包。除去三角、算术函数等基础函数，基本的统计函数是必不可少的。
NumPy 提供了很多统计函数，用于从数组中查找最小元素，最大元素，百分位标准差和方差等。

numpy 呀

1、最大最小及相关函数

numpy.amin() 用于计算数组中的元素沿指定轴的最小值。
numpy.amax() 用于计算数组中的元素沿指定轴的最大值。
numpy.ptp() 函数计算数组中元素最大值与最小值的差（最大值 – 最小值）

    a = np.array([[3, 7, 5], [8, 4, 3], [2, 4, 9]])
    print("a = ", a)
    # 求列最大
    print("np.amax(a, 0) = ", np.amax(a, 0))
    # 求行最大
    print("np.amax(a, 1) = ", np.amax(a, 1))
    # 求行最小
    print("np.amin(a, 1) = ", np.amin(a, 1))

    # numpy.ptp()函数计算数组中元素最大值与最小值的差（最大值 - 最小值）。
    # 所有元素最大-最小
    print("np.ptp(a) = ", np.ptp(a))
    # 按行/x轴/1轴求 最大-最小
    print("np.ptp(a, 1) = ", np.ptp(a, 1))
    # 按列/y轴/0轴 最大 -最小
    print("np.ptp(a, 0) = ", np.ptp(a, 0))
a =  [[3 7 5]
 [8 4 3]
 [2 4 9]]
np.amax(a, 0) =  [8 7 9]
np.amax(a, 1) =  [7 8 9]
np.amin(a, 1) =  [3 3 2]
np.ptp(a) =  7
np.ptp(a, 1) =  [4 5 7]
np.ptp(a, 0) =  [6 3 6]

2、百分比函数

np.percentile(a, q,axis)百分位数是统计中使用的度量，表示小于这个值的观察值的百分比。
numpy.median() 函数用于计算数组 a 中元素的中位数（中值

    # a: 输入数组
    # q: 要计算的百分位数，在 0 ~ 100 之间
    # axis: 沿着它计算百分位数的轴
    print("np.percentile(a, 70) =", np.percentile(a, 70))
    print("np.percentile(a, 50, 1) =", np.percentile(a, 50, 1))
    print("np.percentile(a, 50, 0) =", np.percentile(a, 50, 0))
    # numpy.median() 函数用于计算数组 a 中元素的中位数（中值）
    print("np.median(a) = ", np.median(a))
    print("np.median(a, 1) = ", np.median(a, 1))
    print("np.median(a, 0) = ", np.median(a, 0))
a =  [[3 7 5]
 [8 4 3]
 [2 4 9]]
np.percentile(a, 70) = 6.199999999999999
np.percentile(a, 50, 1) = [5. 4. 4.]
np.percentile(a, 50, 0) = [3. 4. 5.]
np.median(a) =  4.0
np.median(a, 1) =  [5. 4. 4.]
np.median(a, 0) =  [3. 4. 5.]

3、均值、方差

numpy.mean() 函数返回数组中元素的算术平均值。 如果提供了轴，则沿其计算。
numpy.average() 函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。

    # 算术平均值是沿轴的元素的总和除以元素的数量。
    print("np.mean(a) = ", np.mean(a))
    print("np.mean(a, 1) =", np.mean(a, 1))
    print("np.mean(a, 0) = ", np.mean(a, 0))

    # numpy.average() 该函数可以接受一个轴参数。 如果没有指定轴，则数组会被展开。
    # 如果没有轴参数，权重元素个数必须与数组展开后元素的个数相同，否则会报错
    # 数组[1,2,3,4]和相应的权重[4,3,2,1]，通过将相应元素的乘积相加，并将和除以权重的和，来计算加权平均值。
    # 加权平均值 = (1*4+2*3+3*2+4*1)/(4+3+2+1)
    # 不指定权重时相当于 mean 函数
    # 如果 returned 参数设为 true，则返回权重的和
    print(np.average(a))
    print(np.average(a, weights=np.array([4, 3, 2]), axis=1, returned=True))
    # 标准差是一组数据平均值分散程度的一种度量。
    # 标准差是方差的算术平方根。标准差公式如下：
    # std = sqrt(mean((x - x.mean())**2))
    # 如果数组是 [1，2，3，4]，则其平均值为 2.5。 因此，差的平方是 [2.25,0.25,0.25,2.25]，并且再求其平均值的平方根除以 4，即 sqrt(5/4) ，结果为 1.1180339887498949。
    print(np.std([1, 2, 3, 4]))
    # 统计中的方差（样本方差）是每个样本值与全体样本值的平均数之差的平方值的平均数，即 mean((x - x.mean())** 2)。
    # 换句话说，标准差是方差的平方根。
    print(np.var([1, 2, 3, 4]))
a =  [[3 7 5]
 [8 4 3]
 [2 4 9]]
np.mean(a) =  5.0
np.mean(a, 1) = [5. 5. 5.]
np.mean(a, 0) =  [4.33333333 5.         5.66666667]
5.0
(array([4.77777778, 5.55555556, 4.22222222]), array([9., 9., 9.]))
1.118033988749895
1.25