“广播机制：通过扩展实现数组运算”的版本间的差异

来自CloudWiki
跳转至： 导航， 搜索
110（讨论 | 贡献）
（→‎numpy数组的广播机制）
 
（未显示同一用户的20个中间版本）
第1行： 第1行：
−
 
+
== numpy数组的广播机制 ==
−
== Numpy数组的广播机制 ==
 
 
*注意numpy里数组之间的运算和线性代数中的矩阵运算是不一样的
 
*注意numpy里数组之间的运算和线性代数中的矩阵运算是不一样的
 
*同纬度和形状的数组之间就是同位置的元素两两匹配运算的结果
 
*同纬度和形状的数组之间就是同位置的元素两两匹配运算的结果
−
-------------------------------
 
−
import numpy as np
 
−
<br>x = np.array([[1,2,1],[4,5,6]])
 
−
<br>y = np.array([[1,2,1],[3,4,5]])
 
−
<br>print(x+y)
 
−
<br>[[ 2  4  2]
 
−
<br>[ 7  9 11]]
 
−
print(x-y)
 
−
# [[0 0 0]
 
−
#  [1 1 1]]
 
−
print(x*y)
 
−
# [[ 1  4  1]
 
−
#  [12 20 30]]
 
−
--------------------------------
 
−
注意：如果是列和行其中之一有空缺是可以通过复制来运算的。
 
−
但是蓝本不能有缺或者多，即行和列都不完整。
 
  
−
== 矩阵数组的创建 ==
+
----
 +
<br>import numpy as np
 +
<br>a=np.array([[ 1.,  2.,  1.], [ 1.,  2.,  1.]])
 +
<br>b=np.array([[ 1.,  2.,  3.], [ 1.,  2.,  3.]])
 +
<br>print(a.shape,b.shape)
 +
<br>>>>(2, 3) (2, 3)
 +
<br>print(a+b)
 +
<br>>>>array([[ 2.,  4.,  4.],[ 2.,  4.,  4.]])
 +
<br>print(a*b)
 +
<br>>>>array([[ 1.,  4.,  3.],[ 1.,  4.,  3.]])
 +
<br>print(a-b)
 +
<br>>>>array([[ 0.,  0., -2.],[ 0.,  0., -2.]])
 +
<br>print(a**b)
 +
<br>>>>array([[ 1.,  4.,  1.],[ 1.,  4.,  1.]])
  
−
--------------------------------
+
----
−
import numpy as np
 
  
−
a = np.arange(3,10)#默认从3开始到10（不包括10），步长为1
+
*当两个数组其中一个的维度少于另外一个的时候
−
print(a)
+
少的数组在某一个轴（或是多个轴）的方向缺失数据，缺数据的那个方向只能有1个元素（或是一行，一面）作为复制蓝本，然后依照轴的方向复制，复制数由多的那个数组的大小决定
−
#>>>[3 4 5 6 7 8 9]
+
*注意：如果是列和行其中之一有空缺是可以通过复制来运算的。
−
a_ones = np.ones((3,4))#创建3*4的全1矩阵
+
但是蓝本不能有缺或者多，即行和列都不完整。
−
print(a_ones )
 
−
# [[1. 1. 1. 1.]
 
−
#  [1. 1. 1. 1.]
 
−
#  [1. 1. 1. 1.]]
 
  
−
a_zeros = np.zeros((3,4))#创建3*4的全0矩阵
+
----
−
print(a_zeros )
+
a=np.array([[ 1.,  2.,  1.],
−
# [[0. 0. 0. 0.]
+
            [ 1.,  2.,  1.],
−
# [0. 0. 0. 0.]
+
            [ 1.,  2.,  1.]])
−
# [0. 0. 0. 0.]]
+
b=np.array([[3.],
 +
            [2.],  
 +
            [1.]])
 +
print(a+b)
 +
[[ 4.  5.  4.]
 +
[ 3.  4.  3.]
 +
[ 2.  3.  2.]]
 +
#当数组就只有一个元素的时候，那么其实和常数就没什么区别了
 +
a=np.array([[ 1.,  2.,  1.],
 +
            [ 1.,  2.,  1.],
 +
            [ 1.,  2., 1.]])
 +
b=np.array([[3.]])
 +
print(a+b)
 +
[[ 4. 5. 4.]
 +
  [ 4. 5. 4.]
 +
[ 4.  5.  4.]]
  
−
a_eye = np.eye(3)#创建3阶单位矩阵
+
----
−
# print(a_eye)
+
高维数组的运算
−
# [[1. 0. 0.]
+
无论在多少个方向上缺失数据，只要能通过复制解决就可以运算，复制只能依据1个副本，不能有多个副本
−
#  [0. 1. 0.]
+
Image("2.png")
−
#  [0. 0. 1.]]
 
−
---------------------------------
 
  
−
== 矩阵数组的点乘 —— dot ==
+
a=np.array([[[ 1.,  2.,  1.],
−
---------------------------------
+
            [ 1.,  2.,  1.],
−
import numpy as np
+
            [ 1.,  2.,  1.]],
 +
           
 +
          [[ 1.,  2.,  1.],
 +
            [ 1.,  2.,  1.],
 +
            [ 1.,  2.,  1.]]])
 +
b=np.array([[ 3.,  2.,  1.],
 +
            [ 3.,  2.,  1.],
 +
            [ 3.,  2.,  1.]])
 +
print(a+b)
 +
[[[ 4.  4.  2.]
 +
  [ 4.  4.  2.]
 +
  [ 4.  4.  2.]]
  
−
a = np.array([[1,2,3],[7,6,2]])
+
[[ 4.  4.  2.]
−
b = np.array([[1,2],[7,6],[8,2]])
+
  [ 4.  4.  2.]
−
print(a.dot(b))
+
  [ 4.  4.  2.]]]
−
# [[39 20]
+
a=np.array([[[ 1., 2., 1.],
−
#  [65 54]]
+
            [ 1., 2., 1.],
−
print(a[0,:].dot(b))#第一行的所有列*b
+
            [ 1.,  2.,  1.]],
−
---------------------------------
+
           
 +
          [[ 1., 2.,  1.],
 +
            [ 1.,  2., 1.],
 +
            [ 1., 2.,  1.]]])
 +
b=np.array([[ 3.],
 +
            [ 3.],
 +
            [ 3.]])
 +
print(a+b)
 +
[[[ 4.  5.  4.]
 +
  [ 4.  5.  4.]
 +
  [ 4.  5.  4.]]
  
−
== 行列式的叉乘 —— linalg.det ==
+
[[ 4.  5.  4.]
−
---------------------------------
+
  [ 4.  5.  4.]
−
import numpy as np
+
  [ 4.  5.  4.]]]
 +
a=np.array([[[ 1.,  2.,  1.],
 +
            [ 1.,  2.,  1.],
 +
            [ 1.,  2.,  1.]],
 +
           
 +
          [[ 1.,  2.,  1.],
 +
            [ 1.,  2.,  1.],
 +
            [ 1.,  2.,  1.]]])
 +
b=np.array([[ 5.,6,7]])
 +
print(a+b)
 +
[[[ 6.  8.  8.]
 +
  [ 6.  8.  8.]
 +
  [ 6.  8.  8.]]
  
−
a = np.array([[2,3],[6,2]])
+
[[ 6.  8.  8.]
−
print(np.linalg.det(a))
+
  [ 6.  8.  8.]
−
#>>>-14.000000000000004
+
  [ 6. 8. 8.]]]
−
---------------------------------
 

2020年5月16日 (六) 12:44的最新版本

numpy数组的广播机制

  • 注意numpy里数组之间的运算和线性代数中的矩阵运算是不一样的
  • 同纬度和形状的数组之间就是同位置的元素两两匹配运算的结果


import numpy as np
a=np.array([[ 1., 2., 1.], [ 1., 2., 1.]])
b=np.array([[ 1., 2., 3.], [ 1., 2., 3.]])
print(a.shape,b.shape)
>>>(2, 3) (2, 3)
print(a+b)
>>>array([[ 2., 4., 4.],[ 2., 4., 4.]])
print(a*b)
>>>array([[ 1., 4., 3.],[ 1., 4., 3.]])
print(a-b)
>>>array([[ 0., 0., -2.],[ 0., 0., -2.]])
print(a**b)
>>>array([[ 1., 4., 1.],[ 1., 4., 1.]])

  • 当两个数组其中一个的维度少于另外一个的时候

少的数组在某一个轴（或是多个轴）的方向缺失数据，缺数据的那个方向只能有1个元素（或是一行，一面）作为复制蓝本，然后依照轴的方向复制，复制数由多的那个数组的大小决定

  • 注意：如果是列和行其中之一有空缺是可以通过复制来运算的。

但是蓝本不能有缺或者多，即行和列都不完整。

a=np.array([[ 1., 2., 1.], 

           [ 1.,  2.,  1.],
           [ 1.,  2.,  1.]])

b=np.array([[3.], 

           [2.], 
           [1.]])

print(a+b) [[ 4. 5. 4.] 

[ 3.  4.  3.]
[ 2.  3.  2.]]
  1. 当数组就只有一个元素的时候，那么其实和常数就没什么区别了

a=np.array([[ 1., 2., 1.], 

           [ 1.,  2.,  1.],
           [ 1.,  2.,  1.]])

b=np.array(3.) print(a+b) [[ 4. 5. 4.] 

[ 4.  5.  4.]
[ 4.  5.  4.]]

高维数组的运算 无论在多少个方向上缺失数据，只要能通过复制解决就可以运算，复制只能依据1个副本，不能有多个副本 Image("2.png")

a=np.array([[[ 1., 2., 1.], 

           [ 1.,  2.,  1.],
           [ 1.,  2.,  1.]],
           
          [[ 1.,  2.,  1.],
           [ 1.,  2.,  1.],
           [ 1.,  2.,  1.]]])

b=np.array([[ 3., 2., 1.], 

           [ 3.,  2.,  1.],
           [ 3.,  2.,  1.]])

print(a+b) [[[ 4. 4. 2.] 

 [ 4.  4.  2.]
 [ 4.  4.  2.]]

[[ 4.  4.  2.]
 [ 4.  4.  2.]
 [ 4.  4.  2.]]]

a=np.array([[[ 1., 2., 1.], 

           [ 1.,  2.,  1.],
           [ 1.,  2.,  1.]],
           
          [[ 1.,  2.,  1.],
           [ 1.,  2.,  1.],
           [ 1.,  2.,  1.]]])

b=np.array([[ 3.], 

           [ 3.],
           [ 3.]])

print(a+b) [[[ 4. 5. 4.] 

 [ 4.  5.  4.]
 [ 4.  5.  4.]]

[[ 4.  5.  4.]
 [ 4.  5.  4.]
 [ 4.  5.  4.]]]

a=np.array([[[ 1., 2., 1.], 

           [ 1.,  2.,  1.],
           [ 1.,  2.,  1.]],
           
          [[ 1.,  2.,  1.],
           [ 1.,  2.,  1.],
           [ 1.,  2.,  1.]]])

b=np.array(5.,6,7) print(a+b) [[[ 6. 8. 8.] 

 [ 6.  8.  8.]
 [ 6.  8.  8.]]

[[ 6.  8.  8.]
 [ 6.  8.  8.]
 [ 6.  8.  8.]]]
取自“http://www.openbrains.net/mediawiki/index.php?title=广播机制：通过扩展实现数组运算&oldid=18468”