Numpy基础

一、Numpy是什么

数据处理、数据分析

1. 两种基本对象：

   ndarray：存储单一数据类型的多维数组

   ufunc：对数组进行处理的函数

2. 特点

   1. ndarray是快速运算和节省空间的多维数组，提供数组话的算术运算和高级的广播功能
   2. 使用标准数学函数对整个数组的数据进行多维运算，而不需要编写循环
   3. 可以读取/写入磁盘阵列中的数据和操作存储器映像文件
   4. 具有线性代数、随机数生成和傅里叶变换的能力
   5. 可以集成C、C++、Fortran代码

二、生成Numpy数组

1. 导入Numpy

   import numpy as np
   

2. 详细帮助

   np.abs?
   

3. 从已有数据中创建数组

   1. 将列表转换为ndarray

      import numpy as np #001
      lst1 = [3.14, 2.17, 0, 1, 2]
      nd1 = np.array(lst1)
      print(nd1)
      #[3.14 2.17 0.   1.   2.  ]
      print(type(nd1))
      #<class 'numpy.ndarray'>
      

   2. 嵌套列表可以转换成多维ndarray

      import numpy as np #002
      lst2 = [[3.14, 2.17, 0, 1, 2], [1, 2, 3, 4, 5]]
      nd2 = np.array(lst2)
      print(nd2)
      #  [[3.14 2.17 0.   1.   2.  ]
      #  [1.   2.   3.   4.   5.  ]]
      print(type(nd2))
      #<class 'numpy.ndarray'>
      

4. 利用random模块生成数组

   1. 常用函数

      函数	描述
      np.random.random	生成0到1的随机数
      np.random.uniform	生成均匀分布的随机数
      np.random.randn	生成标准正态的随机数
      np.random.randint	生成随机的整数
      np.random.normal	生成正态分布的随机数
      np.random.shuffle	随机打乱顺序
      np.random.seed	设置随机数种子
      random_sample	生成随机的浮点数

   2. 函数的具体使用

      import numpy as np #003
      nd3 = np.random.random([3, 3]) #生成0到1的随机数
      print(nd3)
      #  [[0.69430236 0.51450826 0.50220826]
      #  [0.08621113 0.1619209  0.38583299]
      #  [0.54911094 0.93005294 0.92320553]]
      print(nd3.shape) #形状
      #  (3, 3)
      

      为了每次生成同一份数据，可以指定一个随机种子，使用shuffle函数打乱生成的随机数

      import numpy as np #004
      np.random.seed(123) #随机种子
      nd4 = np.random.randn(2,3) #生成标准正态的随机数
      print(nd4)
      #  [[-1.0856306   0.99734545  0.2829785 ]
      #  [-1.50629471 -0.57860025  1.65143654]]
      np.random.shuffle(nd4)
      print(nd4)
      #  [[-1.50629471 -0.57860025  1.65143654]
      #  [-1.0856306   0.99734545  0.2829785 ]]
      print(type(nd4))
      #  <class 'numpy.ndarray'>
      

5. 创建特定形状的多维数组

   1. 生成矩阵

      函数	描述
      np.zeros((3,4))	创建3x4的元素全为0的数组
      np.ones((3,4))	创建3x4的元素全为1的数组
      np.empty((2,3))	创建2x3的空数组，空数组中的值不为0，而是未初始化的垃圾值
      np.zeros_like(ndarr)	以ndarr相同维度创建元素全为0的数组
      np.ones_like(ndarr)	以ndarr相同维度创建元素全为1的数组
      np.empty_like(ndarr)	以ndarr相同维度创建空数组
      np.eye(5)	创建5x5的矩阵，对角线为1，其余为0
      np.full((3,5),666)	创建3x5的元素全为666的数组，666为指定值

   2. 示例

      import numpy as np #005
      #生成全是0的3x3矩阵
      nd5 = np.zeros([3,3]) 
      #生成全是1的3x3矩阵
      nd6 = np.ones([3,3]) 
      #生成3阶的单位矩阵
      nd7 = np.eye(3)
      #生成3阶的对角矩阵
      nd8 = np.diag([1,2,3])
      
      print(nd5)
      #  [[0. 0. 0.]
      #   [0. 0. 0.]
      #   [0. 0. 0.]]
      print(nd6)
      #  [[1. 1. 1.]
      #   [1. 1. 1.]
      #   [1. 1. 1.]]
      print(nd7)
      #  [[1. 0. 0.]
      #   [0. 1. 0.]
      #   [0. 0. 1.]]
      print(nd8)
      #  [[1 0 0]
      #   [0 2 0]
      #   [0 0 3]]
      

   3. 将生成的数据保存起来

      import numpy as np #006
      nd9 = np.random.random([5,5])
      np.savetxt(X=nd9, fname='./test1.txt')
      nd10 = np.loadtxt('./test1.txt')
      print(nd10)
      #  [[0.34606869 0.01239985 0.44734033 0.67887708 0.71633118]
      #   [0.57939934 0.32661689 0.60915307 0.48162036 0.20612397]
      #   [0.23626836 0.76682614 0.4600871  0.36012094 0.50539937]
      #   [0.52061384 0.5403313  0.39356543 0.54757688 0.17183527]
      #   [0.36896731 0.74819984 0.84855227 0.74980182 0.10026765]]
      

6. 利用arrange、linspace函数生成数组

   1. arange

      np.arange([start,] stop[,step], dtype=None)
      

      start、stop指定范围

      step步长

      import numpy as np #007
      print(np.arange(10))
      # [0 1 2 3 4 5 6 7 8 9]
      print(np.arange(0, 10))
      # [0 1 2 3 4 5 6 7 8 9]
      print(np.arange(1, 4, 0.5))
      # [1.  1.5 2.  2.5 3.  3.5]
      print(np.arange(9, -1, -1))
      # [9 8 7 6 5 4 3 2 1 0]
      

   2. linspace

      np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
      

      

      可以根据输入的指定数据范围及等分数量，自动生成一个线性等分向量，其中endpoint**（包含终点）**默认为True，等分数量num默认为50。如果将retstep设置为True，则会返回一个带步长的ndarray。

      import numpy as np #008
      print(np.linspace(0, 1, 10))
      # [0.         0.11111111 0.22222222 0.33333333 0.44444444 0.55555556
      #  0.66666667 0.77777778 0.88888889 1.        ]
      

三、获取元素

1. 读取数据

   import numpy as np #009
   np.random.seed(2019)
   nd11 = np.random.random([10])
   print(nd11)
   #  [0.90348221 0.39308051 0.62396996 0.6378774  0.88049907 0.29917202
   #   0.70219827 0.90320616 0.88138193 0.4057498 ]
   #获取指定位置数据
   print(nd11[3])
   #   0.6378774010222266
   #截取一段数据
   print(nd11[3:6])
   #   [0.6378774  0.88049907 0.29917202]
   #截取固定间隔数据
   print(nd11[1:6:2])
   #   [0.39308051 0.6378774  0.29917202]
   #倒序取数
   print(nd11[::-2])
   #   [0.4057498  0.90320616 0.29917202 0.6378774  0.39308051]
   
   nd12 = np.arange(25).reshape([5,5])
   print(nd12)
   #  [[ 0  1  2  3  4]
   #   [ 5  6  7  8  9]
   #   [10 11 12 13 14]
   #   [15 16 17 18 19]
   #   [20 21 22 23 24]]
   #截取一个多维数组的一个区域内的数据
   print(nd12[1:3,1:3])
   #  [[ 6  7]
   #   [11 12]]
   #截取一个多维数组,数值在一个区间内的数据
   print(nd12[(nd12>3)&(nd12<10)])
   #  [4 5 6 7 8 9]
   #截取一个多维数组中指定的行
   print(nd12[1:3,:])
   #  [[ 5  6  7  8  9]
   #   [10 11 12 13 14]]
   #截取一个多维数组中指定的列
   print(nd12[:,1:3])
   #  [[ 1  2]
   #   [ 6  7]
   #   [11 12]
   #   [16 17]
   #   [21 22]]
   

2. 随机抽取数据

   import numpy as np #010
   a = np.arange(1,25,dtype=float)
   print(a)
   # [ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10. 11. 12. 13. 14. 15. 16. 17. 18.
   #  19. 20. 21. 22. 23. 24.]
   c1 = np.random.choice(a,size=(3,4)) #size指定输出数组形状
   print(c1) #随机可重复抽取
   # [[ 6.  5. 14. 12.]
   #  [ 4. 23.  5. 17.]
   #  [ 6.  9. 21.  7.]]
   c2 = np.random.choice(a,size=(3,4),replace=False) #replace缺省为True，即可重复抽取
   print(c2) #随机不可重复抽取
   # [[14. 15. 17. 23.]
   #  [20.  6. 19. 10.]
   #  [ 2. 13. 12. 24.]]
   c3 = np.random.choice(a,size=(3,4),p=a/np.sum(a)) #p指定每个元素对应抽取概率
   print(c3) #随机但按制度概率抽取
   # [[12. 21. 19. 22.]
   #  [22. 23. 15. 15.]
   #  [ 9. 12. 17. 12.]]
   

四、Numpy的算术运算

五、数组变形

六、通用函数

七、广播机制