本文共 11042 字，大约阅读时间需要 36 分钟。

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()可实现对数组的填充，可参考,其中若设定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表示不适用科学记数法的形式输出。详见
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，否则取ya = 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 vectorsNone 	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 below2 	    2-norm (largest sing. value) 	as below-2 	    smallest singular value 	    as belowother 	– 	                            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=<no value>, ddof=<no value>)用于计算相关系数

    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=<no value>, append=<no value>)来计算一维数组或二维数组中相邻两元素的差值

    '''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.  

转载地址：http://zqhzb.baihongyu.com/