数组操作

一、形状操作

  1. import numpy as np
  1. ary = np.array([[1,2,3],[4,5,6]])
  2. print(ary)
  3. print("-----------------------------------")
  4. #shape修改的是原有的
  5. ary.shape = (3,2)
  6. print(ary) #这里是直接对原有数组ary修改成三行两列的数组
  7. print("-----------------------------------")
  8. #reshape返回一个新的数组
  9. ary = ary.reshape(3,2)
  10. print(ary)
  11. print("------------------------------------")
  12. #将多维变为一维数组
  13. ary01 = ary.reshape((6,),order = 'F') #默认情况下参数order=‘C’以行为顺序展开,F(Fortran)意味以列展开
  14. ary03 = ary.flatten(order = 'F')
  15. print(ary01)
  16. print(ary03)
  17. print("-----------------------------------")
  18. #拓展:数组的形状
  19. t = np.arange(24)
  20. print(t)
  21. print(t.shape)
  22. print("-----------------------------------")
  23. #转换成二维
  24. t1 = t.reshape(4,6)
  25. print(t1)
  26. print(t1.shape)
  27. print("-----------------------------------")
  28. #转换成三维
  29. t2 = t.reshape(2,3,4)
  30. print(t2)
  31. print(t2.shape)
  1. [[1 2 3]
  2. [4 5 6]]
  3. -----------------------------------
  4. [[1 2]
  5. [3 4]
  6. [5 6]]
  7. -----------------------------------
  8. [[1 2]
  9. [3 4]
  10. [5 6]]
  11. ------------------------------------
  12. [1 3 5 2 4 6]
  13. [1 3 5 2 4 6]
  14. -----------------------------------
  15. [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
  16. (24,)
  17. -----------------------------------
  18. [[ 0 1 2 3 4 5]
  19. [ 6 7 8 9 10 11]
  20. [12 13 14 15 16 17]
  21. [18 19 20 21 22 23]]
  22. (4, 6)
  23. -----------------------------------
  24. [[[ 0 1 2 3]
  25. [ 4 5 6 7]
  26. [ 8 9 10 11]]
  27. [[12 13 14 15]
  28. [16 17 18 19]
  29. [20 21 22 23]]]
  30. (2, 3, 4)

二、ndarray转换成为list

  1. #ndarray.tolist将数组转成list
  2. a = np.array([9,12,88,14,25])
  3. lst_a = a.tolist()
  4. print(lst_a)
  5. type(lst_a)
  1. [9, 12, 88, 14, 25]
  2. list

三、ndarray数组索引/切片/循环操作

  1. #跟列表索引切片类似
  2. #print(ary[start,end,step])
  3. #一维数组的切片操作
  4. ary04 = np.arange(1,10)
  5. print(ary04)
  6. print(ary04[3:7])
  7. print(ary04[:7:2])
  8. print(ary04[-7::-2])
  9. print("-----------------------------------")
  10. #多维数组的切片操作
  11. #数组对象[页,行,列],下标从0开始,到数组len-1结束
  12. ary05 = np.arange(1,28).reshape(3,3,3)
  13. print(ary05)
  14. print("-----------------------------------")
  15. #切出1页
  16. print(ary05[1,:,:])
  17. print("-----------------------------------")
  18. #切出所有页的1行
  19. print(ary05[:,1,:])
  20. print("-----------------------------------")
  21. #切出0页的1行1列
  22. print(ary05[0,1,1])
  1. [1 2 3 4 5 6 7 8 9]
  2. [4 5 6 7]
  3. [1 3 5 7]
  4. [3 1]
  5. -----------------------------------
  6. [[[ 1 2 3]
  7. [ 4 5 6]
  8. [ 7 8 9]]
  9. [[10 11 12]
  10. [13 14 15]
  11. [16 17 18]]
  12. [[19 20 21]
  13. [22 23 24]
  14. [25 26 27]]]
  15. -----------------------------------
  16. [[10 11 12]
  17. [13 14 15]
  18. [16 17 18]]
  19. -----------------------------------
  20. [[ 4 5 6]
  21. [13 14 15]
  22. [22 23 24]]
  23. -----------------------------------
  24. [ 5 14]
  1. #多维数组循环操作
  2. ary06 = np.arange(16).reshape(4,4)
  3. ary06
  4. print(ary06.shape)
  5. print(ary06.ndim)
  6. #flat属性
  7. for element01 in ary06.flat: #方式一
  8. print(element01)
  9. for element02 in np.nditer(ary06): #方式二
  10. print(element02)
  1. (4, 4)
  2. 2
  3. 0
  4. 1
  5. 2
  6. 3
  7. 4
  8. 5
  9. 6
  10. 7
  11. 8
  12. 9
  13. 10
  14. 11
  15. 12
  16. 13
  17. 14
  18. 15
  19. 0
  20. 1
  21. 2
  22. 3
  23. 4
  24. 5
  25. 6
  26. 7
  27. 8
  28. 9
  29. 10
  30. 11
  31. 12
  32. 13
  33. 14
  34. 15