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 - B
print np.subtract(A, B)

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

Addition

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

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

Division

print A / B
print 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 * B
print 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 == B
print A < B
print 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_like
Array to be sorted.
**axis **: int or None, optional
Axis 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’}, optional
Sorting algorithm. Default is ‘quicksort’.
**order** : str or list of str, optional
`Returns:   `
**sorted_array** : ndarray
Array 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    
False
True          

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