保留初心，砥砺前行
先定义两个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.]]
把每个元素nij变成以e为底，nij为指数的形式——enij
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）](http://www.jianshu.com/p/5472800d7c36)
>[相关链接：NumPy（2）reshape，dot，flat](http://www.jianshu.com/p/949b1f8750a9)
>[相关链接：NumPy（3）full，eye，empty，random](http://www.jianshu.com/p/973bceed75c5)