NumPy（4）数组数学与基础操作与复制、排序

保留初心，砥砺前行

NumPy官方网站

NumPy Tutorial

先定义两个NumPy array

A = np.array([[1, 2, 3],              [2, 3, 4]]).astype(np.float32)B = np.array([[2, 3, 4],              [3, 4, 5]]).astype(np.float32)

• 算数运算：

  Subtraction

print A - Bprint np.subtract(A, B)

[[-1. -1. -1.] [-1. -1. -1.]][[-1. -1. -1.] [-1. -1. -1.]]

Addition

print A + Bprint np.add(A, B)

[[ 3.  5.  7.] [ 5.  7.  9.]][[ 3.  5.  7.] [ 5.  7.  9.]]

Division

print A / Bprint np.divide(A, B)

[[ 0.5         0.66666669  0.75      ] [ 0.66666669  0.75        0.80000001]][[ 0.5         0.66666669  0.75      ] [ 0.66666669  0.75        0.80000001]]

Multiplication，只是对应的元素相乘，并不是真正的矩阵乘法

print A * Bprint np.multiply(A, B)

[[  2.   6.  12.] [  6.  12.  20.]][[  2.   6.  12.] [  6.  12.  20.]]

dot product 点积，这是真正的矩阵乘法，与上边的操作相对应

print np.dot(A, np.transpose(B))print np.transpose(B)

[[ 20.  26.] [ 29.  38.]][[ 2.  3.] [ 3.  4.] [ 4.  5.]]

把每个元素n_ij变成以e为底，n_ij为指数的形式——e^n_ij

print np.exp(A)

[[  2.71828175   7.38905621  20.08553696] [  7.38905621  20.08553696  54.59814835]]

把每个元素开方

print np.sqrt(A)

[[ 1.          1.41421354  1.73205078] [ 1.41421354  1.73205078  2.        ]]

比较：

两个矩阵之间的对应元素大小的比较

print A == Bprint A < Bprint A < 3

[[False False False] [False False False]][[ True  True  True] [ True  True  True]][[ True  True False] [ True False False]]

两个矩阵在矩阵层面的比较

print np.array_equal(A, B)

False

- 聚合函数：

这里包含求所有元素（或按照行或列划分的）和，所有元素（或按照行或列划分的）中的最大最小值，元素累加，平均数，中位数，相关系数，标准差等。

关于相关系数：相关表和相关图可反映两个变量之间的相互关系及其相关方向，但无法确切地表明两个变量之间相关的程度。于是，著名统计学家卡尔·皮尔逊设计了统计指标——相关系数(Correlation coefficient)。相关系数是用以反映变量之间相关关系密切程度的统计指标。

print np.min(A)              #A中的最小值               print np.sum(A), np.sum(A, axis=1)             #A所有元素求和，横轴元素求和 print np.max(A, axis=1)           #每一个横轴的最大值             print np.cumsum(A), np.cumsum(A, axis=1)        #按元素累加，每一个横轴按元素累加print np.mean(A)                  #求所有元素的平均值             print np.median(A)                #中位数             print np.corrcoef(A)                  #相关系数         print np.std(A)                                #标准差

其中，np.cumsum累加可能不是很清晰，看下边的例子：

print np.cumsum(A), np.cumsum(A, axis=1) [  1.   3.   6.   8.  11.  15.] [[ 1.  3.  6.]                                   [ 2.  5.  9.]]

可以看出np.cumsum(A)的每一个元素是A中这个位置的元素（包括自身）累加到第一个元素的值。

- 排序：np.sort()Return a sorted copy of an array.>`Parameters:   `***a*** : array_likeArray to be sorted.**axis **: int or None, optionalAxis along which to sort. If None, the array is flattened before sorting. The default is -1, which sorts along the last axis.**kind** : {‘quicksort’, ‘mergesort’, ‘heapsort’}, optionalSorting algorithm. Default is ‘quicksort’.**order** : str or list of str, optional`Returns:   `**sorted_array** : ndarrayArray of the same type and shape as *a*.

C = np.array([1,3,5,2,34,5,6,3,5,8])                                          print np.sort(C)                    

 [1  2  3  3  5  5  5  6  8 34]

复制：

copy

首先需要注意的是，B = A并不意味着copy了一个与A相同的array并赋值给B，而是B也指向了A指向的那个array，如果此时对A进行操作，则B也会产生同样的变化，因为它们本来就是同一个array。

C = np.array([1, 2, 3, 4, 6])     D = C.copy()              

这是deep copy ，可以看做是真正的copy，如上代码所示，将C中的内容复制到D中，C与D虽然内容完全一样，但是是两个array。

view

Different array objects can share the same data. The view method creates a new array object that looks at the same data.

事实上，没有任何数据类型是固定的，主要取决于如何看待这片数据的内存区域。

在numpy.ndarray.view中，提供对内存区域不同的切割方式，来完成数据类型的转换，而无须要对数据进行额外的copy，来节约内存空间。
我自己的理解是，view生成的array和被view的array的data实际上指向的是同一块内存，也就是相同的一块数据。不同点在于view可以表示成不同的shape或type。这样比copy节省内存。
接下来看示例就可以明白个大概。

C = np.array([1, 2, 3, 4, 6])  D = C.view()                   print D is C                   print D.base is C    FalseTrue          

C = np.array([1, 2, 3, 4, 6]) D = C.view(np.float32)        print C                       print D                       

[1 2 3 4 6][  1.40129846e-45   0.00000000e+00   2.80259693e-45   0.00000000e+00   4.20389539e-45   0.00000000e+00   5.60519386e-45   0.00000000e+00   8.40779079e-45   0.00000000e+00]

他们其实共享的是同一个内存中的同一个数据，只是表示出来的type不同而已。

C = np.array([1, 2, 3, 4, 6])  D = C.view()                   C[0] = 3                       print C                        print D                        

[3 2 3 4 6][3 2 3 4 6]

当array C中的某个元素变化，可以看到array D中的相应元素也发生了变化。

好了，以上就是今天的全部内容了，欢迎讨论指正。

相关链接：NumPy（1）简介，基础属性，数组创建（ones，zeros，empty，arange，linespace）
相关链接：NumPy（2）reshape，dot，flat
相关链接：NumPy（3）full，eye，empty，random