numpy基础

1 常用函数

1.1 正态分布

产生num个，均值为0.05，标准差为0.0001的正态分布随机数。

ran = np.random.normal(0.05, 0.0001, num)

1.2 np.apply_along_axis()函数

1.3 np.percentile()函数

计算沿指定轴的数据的第q个百分点。返回数组元素的第q个百分点。

a1 = np.array([[10, 7, 4], [3, 2, 1]]) 
res1 = np.percentile(a1, 60, axis=1)

res1:
指定轴为横轴，取第60个百分点——4+(10-4)0.6=7.6，1+(3-1)0.6=2.2

output:
    [7.6 2.2]

1.4 np.empty()函数

返回给定形状和类型的新数组，而无需初始化条目。

print(np.empty([10, 1], dtype=float))
print(np.empty(10, dtype=float))

output1:输出二维数组，10行1列
    [[1.37505327e-311]
     [6.95218360e-310]
     [1.37710552e-311]
     [1.37710552e-311]
     [1.37710860e-311]
     [1.37710552e-311]
     [1.37710552e-311]
     [1.37710836e-311]
     [0.00000000e+000]
     [0.00000000e+000]]
output2:输出一维数组
    [1.37505327e-311 6.95218360e-310 1.37710552e-311 1.37710552e-311
    1.37710860e-311 1.37710552e-311 1.37710552e-311 1.37710836e-311
     0.00000000e+000 0.00000000e+000]

1.5 multiply()函数

两个矩阵的相同位置的元素相乘，结果矩阵的shape等于输入矩阵的最大行列。当两个输入矩阵的行、列只有一个不相同时，输出矩阵的行列可以广播到最大的行列值（1.2,1.3）；当行、列都不同时，运行错误（1.4）。

1) 两个输入矩阵的shape相同时：

alp = np.mat(np.ones((5,2)))
lab = np.mat(([[-1,-3],[1,0],[2,1],[-1,0],[-3,-1]]))
print("矩阵alp：\n%s \n 矩阵lab:\n%s" %(alp,lab))
np.multiply(alp,lab)

Output：
        # 矩阵alp：
        [[ 1.  1.]
         [ 1.  1.]
         [ 1.  1.]
         [ 1.  1.]
         [ 1.  1.]] 
        # 矩阵lab:
            [[-1 -3]
             [ 1  0]
             [ 2  1]
             [-1  0]
             [-3 -1]]
        matrix([[-1., -3.],
                [ 1.,  0.],
                [ 2.,  1.],
                [-1.,  0.],
                [-3., -1.]])

2) 两个输入矩阵的shape不相同时：

alp = np.mat(np.ones((5,2)))
lab = np.mat(([[-1],[1],[2],[-1],[-3]]))
print("矩阵alp：\n%s \n 矩阵lab:\n%s" %(alp,lab))
np.multiply(alp,lab)

Output:
        # 矩阵alp：
        [[ 1.  1.]
         [ 1.  1.]
         [ 1.  1.]
         [ 1.  1.]
         [ 1.  1.]] 
         # 矩阵lab:
            [[-1]
             [ 1]
             [ 2]
             [-1]
             [-3]]
        matrix([[-1., -1.],
                [ 1.,  1.],
                [ 2.,  2.],
                [-1., -1.],
                [-3., -3.]])

3) 两个输入矩阵的shape不相同时：

alp = np.mat(np.ones((5,2)))
lab = np.mat(([[-1,0]]))
print("矩阵alp：\n%s \n 矩阵lab:\n%s" %(alp,lab))
np.multiply(alp,lab)

Output:
        # 矩阵alp：
        [[ 1.  1.]
         [ 1.  1.]
         [ 1.  1.]
         [ 1.  1.]
         [ 1.  1.]] 
        # 矩阵lab:
            [[-1  0]]
        matrix([[-1.,  0.],
                [-1.,  0.],
                [-1.,  0.],
                [-1.,  0.],
                [-1.,  0.]])

4) 两个输入矩阵的shape不相同时：

alp = np.mat(np.ones((5,2)))
lab = np.mat(([[-1],[1],[2],[-1]]))
print("矩阵alp：\n%s \n 矩阵lab:\n%s" %(alp,lab))
np.multiply(alp,lab)

Output:
        # 矩阵alp：
                [[ 1.  1.]
                 [ 1.  1.]
                 [ 1.  1.]
                 [ 1.  1.]
         [ 1.  1.]] 
        # 矩阵lab:
            [[-1]
             [ 1]
             [ 2]
             [-1]]
    ValueError: operands could not be broadcast together with shapes (5,2) (4,1)

1.6 np.random.shuffle()

将输入矩阵或列表顺序 随机 打乱。

1) 输入是列表

import numpy as np
if __name__ == "__main__":
    L = [1, 2, 3, 4 , 5, 6, 7, 8, 9]
    for i in range(5):
        #  打乱5次，结果随机
        np.random.shuffle(L)
        print(L)

Output：
    [7, 6, 9, 3, 2, 8, 1, 4, 5]
    [8, 9, 6, 2, 7, 1, 4, 3, 5]
    [3, 7, 2, 1, 5, 4, 6, 9, 8]
    [3, 6, 8, 7, 1, 2, 4, 5, 9]
    [5, 9, 1, 2, 3, 6, 8, 4, 7]

2) 输入是矩阵

import numpy as np
if __name__ == "__main__":
    R = [
        [5, 3, 0, 1],
        [4, 0, 0, 1],
        [1, 1, 0, 5],
        [1, 0, 0, 4],
        [0, 1, 5, 4],
    ]
    for i in range(5):
        np.random.shuffle(R)
        print(R)

Output：
    [[0, 1, 5, 4], [5, 3, 0, 1], [1, 0, 0, 4], [4, 0, 0, 1], [1, 1, 0, 5]]
    [[5, 3, 0, 1], [1, 1, 0, 5], [1, 0, 0, 4], [4, 0, 0, 1], [0, 1, 5, 4]]
    [[1, 1, 0, 5], [0, 1, 5, 4], [4, 0, 0, 1], [5, 3, 0, 1], [1, 0, 0, 4]]
    [[0, 1, 5, 4], [1, 1, 0, 5], [4, 0, 0, 1], [5, 3, 0, 1], [1, 0, 0, 4]]
    [[0, 1, 5, 4], [5, 3, 0, 1], [1, 0, 0, 4], [4, 0, 0, 1], [1, 1, 0, 5]]
## 当函数的输入是矩阵时，只打乱一个维度上的的顺序，如：

import numpy as np
if __name__ == "__main__":
    M = [[[1, 2], [3, 4]], [[1, 3], [2, 4]], [[5, 6], [7, 8]]]
    for i in range(5):
        np.random.shuffle(M)
        print(M)

Output：
    [[[5, 6], [7, 8]], [[1, 2], [3, 4]], [[1, 3], [2, 4]]]
    [[[5, 6], [7, 8]], [[1, 3], [2, 4]], [[1, 2], [3, 4]]]
    [[[5, 6], [7, 8]], [[1, 2], [3, 4]], [[1, 3], [2, 4]]]
    [[[1, 2], [3, 4]], [[1, 3], [2, 4]], [[5, 6], [7, 8]]]
    [[[1, 3], [2, 4]], [[5, 6], [7, 8]], [[1, 2], [3, 4]]]

1.7 np.maximum：(X, Y, out=None) 函数

X 与 Y 逐位比较取其大者;当其中一个参数为常数值、另一个为numpy数组时，返回结果为数组，且shape与参数中的数组一致。当两个参数都输数组时，需要两个数组的shape一致，否则报错。

a=[[1,2], [3,4]]
b=[[0.1,5], [6,0.2]]
c=[[-3], [9], [7]]
max_1 = np.maximum(0.5, b)
max_2 = np.maximum(a, b)
print("max_a: ")
print(max_1)
print(max_2)

output:
max_1: 
[[0.5 5. ]
 [6.  0.5]]
max_2: 
[[1. 5.]
 [6. 4.]]

max_3 = np.maximum(a, c)
print(max_3)

ValueError: operands could not be broadcast together with shapes (2,2) (3,1)

1.8 linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None,axis=0)

产生一个起于start值，止于stop值的列表，共num+1个元素。
endpoint : bool, optional. 表示stop值是否在结果列表中。
retstep : bool, optional. 表示返回结果时是否同时返回步长，为Trye时: (samples, step)

import numpy as np
terms_long1 = np.linspace(0, 10, num=11, endpoint=False, retstep=False)
terms_long2 = np.linspace(0, 10, num=11, endpoint=True, retstep=False)
terms_long3 = np.linspace(0, 10, num=11, endpoint=True, retstep=True)
print(terms_long1)
print(terms_long2)
print(terms_long3)

output:

结尾数值10不在返回结果中且不返回步长：
[0.         0.90909091 1.81818182 2.72727273 3.63636364 4.54545455 5.45454545 6.36363636 7.27272727 8.18181818 9.09090909]
结尾数值10在返回结果中且不返回步长：
[ 0.  1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]
结尾数值10在返回结果中且返回步长：
(array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.]), 1.0)

1.9 np.irr()

用于计算内部收益率，表示净现值为0时的定期复合收益率，可以理解为在投资期限内，每一期的平均收益率。

假如，我期初投资100块钱，然后之后的4年每一年分别取出20, 26, 35, 45元，第四年后我的本金和利息已全部取出(此时净值为0)，那么我每一期的平均收益率为8.6552%。按照这个收益率，如果我4年中间不取钱，本金只增不降，直到第4年结束后一次性取出，那么总收益应该是139.38元；但是由于，我实际上由于我中间每年都取出一部分钱，导致本金在减少，所以总收益比139.38元少，只有126元。
内部收益率求法：

import numpy as np
Initial_amount = 100
irr = np.irr([-100, 20, 26, 35, 45])
print('内部收益率：', '%.4f%%' % (irr * 100))

output:

内部收益率： 8.6552%

1.10 np.expand_dims(a, axis)

对数组a做维度上的扩展，在axis指定的维度增加一维。等价于np.reshape()的功能。
比如原本数组a是一维，a=[1, 2, 3]，a shape=(3,)

a = [1, 2, 3]
a1 = np.expand_dims(a, axis=1)
print(f"a1 shape={a1.shape}, \n a1=\n{a1}")

output：

a1 shape=(3, 1), 
 a1=
[[1]
 [2]
 [3]]

等同于：

a = [1, 2, 3]
a1 = np.reshape(a, (3, 1))
print(f"a1 shape={a1.shape}, \n a1=\n{a1}")

令axis=0，等价于a1 = np.reshape(a, (1, 3))

1.11

1.12