Python学习笔记（十二）：Numpy

引言：

import numpy as np

一、ndarray 对象

1. 创建 ndarray 类型的对象

       numpy 最重要的一个特点是其 n 维数组对象 ndarray，它是一系列同类型数据的集合，以 0 下标为开始进行集合中元素的索引。ndarray 对象是用于存放同类型元素的多维数组，每个元素在内存中都有相同存储大小的区域。

'''
numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
object -- 数组或嵌套的数列
dtype  -- 数组元素的数据类型，可选
copy   -- 对象是否需要复制，可选
order  -- 数组元素存储区域的排列格式，参数为C和F，即C语言格式和Fortran语言格式。
其中C为行方向（即[[1,2],[3,4]]存储为1|2|3|4），F为列方向（即[[1,2],[3,4]]存储为1|3|2|4）
subok  -- 默认返回一个与基类类型一致的数组
ndmin  -- 指定生成数组的最小维度
'''

a = np.array([[1,2],[3,4]])
a                   # array([[1, 2], [3, 4]])

b = np.array([1,2,3,4,5], dtype = float, ndmin =  3)
b                   # array([[[1., 2., 3., 4., 5.]]])

2. 对象属性

'''
ndarray.ndim
秩，即轴的数量或维度的数量

ndarray.shape
数组的维度，对于矩阵，n 行 m 列

ndarray.size
数组元素的总个数，相当于 .shape 中 n*m 的值

ndarray.dtype
ndarray 对象的元素类型

ndarray.itemsize
ndarray 对象中每个元素的大小，以字节为单位

ndarray.real
ndarray元素的实部

ndarray.imag
ndarray 元素的虚部
'''

arr = np.array([1,2,3,4,5], dtype = complex, ndmin =  3)

arr.ndim            # 3
arr.shape           # (1, 1, 5)
arr.size            # 5
arr.dtype           # dtype('complex128')
arr.itemsize        # 16
arr.real            # array([[[1., 2., 3., 4., 5.]]])
arr.imag            # array([[[0., 0., 0., 0., 0.]]])

二、创建数组

1. 创建常见数组

'''
numpy.empty(shape, dtype = float, order = 'C')
创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组

numpy.zeros(shape, dtype = float, order = 'C')
创建一个指定形状（shape）、数据类型（dtype）的数组，数组元素以 0 来填充

numpy.ones(shape, dtype = None, order = 'C')
创建一个指定形状（shape）、数据类型（dtype）的数组，数组元素以 1 来填充
'''

a = np.empty([3,2], dtype = int) 
a
# array([[7290888465049002081, 3184989590875566189],
#       [8104636977815248178, 2987133850644979813],
#       [         4311747104,          4317679664]])

b = np.zeros([3,2], dtype = int) 
b
# array([[0, 0],
#       [0, 0],
#       [0, 0]])

c = np.ones([3,2], dtype = int) 
c
# array([[1, 1],
#       [1, 1],
#       [1, 1]])

2. 从已有的数据创建数组

'''
numpy.asarray(a, dtype = None, order = None)
类似 numpy.array，但是 numpy.asarray 只有三个参数，比 numpy.array 少两个

numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)
buffer -- 可以是任意对象，会以流的形式读入
dtype  -- 返回数组的数据类型，可选
count  -- 读取的数据数量，默认为-1，读取所有数据
offset -- 读取的起始位置，默认为0
用于实现动态数组

numpy.fromiter(iterable, dtype, count=-1)
iterable -- 可迭代对象
dtype    -- 返回数组的数据类型
count    -- 读取的数据数量，默认为-1，读取所有数据
从可迭代对象中建立 ndarray 对象，返回一维数组
'''

a = np.asarray([(1,2,3),(4,5)])
a                   # array([(1, 2, 3), (4, 5)], dtype=object)

b = np.frombuffer(b'numpy', dtype =  'S1')
b                   # array([b'n', b'u', b'm', b'p', b'y'], dtype='|S1')

list = range(5)
it = iter(list)
c = np.fromiter(it, dtype = float)
c                   # array([0., 1., 2., 3., 4.])

3. 根据一定的步进创建数值数组

'''
numpy.arange(start=0, stop, step=1, dtype)
创建数值范围从 start 开始 stop（不包含） 结束的，步长为 step，类型为 dtype 的 ndarray 对象

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
创建一个等差数列，范围从 start 开始，stop（如果 endpoint 为 True，该值包含于数列中）结束，样本数量为 num，如果 retstep 为 True，生成的数组中会显示间距，反之不显示

np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
创建一个等比数列，范围从 base ** start 开始，base ** stop（如果 endpoint 为 True，该值包含于数列中）结束，样本数量为 num
'''
 
a = np.arange(1, 5, 2, float)
a                   # array([1., 3.])

b = np.linspace(0, 10, 3, True, True, int)
b                   # (array([ 0,  5, 10]), 5.0)

c = np.logspace(0, 9, 10, True, 2, int)
c                   # array([  1,   2,   4,   8,  16,  32,  64, 128, 256, 512])

三、切片和索引

1. 基础

'''
slice(start, stop, step)
从索引 start 开始到索引 stop 停止，间隔为 step 的数组，也可以通过冒号分隔切片参数 start:stop:step 来进行切片操作
'''

arr = np.array([[1,2],[3,4],[5,6],[7,8],[9,10]])
arr[slice(0, 4, 2)] # array([[1, 2], [5, 6]])
arr[0:4:2]          # array([[1, 2], [5, 6]])

2. 冒号

'''
冒号 : 的解释（参数 start 默认为 0，stop 默认为 len(arr)，step 默认为 1）
如果只有一个参数，将返回与该索引相对应的单个元素，如 arr[2]
如果只有一个或两个冒号 :，则空的位置对应默认值，如 arr[:]、arr[::] 等价于 arr[0, len(arr), 1]
如果有一个参数加一个冒号 :，则空的位置对应默认值，如 arr[2:] 等价于 arr[2, len(arr), 1]、arr[:2] 等价于 arr[0, 2, 1]
如果有两个参数加一个冒号 :，则提取两个索引(不包括停止索引)之间的项，即 step 默认为 1，如 arr[2:5] 等价于 arr[2, 5, 1]
'''

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

3. 逗号

'''
多维数组索引
可以使用逗号 , 分隔，代表不同维度数组
'''

arr = np.array([[1,2],[3,4],[5,6],[7,8],[9,10]])
arr[2]              # array([5, 6])
arr[2,1]            # 6
arr[2:]             # array([[5, 6], [7, 8], [9, 10]])
arr[2:,1]           # array([6, 8, 10])

4. 省略号

'''
切片可以包括省略号 …，且只能有一个省略号，来使选择元组的长度与数组的维度相同
假设数组 arr 是三维的，则
arr[...]     等价于 arr[:, :, :]
arr[...,1]   等价于 arr[:, :, 1]
arr[...,1,:] 等价于 arr[:,1,:]
arr[1,...]   等价于 arr[1,:,:]
arr[:,1,...] 等价于 arr[:,1,:]
'''

arr = np.array([[[1,2],[3,4]],[[5,6],[7,8]],[[9,10],[11,12]]])
arr[...]            # array([[[1, 2], [3, 4]], [[ 5, 6], [7, 8]], [[9, 10], [11, 12]]])
arr[...,1]          # array([[2, 4], [6, 8], [10, 12]])
arr[...,1,:]        # array([[3, 4], [7, 8], [11, 12]])
arr[1,...]          # array([[5, 6], [7, 8]])
arr[:,1,...]        # array([[3, 4], [7, 8], [11, 12]])

5. 布尔索引

'''
布尔索引
'''

arr = np.array([[[1,2],[3,4]],[[5,6],[7,8]],[[9,8],[7,6]]])
arr[arr > 5]        # array([6, 7, 8, 9, 8, 7, 6])

四、广播（Broadcast）

       广播是 numpy 对不同形状(shape)的数组进行数值计算的方式，对数组的算术运算通常在相应的元素上进行。
       如果两个数组 a 和 b 形状相同，即满足 a.shape == b.shape，那么 a 与 b 进行算术运算的结果就是 a 与 b 数组对应位的算术运算。当运算中的2个数组形状不同，numpy 将自动触发广播机制。
       从尾部向头部对比两个数组的维度（即 arr.shape），当对应位置相等或者其中一个为1时，可将为1的维度进行拷贝，使得最终形状相同，并进行相应运算；若不满意相等或其中一个为1的条件，则引发异常。具体如下：

A      (4d array):  8 x 1 x 6 x 1
B      (3d array):      7 x 1 x 5
Result (4d array):  8 x 7 x 6 x 5

'''
a、b 形状相同，对应位进行算术运算
'''
a = np.array([1.0,2.0,3.0])
b = np.array([2.0,2.0,2.0])
a + b               # array([3., 4., 5.])
a - b               # array([-1., 0., 1.])
a * b               # array([2., 4., 6.])
a/b                 # array([0.5, 1., 1.5])


'''
a、b 形状不同，根据广播机制进行算术运算
'''
a = np.array([1, 2, 4], dtype = int)
b = np.array([[1, 2, 4], [2, 4, 8]], dtype = int)
a + b               # array([[2, 4, 8], [3, 6, 12]])
a - b               # array([[0, 0, 0], [-1, -2, -4]])
a * b               # array([[1, 4, 16], [2, 8, 32]])
b/a                 # array([[1., 1., 1.], [2., 2., 2.]])

五、数组操作

1. 修改数组形状

'''
numpy.reshape(arr, newshape, order='C')
不改变数据的条件下，按照 order 顺序修改 arr 的形状为 newshape

ndarray.flat
返回数组元素迭代器

ndarray.flatten(order='C')
按照 order 顺序返回一份数组拷贝，对拷贝所做的修改不会影响原始数组

numpy.ravel(arr, order='C')
按照 order 顺序返回一份数组试图，对试图修改会影响原始数组
'''

np.arange(8)        # array([0, 1, 2, 3, 4, 5, 6, 7])

arr = np.reshape(np.arange(8), (4,2))
arr                 # array([[0, 1], [2, 3], [4, 5], [6, 7]])

for i in arr.flat:
	print(i)        # 输出：0 1 2 3 4 5 6 7

arr.flatten('F')    # array([0, 2, 4, 6, 1, 3, 5, 7])
arr.ravel('F')      # array([0, 2, 4, 6, 1, 3, 5, 7])

arr.flatten()       # array([0, 1, 2, 3, 4, 5, 6, 7])
arr.flatten()[1] = 10
arr.flatten()       # array([0, 1, 2, 3, 4, 5, 6, 7])
arr                 # array([[0, 1], [2, 3], [4, 5], [6, 7]])

arr.ravel()         # array([0, 1, 2, 3, 4, 5, 6, 7])
arr.ravel()[1] = 10
arr.ravel()         # array([0, 10, 2, 3, 4, 5, 6, 7])
arr                 # array([[0, 10], [2, 3], [4, 5], [6, 7]])

2. 翻转数组

'''
numpy.transpose(arr, axes)
按照 axes 对换数组 arr 的维度

ndarray.T
类似 numpy.transpose(arr, (..., 3, 2, 1, 0))，即将维度从高到低对调

numpy.rollaxis(arr, axis, start)
滚动特定的轴 axis（axis 为要向后滚动的轴，其它轴的相对位置不会改变） 到位置 start（start 默认为 0）之前

numpy.swapaxes(arr, axis1, axis2)
交换数组 arr 的两个轴 axis1 和 axis2
'''

arr = np.array([
	[
	    [0, 1, 2],
	    [3, 4, 5]
	], [
	    [6, 7, 8],
	    [9, 10, 11]
	]
])

# arr[0][0][0] = 0
# arr[0][0][1] = 1
# arr[0][0][2] = 2
# arr[0][1][0] = 3
# arr[0][1][1] = 4
# arr[0][1][2] = 5
# arr[1][0][0] = 6
# arr[1][0][1] = 7
# arr[1][0][2] = 8
# arr[1][1][0] = 9
# arr[1][1][1] = 10
# arr[1][1][2] = 11
# 将以上第一个方括号[]看作是0轴，第二个为1轴，第三个为2轴

np.transpose(arr, (1, 2, 0))
# 以上代码将012轴的数据改为120，即：
# arr原[0][0][0] = arr[0][0][0] = 0
# arr原[0][0][1] = arr[0][1][0] = 1
# arr原[0][0][2] = arr[0][2][0] = 2
# arr原[0][1][0] = arr[1][0][0] = 3
# arr原[0][1][1] = arr[1][1][0] = 4
# arr原[0][1][2] = arr[1][2][0] = 5
# arr原[1][0][0] = arr[0][0][1] = 6
# arr原[1][0][1] = arr[0][1][1] = 7
# arr原[1][0][2] = arr[0][2][1] = 8
# arr原[1][1][0] = arr[1][0][1] = 9
# arr原[1][1][1] = arr[1][1][1] = 10
# arr原[1][1][2] = arr[1][2][1] = 11

# 输出为：
# array([[[ 0,  6],
#         [ 1,  7],
#         [ 2,  8]],
#        [[ 3,  9],
#         [ 4, 10],
#         [ 5, 11]]])

np.transpose(arr, (2, 1, 0))
arr.T
np.swapaxes(arr, 0, 2)    # 交换轴0和轴2位置，即等价于 np.transpose(arr, (2, 1, 0)) 或 np.transpose(arr)
# 以上三式等价，输出为：
# array([[[ 0,  6],
#         [ 3,  9]],
#        [[ 1,  7],
#         [ 4, 10]],
#        [[ 2,  8],
#         [ 5, 11]]])

np.rollaxis(arr, 0, 3)    # 将轴0滚动到轴3之前，即等价于 np.transpose(arr, (1, 2, 0))
# 输出为：
# array([[[ 0,  6],
#         [ 1,  7],
#         [ 2,  8]],
#        [[ 3,  9],
#         [ 4, 10],
#         [ 5, 11]]])

3. 修改数组维度

'''
以下修改不影响原始数组：

numpy.broadcast(arr1, arr2)
对 arr1 和 arr2 进行广播，用于模仿广播的对象，它返回一个对象，该对象封装了将一个数组广播到另一个数组的结果

numpy.broadcast_to(arr, shape, subok=False)
将数组 arr 广播到新形状 shape，如果新形状不符合 NumPy 的广播规则，该函数会抛出异常

numpy.expand_dims(arr, axis)
向数组 arr 插入指定轴 axis，例如原本 shape 为 (2,3)，axis=0，则 shape 变为 (1,2,3)

numpy.squeeze(arr, axis)
从数组 arr 中删除指定轴 axis，该轴对应的 shape 值应该为 1
'''

arr1 = np.array([[1], [2]])
arr2 = np.array([3, 4])  
a = np.broadcast(arr1, arr2)
[u + v for (u,v) in a]           # 手动计算 arr1 + arr2，输出：[4, 5, 5, 6]

np.broadcast_to(arr1, (2, 2))    # array([[1, 1], [2, 2]])
np.broadcast_to(arr2, (2, 2))    # array([[3, 4], [3, 4]])

np.expand_dims(arr2, 0)          # array([[3, 4]])
np.expand_dims(arr2, 1)          # array([[3], [4]])

arr = np.reshape(np.arange(6), (2,3))
np.expand_dims(arr, 0).shape     # (1, 2, 3)
np.expand_dims(arr, 1).shape     # (2, 1, 3)
np.expand_dims(arr, 2).shape     # (2, 3, 1)

np.squeeze(arr1, 1)              # array([1, 2])

arr = np.reshape(np.arange(6), (1,2,3))
np.squeeze(arr, 0).shape         # (2, 3)
np.squeeze(arr, 1)               # 异常：ValueError: cannot select an axis to squeeze out which has size not equal to one

4. 连接数组

'''
numpy.concatenate((arr1, arr2, ...), axis=0)
沿轴 axis 连接相同形状的两个或多个数组 arr1,arr2,...

numpy.stack(arrs, axis=0)
沿轴 axis 连接相同形状的数组序列 arrs

numpy.hstack(arrs)
是 numpy.stack 函数的变体，它通过水平堆叠来生成数组，等价于 numpy.concatenate(arrs, axis = 1)

numpy.vstack(arrs)
是 numpy.stack 函数的变体，它通过垂直堆叠来生成数组，等价于 numpy.concatenate(arrs, axis = 0)
'''

arr1 = np.array([[1], [2], [3]])
arr2 = np.array([[4], [5], [6]])

# 两个 shape 为 (3,1) 的数组沿 0 轴 concatenate，shape 变为 (6,1)
# 两个 shape 为 (3,1) 的数组沿 1 轴 concatenate，shape 变为 (3,2)
np.concatenate((arr1, arr2), 0)    # array([[1], [2], [3], [4], [5], [6]])
np.concatenate((arr1, arr2), 1)    # array([[1, 4], [2, 5], [3, 6]])

# 两个 shape 为 (3,1) 的数组沿 0 轴 stack 变为 (2,3,1)
# 两个 shape 为 (3,1) 的数组沿 1 轴 stack 变为 (3,2,1)
np.stack((arr1, arr2), 0)          # array([[[1], [2], [3]], [[4], [5], [6]]])
np.stack((arr1, arr2), 1)          # array([[[1], [4]], [[2], [5]], [[3], [6]]])

np.hstack((arr1, arr2))            # array([[1, 4], [2, 5], [3, 6]])

np.vstack((arr1, arr2))            # array([[1], [2], [3], [4], [5], [6]])

5. 分割数组

'''
numpy.split(arr, indices_or_sections, axis=0)
沿轴 axis 将数组 arr 按 indices_or_sections 方式分割，其中 indices_or_sections 如果是一个整数，就用该数平均切分，如果是一个数组，则为沿轴切分的位置（左开右闭） 

numpy.hsplit(arr, indices_or_sections)
等价于 numpy.split(arr, indices_or_sections, axis = 1)

numpy.vsplit(arr, indices_or_sections)
等价于 numpy.split(arr, indices_or_sections, axis = 0)
'''

arr = np.reshape(np.arange(12), (3, 4))
arr  # array([[ 0,  1,  2,  3], [ 4,  5,  6,  7], [ 8,  9, 10, 11]])

np.split(arr, 3, 0)                # [array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]
np.vsplit(arr, 3)                  # [array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]
np.split(arr, [1, 2], 1)           # [array([[0], [4], [8]]), array([[1], [5], [9]]), array([[ 2,  3], [ 6,  7], [10, 11]])]
np.hsplit(arr, [1, 2])             # [array([[0], [4], [8]]), array([[1], [5], [9]]), array([[ 2,  3], [ 6,  7], [10, 11]])]

6. 数组元素的添加与删除

'''
numpy.resize(arr, shape)
返回指定形状 shape 的新数组

numpy.append(arr, values, axis=None)
沿轴 axis 向输入数组 arr 的末尾添加值 values（需要与 arr 形状相同）

numpy.insert(arr, obj, values, axis)
沿轴 axis 向输入数组 arr 的指定索引 obj 添加值 values（需要与 arr 形状相同），如果未提供轴 axis 参数，则输入数组将展开

numpy.delete(arr, obj, axis)
返回从输入数组 arr 中删除指定子数组的新数组，如果未提供轴 axis 参数，则输入数组将展开

numpy.unique(arr, return_index, return_inverse, return_counts)
去除输入数组 arr 中的重复元素
return_index   -- 若为true，返回新列表元素在旧列表中的位置（下标），并以列表形式储
return_inverse -- 若为true，返回旧列表元素在新列表中的位置（下标），并以列表形式储
return_counts  -- 若为true，返回去重数组中的元素在原数组中的出现次数
'''

arr = np.array([[1, 2], [2, 4]])

np.resize(arr, (4, 1))              # array([[1], [2], [2], [4]])

np.append(arr, [[5, 6]], 0)         # array([[1, 2], [2, 4], [5, 6]])
np.append(arr, [[5, 6], [7, 8]], 1) # array([[1, 2, 5, 6], [2, 4, 7, 8]])

np.insert(arr, 1, 5)                # array([1, 5, 2, 2, 4])
np.insert(arr, 1, [[5, 6]], 0)      # array([[1, 2], [5, 6], [2, 4]])

np.delete(arr, 0)                   # array([2, 2, 4])
np.delete(arr, 0, 0)                # array([[2, 4]])

np.unique(arr)                      # array([1, 2, 4])

六、字符串函数

'''
numpy.char.add(str1, str2)
返回 str1 和 str2 字符串连接

numpy.char.multiply(str, num)
返回 str 多重连接后的字符串

numpy.char.center(str, width, fillchar)
将 str 居中，并使用指定字符 fillchar 在左侧和右侧进行填充至长度为 width

numpy.char.capitalize(str)
将 str 的第一个字母转换为大写

numpy.char.title(str)
将 str 的每个单词的第一个字母转换为大写

numpy.char.lower(str)
将 str 的每个元素转换为小写

numpy.char.upper(str)
将 str 的每个元素转换为大写

numpy.char.split(str, seq=' ')
通过指定分隔符 seq 对 str 进行分割，并返回数组

numpy.char.splitlines(str)
以换行符作为分隔符来分割 str，并返回数组。

numpy.char.strip(str, s)
用于移除 str 开头或结尾处的特定字符 s

numpy.char.join(seq, str)
通过指定分隔符 seq 来连接 str 中的元素或字符串

numpy.char.replace(str, a, b)
使用新字符串 b 替换字符串中的所有子字符串 a
'''

np.char.add(['hello'],[' python'])                 # array(['hello python'], dtype='
np.char.multiply('hi ',3)                          # array('hi hi hi ', dtype='
np.char.center('hello python', 20, fillchar = '*') # array('****hello python****', dtype='
np.char.capitalize('hello python')                 # array('Hello python', dtype='
np.char.title('hello python')                      # array('Hello Python', dtype='
np.char.lower(['HELLO','PYTHON'])                  # array(['hello', 'python'], dtype='
np.char.upper(['hello','python'])                  # array(['HELLO', 'PYTHON'], dtype='
np.char.split ('hello python')                     # array(list(['hello', 'python']), dtype=object)
np.char.splitlines('hello\npython')                # array(list(['hello', 'python']), dtype=object)
np.char.strip(['arunooba','admin','java'],'a')     # array(['runoob', 'dmin', 'jav'], dtype='
np.char.join(':','python')                         # array('p:y:t:h:o:n', dtype='
np.char.replace ('dog', 'do', 'eg')                # array('egg', dtype='

七、数学函数

1. 算术函数

'''
numpy.around(arr, decimals=0)
返回指定数字的四舍五入值，decimals 为舍入的小数位数，若为负，整数将四舍五入到小数点左侧的位置

numpy.floor(arr)
返回数字的下舍整数

numpy.ceil(arr)
返回数字的上入整数
'''

arr = np.array([1.0, 5.55, 123, 0.567, 25.532])
np.around(arr, decimals =  1)     # array([  1. ,   5.6, 123. ,   0.6,  25.5])
np.around(arr, decimals =  -1)    # array([  0.,  10., 120.,   0.,  30.])
np.floor(arr)                     # array([  1.,   5., 123.,   0.,  25.])
np.ceil(arr)                      # array([  1.,   6., 123.,   1.,  26.])

2. 算术运算

'''
numpy.add(a, b)
  a + b
numpy.add.accumulate(arr, axis)
  累加，arr=[a, b, c]，则累加结果为[a, a+b, a+b+c]
numpy.add.reduce(arr, axis)
  连加，arr=[a, b, c]，则连加结果为 a+b+c
numpy.add.outer(arr1, arr2)
  将第一个列表中的每个元素依次加到第二个列表中的每个元素，arr1=[a,b]，arr2=[c,d,e]，则结果为[[c+a, d+a, e+a], [c+b, d+b, e+b]]
numpy.add.reduceat(arr, indices)
  计算多组reduce()的结果，通过 indices 参数指定一系列 reduce 的起始和终了位置
  

numpy.subtract(a, b)
  a - b

numpy.multiply(a, b)
  a * b
numpy.multiply.accumulate(arr, axis)
  累乘，arr=[a, b, c]，则累乘结果为[a, a*b, a*b*c]
numpy.multiply.reduce(arr, axis)
  连乘，arr=[a, b, c]，则连乘结果为 a*b*c
numpy.multiply.outer(arr1, arr2)
  将第一个列表中的每个元素依次乘到第二个列表中的每个元素，arr1=[a,b]，arr2=[c,d,e]，则结果为[[c*a, d*a, e*a], [c*b, d*b, e*b]]
numpy.multiply.reduceat(arr, indices)
  计算多组reduce()的结果，通过 indices 参数指定一系列 reduce 的起始和终了位置


numpy.divide(a, b)
  a / b

numpy.reciprocal(arr)
返回参数逐元素的倒数，对于绝对值大于 1 的整数元素，结果始终为 0， 对于整数 0，则发出溢出警告

numpy.power(arr1, arr2)
将 arr1 的元素作为底数，计算它与 arr2 中相应元素的幂

numpy.mod(arr1, arr2)
计算输入数组中相应元素的相除后的余数
'''

arr = np.array([1, 2, 3, 4])
arr1 = np.array([4, 2, 2, 1])
np.add.reduceat(arr, indices=[0,1,0,2,0,3,0])      # array([ 1,  2,  3,  3,  6,  4, 10])
np.multiply.reduceat(arr, indices=[0,1,0,2,0,3,0]) # array([ 1,  2,  2,  3,  6,  4, 24])
np.reciprocal(arr)                                 # array([1, 0, 0, 0])
np.reciprocal(np.floor(arr))                       # array([1., 0.5, 0.33333333, 0.25])
np.power(arr, arr1)                                # array([1, 4, 9, 4])
np.mod(arr, arr1)                                  # array([1, 0, 1, 0])

3. 统计函数

'''
numpy.amin(arr, axis)
计算数组 arr 中的元素沿指定轴 axis 的最小值

numpy.amax(arr, axis)
计算数组 arr 中的元素沿指定轴 axis 的最大值

numpy.ptp(arr, axis)
计算数组 arr 中元素沿指定轴 axis 最大值与最小值的差（最大值 - 最小值）

numpy.percentile(arr, q, axis)
计算 arr 沿指定轴 axis 的 q 分数位的值，如 q = 50，则计算中位数

numpy.median(arr, axis)
计算 arr 沿指定轴 axis 的中位数

numpy.mean(arr, axis)
计算 arr 沿指定轴 axis 元素的算术平均数

numpy.average(arr, weights, returned=False)
计算数组 arr 与 权重 weights 的加权平均数，returned 为 True 则返回权重之和

numpy.std(arr)
计算标准差

numpy.var(arr)
计算方差
'''

arr = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
wts = np.array([[5, 4, 3, 2, 1],[1,1,1,1,1]])

np.amin(arr, 0)                               # array([1, 2, 3, 4, 5])
np.amin(arr, 1)                               # array([1, 6])
np.amax(arr, 0)                               # array([  6,  7,  8,  9, 10])
np.amax(arr, 1)                               # array([ 5, 10])

np.ptp(arr, 1)                                # array([4, 4])
np.percentile(arr, 0.25, 0)                   # array([1.0125, 2.0125, 3.0125, 4.0125, 5.0125])
np.median(arr, 1)                             # array([3., 8.])

np.mean(arr)                                  # 5.5
np.mean(arr, 0)                               # array([3.5, 4.5, 5.5, 6.5, 7.5])
np.mean(arr, 1)                               # array([3., 8.])

np.average(arr, weights = wts)                # 3.75
np.average(arr, weights = wts, returned=True) # (3.75, 20.0)

np.std(arr)                                   # 2.8722813232690143
np.var(arr)                                   # 8.25

八、排序函数

'''
numpy.sort(arr, axis=1, kind='quicksort', order=None)
arr   -- 要排序的数组
axis  -- 沿着它排序数组的轴，如果没有数组会被展开，沿着最后的轴排序，axis=0 按列排序，axis=1 按行排序
kind  -- 排序算法，可选择有'quicksort'（快速排序）、'mergesort'（归并排序）、'heapsort'（堆排序）
order -- 一个字符串或列表，可以设置按照某个属性进行排序
返回输入数组 arr 的排序副本

numpy.argsort(arr, axis=1, kind='quicksort', order=None)
返回输入数组 arr 从小到大的索引值

numpy.lexsort(arr, axis=-1, kind='quicksort', order=None)
用于对多个序列进行排序。把它想象成对电子表格进行排序，每一列代表一个序列，排序时优先照顾靠后的列

numpy.argmax(arr, axis)
返回 arr 沿给定轴 axis 的最大元素的索引

numpy.argmin(arr, axis)
返回 arr 沿给定轴 axis 的最小元素的索引

numpy.nonzero(arr)
返回输入数组 arr 中非零元素的索引

numpy.where(condition, x, y)
没有 x 和 y，返回输入数组中满足给定条件的元素的索引；有 x 和 y，则满足条件(condition)，输出 x，不满足输出 y

numpy.extract(condition, arr)
根据某个条件从数组 arr 中抽取元素，返回满足条件的元素
'''

dtype = [('Name', 'S10'), ('Age', int), ('Grade', int)]
values = [('A', 8, 95), ('B', 7, 98),('C', 8, 92)]
arr = np.array(values, dtype = dtype)
np.sort(arr, order='Grade') # array([(b'C', 8, 92), (b'A', 8, 95), (b'B', 7, 98)], dtype=[('Name', 'S10'), ('Age', '

arr = np.array([[2,4,3],[5,9,1]])

np.sort(arr, 0)             # array([[2, 4, 1], [5, 9, 3]])
np.sort(arr, 1)             # array([[2, 3, 4], [1, 5, 9]])
np.sort(arr, None)          # array([1, 2, 3, 4, 5, 9])

np.argsort(arr, 1)          # array([[0, 2, 1], [2, 0, 1]])
np.argsort(arr, None)       # array([5, 0, 2, 1, 3, 4])

a = [2,1,4,4,4,9,3]
b = [9,3,5,0,0,0,6]
# 先排a：(1, 0, 6, 2, 3, 4, 5)
# 再排b：(3, 4, 5, 1, 2, 6, 0)
np.lexsort((b,a))           # array([1, 0, 6, 3, 4, 2, 5])

np.argmax(arr, 0)           # array([1, 1, 0])
np.argmin(arr, 1)           # array([0, 2])

np.nonzero(b)               # (array([0, 1, 2, 6]),)

np.where(arr > 3)           # (array([0, 1, 1]), array([1, 0, 1]))
np.where(arr > 3, 1, 0)     # array([[0, 1, 0], [1, 1, 0]])

np.extract(arr > 3, arr)    # array([4, 5, 9])

以上全部内容参考书籍如下：
Magnus Lie Hetland《Python基础教程（第2版）》