(XWZ)的Python学习笔记Ⅷ--------numpy

1. numpy中对数组使用布尔索引时，布尔表达式的连接应该是用&、|、~，而不是（and, or, not)，尽量用括号将各子表达式括起来。

   a = np.arange(11)
   a[(a < 4) & (a > 8)] += -1 #array([  0,  -1,  -2,   3,   4,   5,   6,   7,   8,  -9, -10])
   a[(a < 4) and (a > 8)] #运行出错

    

2. numpy.random.randn()产生的是正态分布X~(0, 1)的随机数，而numpy.random.rand()产生的均匀分布X~(0, 1)的随机数。
3. 一维数组表示向量，可以用vdot()来计算两个向量的内积

   a = np.arange(5)
   b = np.arange(1, 6)
   print(np.vdot(a, b)) #40

    

4. 创建等差数组：numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)

   a = np.linspace(10, 20, 5, dtype=np.float64) #array([10. , 12.5, 15. , 17.5, 20. ]) #默认是包括20的，可以设置endpoint=Flase不包括20

    

5.  创建等比数组(基默认为10)：numpy.logspace(start, stop, num=50, endpoint=True, base=10.0)

   np.logspace(1, 5, 8, base=2)

    

6.  使用numpy.random.randint(low, high=None, size=None, dtype='I')创建随机整数数组。创建值小于10，长度为7的随机一维整数数组：

   np.random.randint(10, size=7)
   

   或者

   np.random.randint(10, size=(7,))

   创建值大于等于5小于10，长度为6的随机一维整数数组:

   np.random.randint(5, 10, size=6)

   创建值大于等于10小于20的5×4的数组：

   np.random.randint(10, 20, size=(5, 4))

    

7. 生成浮点数使用numpy.random.uniform(low=0.0, high=1.0, size=None)，用法和random.randint()一样。

8. 求n阶矩阵的逆：

   np.linalg.inv(a)

   求伪逆矩阵：

   np.linalg.pinv(a)

    

9.  在5×5的矩阵a中,[[2,3,4], [1,2,3]]中索引的元素是a[2][1],a[3][2],a[4][3]，而a[2:, 1:4]索引的元素包括a[2][1],a[2][2],a[2][3],a[3][1],a[3][2],a[3][3],a[4][1],a[4][2],a[4][3]
10. reshape()和resize()都是改变数组的形状，但是reshape()不会改变原数组，而是生成一个新的数组，而resize()是改变原数组的形状。
11. 使用ravel()可以展平数组（就是转为一维数组）,参数order可以决定按行（'F'）还是按列展开。
12. 广播机制：常数a可广播成m×n阶的元素都是a的矩阵，m×1的二维数组A可广播成每一列都是A的m×n的矩阵，1×n的二维数组B可广播成每一行都是B的m×n的矩阵。对一维数组也能够进行广播，将它以1×n的二位数组进行同样的处理。
13. 垂直合并数组：random.vstack((a, b))

    a = np.random.randint(10, size=(4, 3))
    b = np.random.randint(12, size=(2, 3))
    np.vstack((a, b))

     

14.  水平合并数组：random.hstack()，与vstack()用法类似。
15. 水平分割数组：hsplit()

    # a = array([[3, 3, 9],
    #            [2, 1, 2],
    #            [7, 2, 4],
    #            [4, 6, 4]])
    
    np.hsplit(a, 3) #列数要是3的整数倍
    #结果为[array([[3],
    #              [2],
    #              [7],
    #              [4]]),
    # array([[3],
    #        [1],
    #        [2],
    #        [6]]),
    # array([[9],
    #        [2],
    #        [4],
    #        [4]])]

     

16. 垂直分割数组和水平分割数组用法类似。
17. max(a)返回矩阵a中最大值，max(a, axis=0)返回每一列的最大值，max(a, axis=1)返回每一行的最大值，argmax(a, axis=0)返回a的每一列中最大值的索引，argmax(a, axis=1)返回每一行中最大值的索引。min系列的用法类似，求平均值mean()，求中位数median()，求方差var()，求标准差std()也类似。
18. 使用pad()可实现对数组的填充，可参考https://www.cnblogs.com/hezhiyao/p/8177541.html,其中若设定pad_width=c(常数)则设定各个维度的填充长度都为c。
19. 使用diag()来创建对角矩阵：

    np.diag(np.arange(7), k = -2) #创建主对角线下方第二个斜对角线元素为0，1，2，3，4，5，6的对角矩阵，默认k=0，即主对角元素
    
    '''
    array([[0, 0, 0, 0, 0],
           [0, 0, 0, 0, 0],
           [3, 0, 0, 0, 0],
           [0, 4, 0, 0, 0],
           [0, 0, 5, 0, 0]])
    '''

     

20. 使用intersect1d()求两个数组的交集

    np.intersect1d(np.arange(10), np.arange(5, 15))

    union1d()求并集，setdiff1d()求差集

21.  使用floor()计算向下取整，使用ceil()计算向上取整

    a = np.random.uniform(10, size=(4, 3))
    
    print('a为：', a)
    
    print('向下取整为：', np.floor(a))
    
    print('向上取整为：', np.ceil(a))
    
    
    '''
    a为：
    [[1.48043603 1.10139178 8.11631089]
     [5.87661904 3.48909693 9.84390292]
     [9.90676002 8.1304763  5.89695023]
     [8.42013761 5.80825214 6.49500302]]
    
    向下取整为：
    [[1. 1. 8.]
     [5. 3. 9.]
     [9. 8. 5.]
     [8. 5. 6.]]
    向上取整为：
    [[ 2.  2.  9.]
     [ 6.  4. 10.]
     [10.  9.  6.]
     [ 9.  6.  7.]]
    '''
    

22.  使用astype()进行类型转换，将参数copy设置为False就是直接对原数组机型转换，为True就是对拷贝数组进行转换，默认为True。

    a = np.random.uniform(10, size=(4, 3))
    
    print('a为:\n', a)
    
    print('转换为整数后为：')
    
    print(a.astype(int))
    
    '''
    a为:
     [[1.29323846 4.34909029 2.24730222]
     [3.92151758 7.11321729 1.0087961 ]
     [7.20850234 2.87578861 9.07388942]
     [9.00594579 5.03391584 9.91513397]]
    转换为整数后为：
    [[1 4 2]
     [3 7 1]
     [7 2 9]
     [9 5 9]]
    '''

23. 使用sort()对数组进行排序（默认采用的是快排），对参数axis设定可按行或按列进行排序。

24.  使用iinfo().max/iinfo().min获取numpy中某个整数类型的最大/小值，使用finfo().max/finfo().min获取numpy中某个浮点数类型的最大/小值

25. trunc()是去掉一个浮点数的小数部分结果仍为浮点数：

    np.trunc(np.random.uniform(10, size=10) #结果为array([4., 7., 4., 2., 9., 3., 7., 3., 4., 6.])

     

26. argsort()得到的是排好序的数组的在原数组的索引，可设定参数axis指定按行或按列进行排序：

    '''
    a = [[45, 20, 57, 19, 54, 40],
         [52,  1, 43, 50, 19, 90],
         [ 3, 57, 13, 75, 26, 73],
         [96, 25, 93, 11, 15,  0],
         [51, 37,  7,  8, 58,  9],
         [16, 11, 53, 18, 92, 83]]
    '''
    np.argsort(a, axis=0)
    
    '''
    结果为：
    array([[2, 1, 4, 4, 3, 3],
           [5, 5, 2, 3, 1, 4],
           [0, 0, 1, 5, 2, 0],
           [4, 3, 5, 0, 0, 2],
           [1, 4, 0, 1, 4, 5],
           [3, 2, 3, 2, 5, 1]])
    '''

     

     

27.  bincount()用来统计一维数组中元素出现的次数, 只能统计非负整数：

    b = np.random.randint(10, size=10)
    
    print('b为：\n',b)
    
    np.bincount('结果为：\n', b)
    
    '''
    b为：
    [6 8 3 2 0 5 9 9 3 6]
    结果为：
    array([1, 0, 1, 2, 0, 1, 2, 0, 1, 2]) #按从小到大的顺序给出各个元素出现的次数，如0出现一次，1出现0次，2出现1次，3出现2次...
    '''

     

28.  使用nonzero()可以给出非零未知元素的索引：

    b = np.random.randint(5, size=(5, 4))
    b
    
    '''
    运行结果：
    array([[1, 0, 3, 1],
           [1, 4, 2, 4],
           [2, 1, 1, 1],
           [1, 0, 0, 2],
           [4, 0, 0, 1]])
    '''

    np.nonzero(b)
    
    '''
    运行结果：
    (array([0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4]),
     array([0, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 3, 0, 3]))
    '''

     

29.  np.set_printoptions(precision=None, threshold=None, edgeitems=None, linewidth=None, suppress=None, nanstr=None, infstr=None)可以设值控制台数据输出的格式，precision表示显示小数点后的位数，threadhold表示不是用省略号的最少数据个数，suppress=True表示不适用科学记数法的形式输出。详见https://blog.csdn.net/weixin_43584807/article/details/103093874
30. random.rand()和random.random()两个函数功能是一样的，只是参数的传入方式不一样。
31. 使用percentile(a, q, axis=None, out=None, overwrite_input=False, interpolation='linear', keepdims=False)来得到数组中的第a%处的数

        np.percentile(a, q, axis=None, out=None, overwrite_input=False, interpolation='linear', keepdims=False)
         
        a : array，用来算分位数的对象，可以是多维的数组
        q : 介于0-100的float，用来计算是几分位的参数，如四分之一位就是25，如要算两个位置的数就(25,75)
        axis : 坐标轴的方向，一维的就不用考虑了，多维的就用这个调整计算的维度方向，取值范围0/1
        out : 输出数据的存放对象，参数要与预期输出有相同的形状和缓冲区长度
        overwrite_input : bool，默认False，为True时及计算直接在数组内存计算，计算后原数组无法保存
        interpolation : 取值范围{'linear', 'lower', 'higher', 'midpoint', 'nearest'}
                    默认liner，比如取中位数，但是中位数有两个数字6和7，选不同参数来调整输出
        keepdims : bool,默认False,为真时取中位数的那个轴将保留在结果中

     

32.  sum()作用在布尔数组上时，结果是True的个数。
33. where()的用法：

    #用法一：当调用方式为np.where(condition, x, y)时，表示condition满足时取x，否则取y
    a = np.random.randint(20, size=(3, 3))
    '''
    [[ 2 10  4]
     [11 11 19]
     [ 4 13 18]]
    '''
    np.where(a % 2 == 1, 'odd', 'even')
    '''
    array([['even', 'even', 'even'],
           ['odd', 'odd', 'odd'],
           ['even', 'odd', 'even']], dtype='

     

34.  unique(ar, return_index=False, return_inverse=False, return_counts=False,axis=None)的作用是，去除数组ar的重复元素之后，再按从小到大的顺序进行排序：

    a = np.random.randint(10, size=10)
    
    '''
    array([3, 5, 9, 3, 1, 9, 2, 4, 0, 4])
    '''
    
    #return_index=True表示输出新数组中各元素在原数组中的第一处出现时的索引
    np.unique(a, return_index=True)
    
    '''
    (array([0, 1, 2, 3, 4, 5, 9]), array([8, 4, 6, 0, 7, 1, 2]))
    '''
    
    #return_inverse表示输出原数组中各元素在新数组中的索引
    np.unique(a, return_inverse=True=True)
    
    '''
    (array([0, 1, 2, 3, 4, 5, 9]), array([3, 5, 6, 3, 1, 6, 2, 4, 0, 4]))
    '''
    
    #return_count表示输出新数组中各元素在原数组中出现的次数
    np.unique(a, return_counts=True)
    
    '''
    (array([0, 1, 2, 3, 4, 5, 9]), array([1, 1, 1, 2, 2, 1, 2]))
    '''

     

35.  concatenate((a1,a2,...), axis=0)可实现对数组的拼接，执行效率比append()要高。对二维数组进行拼接时，参数设置为axis=0时进行垂直拼接，和vstack()效果一样，设置为axis=1时进行水平拼接，和hstack()效果一样

    a1 = np.arange(5)
    a2 = np.arange(5, 11)
    np.concatenate((a1, a2))
    
    '''
    array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10])
    '''
    
    a3 = np.arange(9).reshape(3, 3)
    
    '''
    array([[0, 1, 2],
           [3, 4, 5],
           [6, 7, 8]])
    '''
    
    a4 = np.arange(9, 18).reshape(3, 3)
    
    '''
    array([[ 9, 10, 11],
           [12, 13, 14],
           [15, 16, 17]])
    '''
    
    np.concatenate((a3, a4), axis = 0) #和np.vstack((a3, a4))效果一样
    
    '''
    array([[ 0,  1,  2],
           [ 3,  4,  5],
           [ 6,  7,  8],
           [ 9, 10, 11],
           [12, 13, 14],
           [15, 16, 17]])
    '''
    
    np.concatenate((a3, a4), axis=1) #和np.hstack((a3, a4))效果一样
    
    '''
    array([[ 0,  1,  2,  9, 10, 11],
           [ 3,  4,  5, 12, 13, 14],
           [ 6,  7,  8, 15, 16, 17]])
    '''

     

36.  amax()和max()是同一个函数，amin和min是同一个函数。
37. apply_along_axis(func, axis, arr, *args, **kwargs)函数的作用是将func作用于arr的每一个元素生成新的数组

    a = np.random.randint(20, size=(3, 3))
    '''
    array([[ 5, 12, 11],
           [13, 18,  0],
           [13, 19, 14]])
    '''
    np.apply_along_axis(np.sum, 1, a) #计算a中每一行的和
    '''
    array([28, 31, 46])
    '''

     

38.  

    a = np.array([1 + 2j, 3 + 4j, 5 + 6j])
    
    print("实部：", a.real) #打印a的实部
    print("虚部：", a.imag) #打印a的虚部

     

39.  '='是引用的赋值，如a=b,则a和b指向的都是同一个数据，而copy()是生成一个副本再赋值，如b=a.copy()，a和b指向的不是同一个数据。
40. allclose(a, b, rtol=1e-05, atol=1e-08, equal_nan=False)作用是比较两个数组每一个元素是否都相等，误差默认为1e-5。
41. 使用linalg.norm(x, ord=None, axis=None)来计算向量(一维数组)或矩阵（二维数组）的范数，当计算一维数组的范数时，axis参数无效。当以二维数组为对象计算范数时，若不设定axis的值是计算矩阵的范数，当设定axis=1或0时，则计算矩阵中每一行或列的向量范数。

    For values of ord <= 0, the result is, strictly speaking, not a mathematical ‘norm’, but it may still be useful for various numerical purposes.
    
    The following norms can be calculated:
    ord 	norm for matrices 	            norm for vectors
    None 	Frobenius norm 	                2-norm
    ‘fro’ 	Frobenius norm 	                –
    inf 	max(sum(abs(x), axis=1)) 	    max(abs(x))
    -inf 	min(sum(abs(x), axis=1)) 	    min(abs(x))
    0 	    – 	                            sum(x != 0)
    1 	    max(sum(abs(x), axis=0)) 	    as below
    -1 	    min(sum(abs(x), axis=0)) 	    as below
    2 	    2-norm (largest sing. value) 	as below
    -2 	    smallest singular value 	    as below
    other 	– 	                            sum(abs(x)**ord)**(1./ord)

    a = np.random.randint(-10, 10, 5)
    '''
    array([ 1, -1,  1, -1,  3])
    '''
    np.linalg.norm(a, ord=1) #计算向量a的1-范数
    '''
    7.0
    '''
    np.linalg.norm(a, ord=np.inf) #计算向量a的无穷范数
    '''
    3.0
    '''
    np.linalg.norm(a) #默认计算2-范数
    '''
    3.605551275463989
    '''
    
    x = np.random.randint(-10, 10, size=(3, 3))
    '''
    array([[ -2,   9,   7],
           [  1,  -3,   8],
           [  7, -10,   5]])
    '''
    np.linalg.norm(x) #默认计算F-范数
    '''
    19.544820285692065
    '''
    np.linalg.norm(x, ord=2) #计算矩阵x的2范数
    '''
    15.516628929433754
    '''
    np.linalg.norm(x, ord=1, axis=1, keepdims=True) #计算X中每一行向量的1-范数
    '''
    array([[18.],
           [12.],
           [22.]])
    '''

     

42. corrcoef(x, y=None, rowvar=True, bias=, ddof=)用于计算相关系数

    x： array_like，包含多个变量和观测值的1-D或2-D数组，x的每一行代表一个变量，每一列都是对所有这些变量的单一观察
    y： array_like, 可选，另外一组变量和观察，y具有与x相同的列。对x的进一步补充，相当于直接垂直并到x的下方
    rowvar： bool, 可选，如果rowvar为True（默认值），则每行代表一个变量，并在列中显示。否则，转换关系：每列代表一个变量，而行包含观察。
    bias： _NoValue，可选，没有效果，请勿使用
    ddof： _NoValue，可选，没有效果，请勿使用

     

43. 使用linalg.eig(x)计算方阵x的特征值和特征向量

44. 使用diff(a, n=1, axis=-1, prepend=, append=)来计算一维数组或二维数组中相邻两元素的差值

    '''
    a = array([ 1, -1,  1, -1,  3])
    '''
    np.diff(a) #计算一次一维数组a中相邻两元素的差值
    '''
    array([-2,  2, -2,  4])
    '''
    np.diff(a, 2) #计算两次a中两元素的差值，第二次计算是在第一次的结果上进行的计算
    '''
    array([ 4, -4,  6])
    '''
    '''
    x = array([[ -2,   9,   7],
               [  1,  -3,   8],
               [  7, -10,   5]])
    '''
    np.diff(x, n=2, axis=1) #计算两次x中每一行相邻两元素的差值
    '''
    array([[-13],
           [ 15],
           [ 32]])
    '''

     

45. cumsum(a, axis=None, dtype=None, out=None)用于计算累加和

    Z = np.random.randint(1, 10, 10)
    print(Z)
    
    '''
    [第一个元素, 第一个元素 + 第二个元素, 第一个元素 + 第二个元素 + 第三个元素, ...]
    '''
    np.cumsum(Z)
    
    '''
    [4 4 6 1 7 4 8 6 7 4]
    
    array([ 4,  8, 14, 15, 22, 26, 34, 40, 47, 51])
    '''
    
    

     

46. 使用np.c_[a, b]对a和b两个数组按列进行连接，np.r_[a, b]对a和b按行进行连接

    a = np.arange(3)
    b = np.arange(3, 6)
    np.c_[a, b] #将a和b两个一维数组按列进行连接
    '''
    array([[0, 3],
           [1, 4],
           [2, 5]])
    '''
    np.r_[a, b] #将a和b两个一维数组按行进行连接
    '''
    array([0, 1, 2, 3, 4, 5])
    '''
    
    
    x = np.arange(6).reshape(3, 2, order='C')
    '''
    array([[0, 1],
           [2, 3],
           [4, 5]])
    '''
    y = np.arange(6, 12).reshape(3, 2)
    '''
    array([[ 6,  7],
           [ 8,  9],
           [10, 11]])
    '''
    np.c_[x, y] #将x和y两个矩阵按列进行连接
    '''
    array([[ 0,  1,  6,  7],
           [ 2,  3,  8,  9],
           [ 4,  5, 10, 11]])
    '''
    np.r_[x, y] #将x和y两个矩阵按行进行连接
    '''
    array([[ 0,  1],
           [ 2,  3],
           [ 4,  5],
           [ 6,  7],
           [ 8,  9],
           [10, 11]])
    '''

     

47. 以函数的形式创建数组

    np.fromfunction(lambda x: x ** 2, (5,)) #创建一维数组，x维数组中元素的下标
    '''
    array([ 0.,  1.,  4.,  9., 16.])
    '''
    
    np.fromfunction(lambda x, y: x + y, (3, 3)) #创建二维数组，x,y维数组中元素的下标
    '''
    array([[0., 1., 2.],
           [1., 2., 3.],
           [2., 3., 4.]])
    '''

     

48.