1. 数组维度、每个维度大小、总大小

  1. import numpy as np
  3. a = np.random.randint(10, size=(2, 3))
  4. print("a = ", a)
  5. print('ndim-数组的维度')
  6. print("a ndim= ", a.ndim)
  7. print('shape-数组每个维度的大小')
  8. print("a shape= ", a.shape)
  9. print('size-数组的总大小')
  10. print("a size= ", a.size)

2. 创建数组副本

创建数组的副本，而非只是给切片另外赋了个值，即非视图

  1. a = np.arange(10)
  2. print(a)
  3. b = a[2: 5].copy()
  4. print(b)
  5. b[0] = 100
  6. print(a)
  8. [0 1 2 3 4 5 6 7 8 9]
  9. [2 3 4]
  10. [0 1 2 3 4 5 6 7 8 9]

3. 三维的理解

  1. print('两层建筑，每层有3行4列共12个房间')
  2. a = np.arange(24).reshape(2, 3, 4)
  3. print(a)
  4. print('三维坐标（楼层，行号，列号）确定一个房间')
  5. print(a[1, 2, 1])
  6. print('只关心行号和列号，不关心楼层')
  7. print(a[: , 2, 1])
  8. print('只关心楼层')
  9. print(a[0, :, :])
  11. 两层建筑，每层有3行4列共12个房间
  12. [[[ 0  1  2  3]
  13.   [ 4  5  6  7]
  14.   [ 8  9 10 11]]
  16.  [[12 13 14 15]
  17.   [16 17 18 19]
  18.   [20 21 22 23]]]
  19. 三维坐标（楼层，行号，列号）确定一个房间
  20. 21
  21. 只关心行号和列号，不关心楼层
  22. [ 9 21]
  23. 只关心楼层
  24. [[ 0  1  2  3]
  25.  [ 4  5  6  7]
  26.  [ 8  9 10 11]]

4. 处理数组的形状

  1. print('变形')
  2. a = np.arange(24)
  3. b = a.reshape(6, 4)
  4. print(a)
  5. print(b)
  7. [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
  8. [[ 0  1  2  3]
  9.  [ 4  5  6  7]
  10.  [ 8  9 10 11]
  11.  [12 13 14 15]
  12.  [16 17 18 19]
  13.  [20 21 22 23]]

5. 拉直数组

  1. c = b.flatten()
  2. print(c)
  4. [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]

6. 转置数组

  1. print(b)
  2. d = b.transpose()
  3. print(d)
  5. [[ 0  1  2  3]
  6.  [ 4  5  6  7]
  7.  [ 8  9 10 11]
  8.  [12 13 14 15]
  9.  [16 17 18 19]
  10.  [20 21 22 23]]
  11. [[ 0  4  8 12 16 20]
  12.  [ 1  5  9 13 17 21]
  13.  [ 2  6 10 14 18 22]
  14.  [ 3  7 11 15 19 23]]

7. 数组水平叠加

  1. e = d * 2
  2. print(d)
  3. print(e)
  4. f = np.hstack((d, e))
  5. print(f)
  7. [[ 0  4  8 12 16 20]
  8.  [ 1  5  9 13 17 21]
  9.  [ 2  6 10 14 18 22]
  10.  [ 3  7 11 15 19 23]]
  11. [[ 0  8 16 24 32 40]
  12.  [ 2 10 18 26 34 42]
  13.  [ 4 12 20 28 36 44]
  14.  [ 6 14 22 30 38 46]]
  15. [[ 0  4  8 12 16 20  0  8 16 24 32 40]
  16.  [ 1  5  9 13 17 21  2 10 18 26 34 42]
  17.  [ 2  6 10 14 18 22  4 12 20 28 36 44]
  18.  [ 3  7 11 15 19 23  6 14 22 30 38 46]]

8. 数组垂直叠加

  1. e = d * 2
  2. print(d)
  3. print(e)
  4. f = np.vstack((d, e))
  5. print(f)
  7. [[ 0  4  8 12 16 20]
  8.  [ 1  5  9 13 17 21]
  9.  [ 2  6 10 14 18 22]
  10.  [ 3  7 11 15 19 23]]
  11. [[ 0  8 16 24 32 40]
  12.  [ 2 10 18 26 34 42]
  13.  [ 4 12 20 28 36 44]
  14.  [ 6 14 22 30 38 46]]
  15. [[ 0  4  8 12 16 20]
  16.  [ 1  5  9 13 17 21]
  17.  [ 2  6 10 14 18 22]
  18.  [ 3  7 11 15 19 23]
  19.  [ 0  8 16 24 32 40]
  20.  [ 2 10 18 26 34 42]
  21.  [ 4 12 20 28 36 44]
  22.  [ 6 14 22 30 38 46]]

9. 横向拆分

  1. print("b = ")
  2. print(b)
  3. c = np.hsplit(b, 4)
  4. print('c=:')
  5. print(c)
  6. print(c[0])
  8. b = 
  9. [[ 0  1  2  3]
  10.  [ 4  5  6  7]
  11.  [ 8  9 10 11]
  12.  [12 13 14 15]
  13.  [16 17 18 19]
  14.  [20 21 22 23]]
  15. c=:
  16. [array([[ 0],
  17.        [ 4],
  18.        [ 8],
  19.        [12],
  20.        [16],
  21.        [20]]), array([[ 1],
  22.        [ 5],
  23.        [ 9],
  24.        [13],
  25.        [17],
  26.        [21]]), array([[ 2],
  27.        [ 6],
  28.        [10],
  29.        [14],
  30.        [18],
  31.        [22]]), array([[ 3],
  32.        [ 7],
  33.        [11],
  34.        [15],
  35.        [19],
  36.        [23]])]
  37. [[ 0]
  38.  [ 4]
  39.  [ 8]
  40.  [12]
  41.  [16]
  42.  [20]]

10. 纵向拆分

  1. print('纵向拆分')
  2. print("b = ")
  3. print(b)
  4. c = np.vsplit(b, 6)
  5. print('c=:')
  6. print(c)
  7. print(c[0])
  9. b = 
  10. [[ 0  1  2  3]
  11.  [ 4  5  6  7]
  12.  [ 8  9 10 11]
  13.  [12 13 14 15]
  14.  [16 17 18 19]
  15.  [20 21 22 23]]
  16. c=:
  17. [array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]]), array([[12, 13, 14, 15]]), array([[16, 17, 18, 19]]), array([[20, 21, 22, 23]])]
  18. [[0 1 2 3]]

11. 数组类型转换

  1. #int32 --> float64  完全ok
  2. #float64 --> int32  会将小数部分截断
  3. #string_ --> float64 如果字符串数组表示的全是数字，也可以用astype转化为数值类型
  5. print('astype改变数组的元素类型')
  6. d = b.astype(float)
  7. print(d)
  8. [[ 0.  1.  2.  3.]
  9.  [ 4.  5.  6.  7.]
  10.  [ 8.  9. 10. 11.]
  11.  [12. 13. 14. 15.]
  12.  [16. 17. 18. 19.]
  13.  [20. 21. 22. 23.]]

12. numpy数组的切片

list和ndarray的切片不同；
list进行切片操作后生成一个新的序列；
ndarray切片是原始数组的视图，而不会单独生成一个新的ndarray，对切片结果的修改会影响到原始数据；
将一个标量赋值给一个切片时，该值会自动传播到整个切片；
列表的元素可以是任何对象，而ndarray只能是相同类型。

1、list切片赋值

  1. a = list(range(10))  # python的range函数生成的是一个对象，需要用list函数将其转换成列表
  2. b = a[2: 5]
  3. b[1] = 100
  4. print(a)
  5. print(b)
  7. [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  8. [2, 100, 4]

2、ndarray切片赋值

  1. import numpy as np
  2. a = np.arange(10)
  3. print(a)
  4. b = a[2: 5]
  5. b[1] = 100
  6. print(a)
  7. print(b)
  9. [0 1 2 3 4 5 6 7 8 9]
  10. [  0   1   2 100   4   5   6   7   8   9]
  11. [  2 100   4]
  1. a = np.arange(10)
  2. print(a)
  3. a[2: 5] = 100
  4. print(a)
  6. [0 1 2 3 4 5 6 7 8 9]
  7. [  0   1 100 100 100   5   6   7   8   9]
  1. a = np.arange(10)
  2. print(a)
  3. b = a[2: 5]
  4. b[:] = 100
  5. #  b = 100
  6. # 为什么不能用b = 100?
  7. # 当b = 100时，相当与直接把新的值赋值给了新生成的另一个名称为b的这个变量，此时b不再代表a[2: 5]
  8. print(a)
  9. print(b)
  11. [0 1 2 3 4 5 6 7 8 9]
  12. [  0   1 100 100 100   5   6   7   8   9]
  13. [100 100 100]