numpy学习笔记（5），其他实用函数

8. 更多函数

8.1 随机数

8.1.1 常用随机数

8.1.1.1 numpy.random.rand(d0, d1, …, dn)

• 返回[0.0, 1.0)随机浮点数，即大于等于0.0，小于1.0。
• d0, d1, …, dn：返回的数组形状

# 使用numpy.random.rand函数
import numpy as np
np.random.rand(3)

array([0.8385857 , 0.8107416 , 0.99370002])

np.random.rand(3, 2)

array([[0.48333664, 0.78368701],
       [0.80706205, 0.3135694 ],
       [0.5942944 , 0.36877126]])

8.1.1.2 numpy.random.randint(low, high=None, size=None, dtype=‘1’)

• 返回[low, high)随机整数，如果high省略则返回[0, low)随机整数
• size：返回数组的形状
• dtype：数组元素类型，l：long

# 使用numpy.random.randint函数
np.random.randint(10, high=20, size=(3, 4))

array([[12, 18, 14, 10],
       [19, 14, 11, 11],
       [13, 14, 14, 10]])

8.1.2 正态分布随机数

8.1.2.1 标准正态分布：numpy.random.randn(d0, d1, …, dn)。

• 返回标准正态分布对技术，参数与rand函数相同

np.random.randn(3, 2)

array([[-0.80338048, -0.29042362],
       [-0.76188074, -0.01707931],
       [ 0.26754266, -0.99031277]])

8.1.2.2 正态分布：numpy.random.normal(loc = 0.0, scale = 1.0, size=None)。

• 返回正态分布随机数
• loc：平均值
• scale：标准差

np.random.normal(1024, 30, size=(3, 4))

array([[ 978.98804509, 1024.68441494, 1078.41620308, 1005.00643101],
       [1008.94025792, 1005.52545803, 1009.09307745, 1027.56131116],
       [1023.88789661,  988.79911263, 1012.40717316, 1074.79730252]])

8.2 排序函数

8.2.1 轴排序

sort函数，按照轴对数组进行排序，语法格式如下：

numpy.sort(a, axis=-1, kind='quicksort', order=None)

• a：要排序的数组
• axis：排序的轴索引，默认是-1，表示最后一个轴
• kind：排序类型，可选则quicksort，mergesort，heapsort，默认是quicksort
• order：排序的字段，自定义对象里可用到

a = np.random.randint(0, 10, size=(3, 4))
# 只在1轴上排序
np.sort(a, axis=1)

array([[0, 5, 8, 8],
       [3, 4, 5, 9],
       [2, 2, 4, 6]])

# 只在0轴上排序
np.sort(a, axis=0)

array([[2, 0, 5, 3],
       [5, 2, 6, 4],
       [8, 4, 9, 8]])

8.2.2 轴排序索引

argsort函数，按照轴对数组进行排序索引，语法格式如下：
numpy.argsort(a, axis=-1, kind=‘quicksort’, order=None)

b = np.random.randint(0, 10, size=(3, 4))
b

array([[9, 9, 8, 6],
       [2, 3, 4, 6],
       [1, 4, 2, 0]])

# 排序返回结果是原数组的索引组合
np.argsort(b, axis=1)

array([[3, 2, 0, 1],
       [0, 1, 2, 3],
       [3, 0, 2, 1]], dtype=int64)

8.3 聚合函数

可以对整个数组元素，或对轴元素进行计算，获取单一值。
如：sum，amin，amax，mean（平均值），average（加权平均值），var（方差），std（标准偏差）等。

聚合函数都会倒置结果数组降低维度

8.3.1 求和

可以使用numpy.sum函数，或numpy.ndarray.sum方法

8.3.1.1 numpy.sum函数，语法如下

numpy.sum(a, axis=None)

• a：要求和的数组
• axis：指定轴索引，如果axis没有指定，则求所有元素之和，如果指定，则求该轴上的所有元素之和。

a = np.random.randint(0, 10, size=(3, 4))
print(a)
np.sum(a, 1)

[[3 3 2 6]
 [5 1 0 4]
 [2 6 8 7]]





array([14, 10, 23])

8.3.1.2 numpy.ndarray.sum方法，语法格式如下：

numpy.ndarray.sum(axis=None)

a.sum(1)

array([14, 10, 23])

b = np.arange(0, 27)
b_3 = b.reshape(3, 3, 3)
print(b_3)
# 沿轴计算后的结果，会降低一个维度
print("结果会降低一个维度：", np.sum(b_3, 2))

[[[ 0  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]]]
结果会降低一个维度： [[ 3 12 21]
 [30 39 48]
 [57 66 75]]

8.3.2 最大值

求最大值可以使用numpy.amax函数，numpy.nanmax函数，或数组的ndarray.max方法

8.3.2.1 numpy.amax函数语法如下：

numpy.amax(a, axis=None)

a = np.random.randint(0, 10, size=(3, 4))
print(a)
np.amax(a, axis=1)

[[9 1 1 3]
 [5 1 8 2]
 [9 4 9 9]]





array([9, 8, 9])

8.3.2.2 numpy.nanmax函数，忽略NaN（Not a Number，非数），语法如下：

numpy.nanmax(a, axis=None)

b = np.array([[np.nan, 1, 2, 3], [4, 5, 6, np.nan]])
np.nanmax(b, axis=1)

array([3., 6.])

8.3.2.3 ndarray.max方法，类似于语法numpy.amax函数，语法如下：

numpy.ndarray.max(axis=None)

8.3.3 最小值

与8.3.2 最大值用法类似

8.3.4 mean，平均值函数

numpy.mean函数，numpy.nanmean函数，或者ndarray.mean方法都可以求平均值。

8.3.4.1 numpy.mean函数语法如下：

numpy.mean(a, axis=None)

import numpy as np
a = np.arange(0, 9)
b = a.reshape(3, 3)
print("b: ", b)
np.mean(b, axis=1)

b:  [[0 1 2]
 [3 4 5]
 [6 7 8]]





array([1., 4., 7.])

# 不指定轴，计算所有元素的平均值，结果是个标量
np.mean(b)

4.0

8.3.5 加权平均值

numpy.average函数，语法如下：

numpy.average(a, axis=None, weights=None)

• a：数组
• axis：指定轴
• weight：权重，一维数组

a = np.arange(0, 10)
b = a.reshape(2, 5)
print("b: ", b)
c = np.average(b, axis=0, weights=[0.3, 0.7])
print("c", c)

b:  [[0 1 2 3 4]
 [5 6 7 8 9]]
c [3.5 4.5 5.5 6.5 7.5]

8.4 unique函数

去除数组中的重复元素，并按照从小到大的顺序排列，语法格式如下：

numpy.unique(a, return_index=False, axis=None)

• a：原始数组
• return_index：设置为True，返回原始数组中的索引数组
• axis：指定轴。如果没有指定，多维数组会降低到一维平铺。

H = [x for x in 'Hello']
W = [y for y in 'world']
print("H: ", H, "\nW: ", W)

H:  ['H', 'e', 'l', 'l', 'o'] 
W:  ['w', 'o', 'r', 'l', 'd']

# 创建二维数组
a = np.array([H, W])
a

array([['H', 'e', 'l', 'l', 'o'],
       ['w', 'o', 'r', 'l', 'd']], dtype='<U1')

# 不指定轴，降低到一维，整体去重
u = np.unique(a)
u

array(['H', 'd', 'e', 'l', 'o', 'r', 'w'], dtype='<U1')

# 返回值的第一个是值，第二个是索引
u, idx = np.unique(a, return_index=True)

# 返回的值数组
u

array(['H', 'd', 'e', 'l', 'o', 'r', 'w'], dtype='<U1')

# 返回的索引数组
idx

array([0, 9, 1, 2, 4, 7, 5], dtype=int64)

# 指定轴
a = np.array([[1, 0, 0], [1, 0, 0], [2, 1, 4]])
print(a)

[[1 0 0]
 [1 0 0]
 [2 1 4]]

# 指定0轴，再0轴上去重
u = np.unique(a, axis=0)
u

array([[1, 0, 0],
       [2, 1, 4]])

# 指定1轴，再1轴上去重，看起来没有效果
u = np.unique(a, axis=1)
u
# 因为1轴上每一个数组去重后，元素数量产生变化

array([[0, 0, 1],
       [0, 0, 1],
       [1, 4, 2]])

# 重新修改初始数组，在一轴上去重
b = np.array([[1, 0, 0], [1, 0, 0], [1, 1, 1]])
print(b)

[[1 0 0]
 [1 0 0]
 [1 1 1]]

u = np.unique(b, axis=1)
u

array([[0, 1],
       [0, 1],
       [1, 1]])

8.5 where函数

where相当于三元运算符，语法格式如下：

numpy.where(condition[, x, y])

• condition：条件，如果为True返回x，为False返回y
• x和y可以是标量，或数组。

a = np.arange(5)
a

array([0, 1, 2, 3, 4])

b = np.where(a < 3, a, a + 100)
b

array([  0,   1,   2, 103, 104])