数组

貌似也称为tensor？

  1. >>> import numpy as np
  2. >>> a = np.array([1, 2, 3])
  4. >>> print(type(a))
  5. <class 'numpy.ndarray'>
  7. >>> print(a.shape)
  8. (3,)
  10. >>> print(a[0], a[1], a[2])
  11. 1 2 3
  13. >>> a[0] = 5
  14. >>> print(a)
  15. [5 2 3]
  17. >>> b = np.array([[1,2,3], [4,5,6]])
  18. >>> print(b.shape) 
  19. (2, 3)
  21. >>> print(b[0,0], b[0,1], b[1,0])
  22. 1 2 4

从第18行可以看出，array的维数是从外往内数的，看最左边，有2个方括号，那肯定是2维的，然后从外面一层层开始数，有2个方括号（[1,2,3]和[4,5,6]），所以第一个维度是2，再数里面的方括号，有3个数字（例如1,2,3），所以，第二个维度是3。这个从第21行，也可以看出array是如何排序的。

创建array

  1. >>> import numpy as np
  2. >>> a = np.zeros((2,2))
  3. >>> print(a)
  4. [[0. 0.]
  5.  [0. 0.]]
  7. >>> b = np.ones((1,2))
  8. >>> print(b)
  9. [[1. 1.]]
  10. >>> print(b.shape)
  11. (1, 2)
  13. >>> c = np.full((2,2), 7)
  14. >>> print(c)
  15. [[7 7]
  16.  [7 7]]
  18. >>> d = np.eye(2)
  19. >>> print(d)
  20. [[1. 0.]
  21.  [0. 1.]]
  23. >>> e = np.random.random((2,2))
  24. >>> print(e)
  25. [[0.7265488  0.51714818]
  26.  [0.42346625 0.88364074]]

查询

切片

不产生新数据

  1. # 创建一个(3,4)的2维数组
  2. >>> a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])
  3. >>> print(a.shape)
  4. (3, 4)
  5. >>> print(a[0, 1])
  6. 2
  7. >>> print(a[0])
  8. [1 2 3 4]
  9. >>> print(a[0].shape)
  10. (4,)
  11. # 注意这种取法的结果是产生了一个一维的结果，并不是行向量或者列向量，对a[0]求转置，是其自身
  12. # 所以，a[0]到底是个啥？
  13. >>> print(a[0].T)
  14. [1 2 3 4]
  15. >>> print(a[0].T.shape)
  16. (4,)
  19. # 数组是多维的，所以，切片也要对每个维度进行指定
  20. # python的切片类似于subList，所以我们可以直接看出，b的维度一定是(2,2)
  21. # 第1个维度上取0,1，那一定前两个方框；第2个维度上取1,2，每个方框内取第2,3个元素
  22. >>> b = a[:2, 1:3]
  23. >>> print(b)
  24. [[2 3]
  25.  [6 7]]
  27. # 可以看到a和b指向的是同一块内存区域，所以，对b做改变，a也随之改变
  28. # 所以，numpy的切片，产生的一个view，这是与subList以及Python的List都不同的地方
  29. >>> b[0, 0] = 77
  30. >>> print(a[0, 1])
  31. 77
  33. # 这是个List的例子，可以看到，a切片产生的是一个复制，所以b的改变不影响a
  34. >>> a = [1, 2, 3]
  35. >>> b = a[0:2]
  36. >>> b[0] = 4
  37. >>> print(a)
  38. [1, 2, 3]
  1. >>> a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])
  3. # 在某个维度上，取单个数字和取一个区间，会产生不同的结果
  4. >>> row_r1 = a[1, :]
  5. >>> row_r2 = a[1:2, :]
  6. >>> print(row_r1, row_r1.shape)
  7. [5 6 7 8] (4,)
  8. >>> print(row_r2, row_r2.shape)
  9. [[5 6 7 8]] (1, 4)
  11. >>> col_r1 = a[:, 1]
  12. >>> col_r2 = a[:, 1:2]
  13. >>> print(col_r1, col_r1.shape)
  14. [ 2  6 10] (3,)
  15. >>> print(col_r2, col_r2.shape)
  16. [[ 2]
  17.  [ 6]
  18.  [10]] (3, 1)

取数组的一部分，并产生一个新数据

不同于Slicing，每次产生的是原数组的view，这里每次产生的都是一个新的数组。

  1. >>> import numpy as np
  2. >>> a = np.array([[1,2], [3,4], [5,6]])
  3. >>> print(a.shape)
  4. (3, 2)
  6. # 第1个[0,1,2]是对第1个维度来说，也就取第1个维度的第0，1，2元素，这里就是[1,2] [3,4] [5,6]
  7. # 第2个[0,1,0]是对第2个维度来说，也就是在第一个1维度确定的基础上，分别取第0，1，0个元素
  8. # 所以结果就是，1 4 5
  9. >>> print(a[[0,1,2], [0,1,0]])
  10. [1 4 5]
  12. # 只取1个维度，默认就是第1个维度，所以第1个维度的第 0 1 0个元素就是下面的结果
  13. >>> print(a[[0,1,0]])
  14. [[1 2]
  15.  [3 4]
  16.  [1 2]]
  18. # a[0,0]，第1个0表示取第1个维度的第0个元素，第2个0表示取第2个维度的第0个元素
  19. # a[0,0] 表示取到的是1个数，如果是a[[0], [0]] 表示取到的是一个数组
  20. >>> print(np.array([a[0,0], a[1,1], a[2,0]]))
  21. [1 4 5]
  23. # 如上描述，这里取到的就是一个数组
  24. >>> b = a[[0],[0]]
  25. >>> print(b.shape)
  26. (1,)
  28. # 表示分别取第1个维度的0 0元素，然后在此基础上取第1 1 个元素
  29. >>> print(a[[0,0], [1,1]])
  30. [2 2]
  32. >>> print(np.array([a[0,1], a[0,1]]))
  33. [2 2]

有了上面的解释，下面的这段代码应该不难理解。可以利用另外一个array来选取arrray。

  1. >>> import numpy as np
  2. >>> a = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
  3. >>> print(a)
  4. [[ 1  2  3]
  5.  [ 4  5  6]
  6.  [ 7  8  9]
  7.  [10 11 12]]
  9. >>> b = np.array([0, 2, 0, 1])
  10. >>> print(b)
  11. [0 2 0 1]
  13. >>> print(a[np.arange(4), b])
  14. [ 1  6  7 11]
  15. >>> print(np.arange(4))
  16. [0 1 2 3]
  18. >>> a[np.arange(4), b] += 10
  19. >>> print(a)
  20. [[11  2  3]
  21.  [ 4  5 16]
  22.  [17  8  9]
  23.  [10 21 12]]

布尔类型数组的切片

  1. >>> import numpy as np
  2. >>> a = np.array([[1,2], [3, 4], [5, 6]])
  4. >>> bool_idx = (a > 2)
  5. >>> print(bool_idx)
  6. [[False False]
  7.  [ True  True]
  8.  [ True  True]]
  10.  # 这只是按照1个维度选，所以结果都是1维的
  11. >>> print(a[bool_idx])
  12. [3 4 5 6]
  14. >>> print(a[a > 2])
  15. [3 4 5 6]

拼接

vstack

hstack

数据类型

通常，numpy会尝试进行推断数据类型，但是也允许你指定数据类型。

  1. >>> import numpy as np
  3. >>> x = np.array([1, 2])
  4. >>> print(x.dtype)
  5. int64
  7. >>> x  = np.array([1.0, 2.0])
  8. >>> print(x.dtype)
  9. float64
  11. >>> x = np.array([1.0, 2.0], dtype=np.int64)
  12. >>> print(x.dtype)
  13. int64

数组运算

numpy提供对运算符的重载，因此可以直接使用运算符来进行数组间的运算，也可以使用提供的函数来进行数组间的运算。

数组元素间对应位置的+ - * /

  1. >>> import numpy as np
  2. >>> x = np.array([[1,2],[3,4]], dtype=np.float64)
  3. >>> y = np.array([[5,6],[7,8]], dtype=np.float64)
  5. >>> print(x + y)
  6. [[ 6.  8.]
  7.  [10. 12.]]
  8. >>> print(np.add(x,y))
  9. [[ 6.  8.]
  10.  [10. 12.]]
  12. >>> print(x - y)
  13. [[-4. -4.]
  14.  [-4. -4.]]
  15. >>> print(np.subtract(x, y))
  16. [[-4. -4.]
  17.  [-4. -4.]]
  19. >>> print(x * y)
  20. [[ 5. 12.]
  21.  [21. 32.]]
  22. >>> print(np.multiply(x, y))
  23. [[ 5. 12.]
  24.  [21. 32.]]
  26. >>> print(x / y)
  27. [[0.2        0.33333333]
  28.  [0.42857143 0.5       ]]
  29. >>> print(np.divide(x, y))
  30. [[0.2        0.33333333]
  31.  [0.42857143 0.5       ]]
  33. >>> print(np.sqrt(x))
  34. [[1.         1.41421356]
  35.  [1.73205081 2.        ]]

数组间的乘法 dot，向量间的dot相当于是向量的内积；矩阵间或矩阵和向量间，相当于矩阵的乘法。

  1. >>> import numpy as np
  2. >>> x = np.array([[1,2],[3,4]])
  3. >>> y = np.array([[5,6],[7,8]])
  4. >>> v = np.array([9,10])
  5. >>> w = np.array([11, 12])
  7. >>> print(x)
  8. [[1 2]
  9.  [3 4]]
  10. >>> print(v.shape)  # w,v是列向量
  11. (2,)
  12. >>> print(w.shape)
  13. (2,)
  15. # dot用于两个向量间是求向量的内积，所以这里是9*11+10*12=219
  16. >>> print(v.dot(w))
  17. 219
  18. >>> print(np.dot(v, w))
  19. 219
  21. # x.shape(2,2) v.shape=(2,)  
  22. # x.dot(v)可以理解为是x的两个行向量分别于v做dot运算
  23. # 1*9+2*10=29  3*9+4*10=67
  24. >>> print(x.dot(v))
  25. [29 67]
  26. >>> print(np.dot(x, v))
  27. [29 67]
  29. >>> a = np.array([1,2])
  30. >>> print(a.shape)
  31. (2,)
  33. >>> b = np.array([[3,4]])
  34. >>> b.shape
  35. (1, 2)
  37. # a 是一个行向量，在np.dot中可以理解为一个矩阵，维度为(1,2)
  38. # b 是一个矩阵，维度(1,2)，所以np.dot(a,b)维度是对不上的，会报错
  39. >>> np.dot(a,b)
  40. Traceback (most recent call last):
  41.   File "<stdin>", line 1, in <module>
  42. ValueError: shapes (2,) and (1,2) not aligned: 2 (dim 0) != 1 (dim 0)
  44. # c 是一个矩阵，维度是(2,1)，所以np.dot(a,b)，结果是一个1x1的矩阵
  45. >>> c = np.array([[1],[2]])
  46. >>> np.dot(a,c)
  47. array([5])
  49. # 1*5+2*7=19  1*6+2*8=22  
  50. # 3*5+4*7=43  3*6+4*8=50
  51. >>> print(x.dot(y))
  52. [[19 22]
  53.  [43 50]]
  54. >>> print(np.dot(x, y))
  55. [[19 22]
  56.  [43 50]]

作用于数组本身

  1. >>> import numpy as np
  2. >>> x = np.array([[1,2],[3,4]])
  3. >>> print(x)
  4. [[1 2]
  5.  [3 4]]
  7. >>> print(np.sum(x))  # Compute sum of all elements
  8. 10
  10. >>> print(np.sum(x, axis=0))  # Compute sum of each column
  11. [4 6]
  13. >>> print(np.sum(x, axis=1))  # Compute sum of each row
  14. [3 7]

向量和矩阵的转置

  1. >>> import numpy as np
  3. >>> v = np.array([1,2,3])
  4. >>> print(v)
  5. [1 2 3]
  6. >>> print(v.T)
  7. [1 2 3]
  9. # 向量的转置等于其本身
  10. >>> print(v_t.shape)
  11. (3,)
  12. >>> print(v.T.shape)
  13. (3,)
  15. # 矩阵的转置，注意与向量的区别
  16. >>> m = np.array([[1,2,3]])
  17. >>> print(m.shape)
  18. (1, 3)
  19. >>> print(m.T.shape)
  20. (3, 1)
  21. >>> print(m.T)
  22. [[1]
  23.  [2]
  24.  [3]]
  26. >>> x = np.array([[1,2], [3,4]])
  27. >>> print(x)
  28. [[1 2]
  29.  [3 4]]
  30. >>> print(x.T)
  31. [[1 3]
  32.  [2 4]]

广播机制

broadcasting可以简化代码，提高运行速度，通常是在一个大的array和一个小的array间发生。

  1. >>> import numpy as np
  3. # We will add the vector v to each row of the matrix x,
  4. # storing the result in the matrix y
  5. >>> x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
  6. >>> v = np.array([1, 0, 1])
  7. >>> y = np.empty_like(x)   # Create an empty matrix with the same shape as x
  9. # Add the vector v to each row of the matrix x with an explicit loop
  10. # 如果没有广播机制，我们需要将x的每一行，都加上v，存入到y的对应行中
  11. >>> for i in range(4):
  12. ...     y[i, :] = x[i, :] + v
  14. >>> print(y)
  15. [[ 2  2  4]
  16.  [ 5  5  7]
  17.  [ 8  8 10]
  18.  [11 11 13]]

当x有很多行时，循环是非常低效的，所以，我们想到也许可以用v生成一个与x同型的矩阵，然后通过矩阵加法来实现。

  1. >>> import numpy as np
  2. >>> x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
  3. >>> v = np.array([1, 0, 1])
  4. >>> vv = np.tile(v, (4, 1))
  5. >>> print(vv)
  6. [[1 0 1]
  7.  [1 0 1]
  8.  [1 0 1]
  9.  [1 0 1]]
  11. >>> y = x + vv
  12. >>> print(y)
  13. [[ 2  2  4]
  14.  [ 5  5  7]
  15.  [ 8  8 10]
  16.  [11 11 13]]

广播机制，提供了更简洁的代码和更高效的计算。

  1. >>> import numpy as np
  3. # We will add the vector v to each row of the matrix x,
  4. # storing the result in the matrix y
  5. >>> x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
  6. >>> v = np.array([1, 0, 1])
  8. >>> y = x + v  # Add v to each row of x using broadcasting
  9. >>> print(y)  # Prints "[[ 2  2  4]
  10. [[ 2  2  4]
  11.  [ 5  5  7]
  12.  [ 8  8 10]
  13.  [11 11 13]]
  15. # 然而，x.shape=(4,3) v.shape=(3,)
  16. # 那么为什么会是行相加呢？
  17. >>> x = np.array([[1,2], [3,4], [5,6]])
  18. >>> print(x.shape)
  19. (3, 2)
  20. >>> v = np.array([1, 0, 1])
  21. >>> y = x + v
  22. Traceback (most recent call last):
  23.   File "<stdin>", line 1, in <module>
  24. ValueError: operands could not be broadcast together with shapes (3,2) (3,)

这里有一篇broadcasting机制的官方文档翻译，可以看看。

现在，应该可以把向量(3,)理解为只有1个维度

也就是按照文档里说的，可以出现broadcasting的原则遵循，从后向前，对应位置进行维度匹配：

  1. 维度相等
  2. 有维度为1

例如：

  1. Image  (3d array): 256 x 256 x 3
  2. Scale  (1d array):             3
  3. Result (3d array): 256 x 256 x 3
  1. A      (4d array):  8 x 1 x 6 x 1
  2. B      (3d array):      7 x 1 x 5
  3. Result (4d array):  8 x 7 x 6 x 5

反例：

  1. A      (1d array):  3
  2. B      (1d array):  4 # trailing dimensions do not match
  4. A      (2d array):      2 x 1
  5. B      (3d array):  8 x 4 x 3 # second from last dimensions mismatched

所以，我们上面，第一个例子能进行broadcasting，是因为遵循了：

  2. # We will add the vector v to each row of the matrix x,
  3. # storing the result in the matrix y
  4. >>> x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
  5. >>> v = np.array([1, 0, 1])
  7. >>> y = x + v  # Add v to each row of x using broadcasting
  8. >>> print(y)  # Prints "[[ 2  2  4]
  9. [[ 2  2  4]
  10.  [ 5  5  7]
  11.  [ 8  8 10]
  12.  [11 11 13]]
  14. x  (2d array):  4 x 3
  15. v  (1d array):      3
  16. y  (2d array):  4 x 3

而第二个例子，报错，是因为：

  1. >>> x = np.array([[1,2], [3,4], [5,6]])
  2. >>> print(x.shape)
  3. (3, 2)
  4. >>> v = np.array([1, 0, 1])
  5. >>> y = x + v
  6. Traceback (most recent call last):
  7.   File "<stdin>", line 1, in <module>
  8. ValueError: operands could not be broadcast together with shapes (3,2) (3,)
  10. x  (2d array): 3 x 2
  11. v  (1d array):     3
  12. y                  mismatched
  13. 可以看到，这里最后一个维度是不相等，且没有维度为1的，所以匹配失败，不能broadcasting。

{% hint style=”warning” %}
由此，我们可以总结一下numpy中的一维向量
{% endhint %}

由np.array([0, 1, 2])生成，shape为(3,)，他其实不是一个向量的理解方式，所以其转置依然等于自身。

维度变换

np.newaxis

  1. a = np.arange(1, 13).reshape(3,4)
  2. b = np.asarray([2, 1 ,1])
  3. print("a shape = ", a.shape)
  4. print(a)
  5. print("\n")
  6. print("b shape = ", b.shape)
  7. print(b)
  9. #print(a-b)  报错，维度不匹配，无法进行broadcasting
  10. c = b[:, np.newaxis]
  11. print("\n")
  12. print("c shape = ", c.shape)
  13. print(c)
  15. print("\n")
  16. print("a-c \n", a-c)
  18. # 结果
  19. a shape =  (3, 4)
  20. [[ 1  2  3  4]
  21.  [ 5  6  7  8]
  22.  [ 9 10 11 12]]
  25. b shape =  (3,)
  26. [2 1 1]
  29. c shape =  (3, 1)
  30. [[2]
  31.  [1]
  32.  [1]]
  35. a-c 
  36.  [[-1  0  1  2]
  37.  [ 4  5  6  7]
  38.  [ 8  9 10 11]]

变量填充 np.pad

  1. import numpy as np
  2. x = np.array([[1,2], [3,4]])
  3. print(x)
  5. [[1 2]
  6.  [3 4]]
  8. # 在第一个维度的前面填充0个0，后面填充1个0，在第二个维度前后都填充0个0
  9. print(np.pad(x, pad_width=((0,1), (0,0)), mode='constant', constant_values=0))
  10. [[1 2]
  11.  [3 4]
  12.  [0 0]]
  14. # 在第一个维度前后都填充0个0，在第二个维度前后都填充1个0
  15. print(np.pad(x, pad_width=((0,), (1,)), mode='constant', constant_values=0))
  16. [[0 1 2 0]
  17.  [0 3 4 0]]

可以看到，x是一个二维数组，所以pad_width是依次对每一个维度进行指定，pad_width=((0,1), (0,0))表示在第一个维度在后面填充1个；pad_width=((0,), (1,))里的(0, )表示前后都填充一样的个数，这里为0，就是前后都不填充。pad_width是指定对每个维度前后的填充个数，而mode表示如何填充，这里constant表示填充固定值，而最后值由constant_values指定。

排序

  1. import numpy as np
  2. import pandas as pd
  4. # =============================================================================
  5. a = np.array([0.8, 0.2, 0.9, 0.1])
  6. a.sort()
  7. # 将a变成排好序的array #不会输出结果 #直接更改array
  8. print(a)
  9. # 结果显示为 [0.1 0.2 0.8 0.9]
  11. # =============================================================================
  12. a = np.array([0.8, 0.2, 0.9, 0.1])
  13. sorted(a)
  14. # 输出结果[0.1 0.2 0.8 0.9] # 但a不会变
  15. print(a)
  16. # 结果依然为[0.8 0.2 0.9 0.1]
  18. # =============================================================================
  19. np.argsort(a)
  20. # 结果为 array([3, 1, 0, 2])
  21. # 这个显示的是，如果排好序，排成[0.1 0.2 0.8 0.9]的样子，这些value在原来的array中的index是多少
  23. # =============================================================================
  24. np.argsort(np.argsort(a))
  25. # 结果为 array([2, 1, 3, 0])
  26. # 这个显示的是，按照原来在array中出现的顺序[0.8, 0.2, 0.9, 0.1]，如果排序，各个位置上相应的value在序列中的序号是多少
  28. # =============================================================================
  29. #pd包中类似的
  30. pd.DataFrame(a).rank()
  31. # 结果如下，这个直接是其序号，从1开始，不是像np包中，从0开始
  32. # =============================================================================
  33. #      0
  34. # 0  3.0
  35. # 1  2.0
  36. # 2  4.0
  37. # 3  1.0
  38. # =============================================================================
  40. # =============================================================================
  41. # 上面结果跟下面这个相同
  42. np.argsort(np.argsort(a)) +1
  43. # 结果为 array([3, 2, 4, 1])
  45. # =============================================================================
  46. np.argsort(np.argsort(-a))
  47. # 这个是倒序排序的序号
  49. # =============================================================================
  50. # 排序的另一种方法，正序
  51. a[np.argsort(a)]
  52. # 结果为array([0.1, 0.2, 0.8, 0.9])
  54. # =============================================================================
  56. # 排序的另一种方法，倒序
  57. a[np.argsort(-a)]
  58. # 结果为array([0.9, 0.8, 0.2, 0.1])

Q&A

matrix与array的区别

class ‘numpy.matrixlib.defmatrix.matrix’