一、* ， dot() multiply()
1, 对于array来说，（* 和 dot()运算不同， * 和 multiply()运算相同）
*和multiply() 是每个元素对应相乘
dot() 是矩阵乘法
2, 对于matrix来说，（* 和 multiply()运算不同，* 和 dot()运算相同）
* 和dot() 是矩阵乘法
multiply() 是每个元素对应相乘
3, 混合的时候（与矩阵同）
multiply 为对应乘
dot为矩阵乘法（矩阵在前数组在后时，均为一维时数组可适应，即能做矩阵乘法）
*为 矩阵乘法（但无上述适应性）
总结：dot为矩阵乘法；multiply是对应乘；* 看元素，元素为矩阵（包括含矩阵）时为矩阵乘法，元素为数组时为对应乘法
Python 3.6.4 (default, Jan 7 2018, 03:52:16)
[GCC 4.2.1 Compatible Android Clang 5.0.300080 ] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import numpy as np
>>> a1=np.array([1,2,3])
>>> a1*a1
array([1, 4, 9])
>>> np.dot(a1,a1)
14
>>> np.multiply(a1,a1)
array([1, 4, 9])
>>> m1 = np.mat(a1)
>>> m1
matrix([[1, 2, 3]])
>>> m1*m1
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/data/data/com.termux/files/usr/lib/python3.6/site-packages/numpy-1.13.3-py3.6-linux-aarch64.egg/numpy/matrixlib/defmatrix.py", line 309, in __mul__
return N.dot(self, asmatrix(other))
ValueError: shapes (1,3) and (1,3) not aligned: 3 (dim 1) != 1 (dim 0)
>>> np.dot(m1,m1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: shapes (1,3) and (1,3) not aligned: 3 (dim 1) != 1 (dim 0)
>>> np.multiply(m1,m1)
matrix([[1, 4, 9]])
>>> np.multiply(a1,m1)
matrix([[1, 4, 9]])
>>> np.multiply(m1,a1)
matrix([[1, 4, 9]])
>>> np.dot(a1,m1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: shapes (3,) and (1,3) not aligned: 3 (dim 0) != 1 (dim 0)
>>> np.dot(m1,a1)
matrix([[14]])
>>> a1*m1
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/data/data/com.termux/files/usr/lib/python3.6/site-packages/numpy-1.13.3-py3.6-linux-aarch64.egg/numpy/matrixlib/defmatrix.py", line 315, in __rmul__
return N.dot(other, self)
ValueError: shapes (3,) and (1,3) not aligned: 3 (dim 0) != 1 (dim 0)
>>> m1*a1
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/data/data/com.termux/files/usr/lib/python3.6/site-packages/numpy-1.13.3-py3.6-linux-aarch64.egg/numpy/matrixlib/defmatrix.py", line 309, in __mul__
return N.dot(self, asmatrix(other))
ValueError: shapes (1,3) and (1,3) not aligned: 3 (dim 1) != 1 (dim 0)
>>> a1,m1
(array([1, 2, 3]), matrix([[1, 2, 3]]))
>>>
-------------------------------------------------------------------
当array是二维时，我们可以把它看做是矩阵（但是乘法的法则还是按照array来算）
In [45]: a_x
Out[45]:
array([[1, 2, 3],
[2, 4, 0],
[1, 2, 1]])
In [46]: a_y
Out[46]: array([[-1, 1, -1]])
先看dot
# 这时用dot做矩阵乘法要注意：满足左边的列数等于右边的行数
In [47]: np.dot(a_x,a_y)
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-47-3b884e90b0ef> in <module>()
----> 1 np.dot(a_x,a_y)
ValueError: shapes (3,3) and (1,3) not aligned: 3 (dim 1) != 1 (dim 0)
In [48]: np.dot(a_y,a_x)
Out[48]: array([[ 0, 0, -4]])
# 当左边的变为一维的数组时，结果还是一个二维的数组（矩阵形式）
In [49]: a_y_ = a_y.flatten()
In [50]: a_y_
Out[50]: array([-1, 1, -1])
然后还有一点很重要 np.dot(a_y_,a_y_) 可以将两个一维的数组（这时没有行列向量之说，从转置后还为本身也可以看出）直接做内积
In [109]: np.dot(a_y_,a_y_)
Out[109]: 3
In [51]: np.dot(a_y,a_x)
Out[51]: array([[ 0, 0, -4]])
再看multiply（与*的效果一致）：
In [52]: a_y
Out[52]: array([[-1, 1, -1]])
In [53]: a_y_
Out[53]: array([-1, 1, -1])
In [54]: np.multiply(a_y,a_y_)
Out[54]: array([[1, 1, 1]])
In [55]: np.multiply(a_y_,a_y)
Out[55]: array([[1, 1, 1]])
得到结论：都是以高维的那个元素决定结果的维度。（重要）
In [56]: np.multiply(a_y_,a_y_.T) # 在a_y_是一维的行向量，a_y_ = a_y_.T，所以结果一样
Out[56]: array([1, 1, 1])
In [57]: np.multiply(a_y_,a_y.T) # a_y 是二维的行向量，转置一下就变成二维的列向量
Out[57]:
array([[ 1, -1, 1],
[-1, 1, -1],
[ 1, -1, 1]])
In [58]: np.multiply(a_y,a_y.T) # 与上述效果相同
Out[58]:
array([[ 1, -1, 1],
[-1, 1, -1],
[ 1, -1, 1]])
上面两个就是下面这俩对应元素相乘！
In [59]: a_y
Out[59]: array([[-1, 1, -1]])
In [60]: a_y.T
Out[60]:
array([[-1],
[ 1],
[-1]])
与下面这种张量积效果相同
In [61]: np.outer(a_y,a_y)
Out[61]:
array([[ 1, -1, 1],
[-1, 1, -1],
[ 1, -1, 1]])
In [62]: np.outer(a_y,a_y.T) # 这时用不用转置的效果都一样
Out[62]:
array([[ 1, -1, 1],
[-1, 1, -1],
[ 1, -1, 1]])
In [63]: np.outer(a_y_,a_y_) # 两个一维的行向量外积的效果也一样
Out[63]:
array([[ 1, -1, 1],
[-1, 1, -1],
[ 1, -1, 1]])
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
下面看一下 .T 和 .transpose()
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
在小于等于二维的情况下，两者效果是相同的！
In [64]: x
Out[64]:
matrix([[1, 2, 3],
[2, 4, 0],
[1, 2, 1]])
In [65]: a_x
Out[65]:
array([[1, 2, 3],
[2, 4, 0],
[1, 2, 1]])
In [68]: (x.T == x.transpose()).all() # 为矩阵时相同
Out[68]: True
In [70]: (a_x.T == a_x.transpose()).all() # 为数组时相同
Out[70]: True
In [71]: (a_y.T == a_y.transpose()).all() # a_y为一维数组（行向量）相同
Out[71]: True
In [72]: (a_y_.T == a_y_.transpose()).all() # a_y_为二维数组（行向量）也相同
Out[72]: True
下面才是两种区别的重点：
当维数大于等于三时（此时只有数组了），
T 其实就是把顺序全部颠倒过来，
而transpose(), 里面可以指定顺序，输入为一个元组(x0,x1,x2...x(n-1) )为(0,1,2,...,n-1)的一个排列,其中n为数组维数，
效果与np.transpose(arr, axes=(x0,x1,x2...x(n-1)) ) 相同,
def transpose(self, *axes): # real signature unknown; restored from __doc__ """ a.transpose(*axes) Returns a view of the array with axes transposed. For a 1-D array, this has no effect. (To change between column and row vectors, first cast the 1-D array into a matrix object.) For a 2-D array, this is the usual matrix transpose. For an n-D array, if axes are given, their order indicates how the axes are permuted (see Examples). If axes are not provided and ``a.shape = (i[0], i[1], ... i[n-2], i[n-1])``, then ``a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0])``. Parameters ---------- axes : None, tuple of ints, or `n` ints * None or no argument: reverses the order of the axes. * tuple of ints: `i` in the `j`-th place in the tuple means `a`'s `i`-th axis becomes `a.transpose()`'s `j`-th axis. * `n` ints: same as an n-tuple of the same ints (this form is intended simply as a "convenience" alternative to the tuple form) Returns ------- out : ndarray View of `a`, with axes suitably permuted. See Also -------- ndarray.T : Array property returning the array transposed. Examples -------- >>> a = np.array([[1, 2], [3, 4]]) >>> a array([[1, 2], [3, 4]]) >>> a.transpose() array([[1, 3], [2, 4]]) >>> a.transpose((1, 0)) array([[1, 3], [2, 4]]) >>> a.transpose(1, 0) array([[1, 3], [2, 4]]) """ pass
这两者的源代码还是又挺大区别的，虽然意思差不多
def transpose(a, axes=None): """ Permute the dimensions of an array. Parameters ---------- a : array_like Input array. axes : list of ints, optional By default, reverse the dimensions, otherwise permute the axes according to the values given. Returns ------- p : ndarray `a` with its axes permuted. A view is returned whenever possible. See Also -------- moveaxis argsort Notes ----- Use `transpose(a, argsort(axes))` to invert the transposition of tensors when using the `axes` keyword argument. Transposing a 1-D array returns an unchanged view of the original array. Examples -------- >>> x = np.arange(4).reshape((2,2)) >>> x array([[0, 1], [2, 3]]) >>> np.transpose(x) array([[0, 2], [1, 3]]) >>> x = np.ones((1, 2, 3)) >>> np.transpose(x, (1, 0, 2)).shape (2, 1, 3) """ return _wrapfunc(a, 'transpose', axes)
还是看实验吧：
In [73]: arr=np.arange(16).reshape(2,2,4)
In [74]: arr
Out[74]:
array([[[ 0, 1, 2, 3],
[ 4, 5, 6, 7]],
[[ 8, 9, 10, 11],
[12, 13, 14, 15]]])
In [75]: arr.transpose((1,0,2)) # 注意这个参数不带key，不能写axes=(1,0,2)，若写成这个，则报错
Out[75]:
array([[[ 0, 1, 2, 3],
[ 8, 9, 10, 11]],
[[ 4, 5, 6, 7],
[12, 13, 14, 15]]])
In [78]: np.transpose(arr, (1, 0, 2)) #这个参数可带key，刻写成axes=(1,0,2)，若写成这个，则通过
Out[78]:
array([[[ 0, 1, 2, 3],
[ 8, 9, 10, 11]],
[[ 4, 5, 6, 7],
[12, 13, 14, 15]]])
三个维度的编号对应为(0,1,2),比如这样，我们需要拿到7这个数字，怎么办，肯定需要些三个维度的值，7的第一个维度为0，第二个维度为1，第三个3，
即坐标轴(0,1,2)的对应的坐标为(0,1,3)所以arr[0,1,3]则拿到了7
所以相当于把原来坐标轴[0,1,2]的转置到[1,0,2]，即把之前第三个维度转为第一个维度，之前的第二个维度不变，之前的第一个维度变为第三个维度
理解了上面，再来理解swapaxes()就很简单了，swapaxes接受一对轴编号，其实这里我们叫一对维度编号更好吧
arr.swapaxes(2,1) 就是将第三个维度和第二个维度交换
注意这个函数必须接受两个参数，（两个轴），不能写成元组(2,1)的形式再传入。
In [81]: arr.swapaxes(2,1)
Out[81]:
array([[[ 0, 4],
[ 1, 5],
[ 2, 6],
[ 3, 7]],
[[ 8, 12],
[ 9, 13],
[10, 14],
[11, 15]]])
In [82]: arr.swapaxes((2,1))
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-82-24459d1e2980> in <module>()
----> 1 arr.swapaxes((2,1))
TypeError: swapaxes() takes exactly 2 arguments (1 given)
还是那我们的数字7来说，之前的索引是(0,1,3),那么交换之后，就应该是(0,3,1)
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------