介绍

  • Numpy (Numerical Python) 是python中的一个基础工具包，用以进行科学计算及数据分析，
  • Numpy中单一数据类型的多维数组以ndarray的形式存储，可进行快速矢量算术运算，
  • Numpy还可用于磁盘数据的读写以及内存映射文件的操作，实现数据的快速读写与输出，

  • Numpy也是数据分析必不可少的工具，可以进行数据清洗、数据转换等矢量化数组运算。

    安装

    1. # python -m pip会使用您指定为python的Python解释器来执行pip
    2. python -m pip install numpy

    创建ndarray数组


    ndarray：数组中的所有对象必须是相同类型的，创建ndarray数组可以使用array函数传入python序列对象实现

  • 一维数组 ```python import numpy as np

创建一维数组

a = [1, 2, 3, 4, 5] arr1 = np.array(a) print(“创建一维数组：\n”, arr1)

  2.    -  **多维数组  **
  3. ```python
  4. # 创建多维数组
  5. b = [[1, 2, 3], [4, 5, 6]]
  6. arr2 = np.array(b)
  7. print("创建多维数组：\n", arr2)

  • shape函数
    shape函数是查看每个数组各维度的大小，返回值是一个元组对象，数组是一维数组，返回值是(n,)，n表示数组的长度，数组是二维数组，返回值是(n1,n2) ，n1表示行数，n2表示列数，对于三维数组就是包含多少个二维数组，后两个数字表示二维数组的行与列 返回值是(n1,n2,n3)， n1表示几个二维数组，n2表示二维数组的行，n3表示二维数组列 

    1. # shape
    2. print("arr1 shape: ", arr1.shape)
    3. print("arr2 shape: ", arr2.shape)

  • reshape函数
    reshape函数可以更改数组的结构，原数组的shape仍然保持不变，原数组与新数组是共享同一数据储存内存区域，所以对其中一个数组元素修改，都会同时引起另一个数组内容的改变 

    1. # reshape
    2. arr2_reshape = arr2.reshape(3,2)
    3. print("arr2 reshape前：\n",arr2)
    4. print("arr2 reshape后: \n",arr2_reshape)

  • 特殊数组 

    1. # 特殊数组
    2. print("创建都是0的一维数组：\n",np.zeros(3))
    3. print("创建都是0的多维数组：\n",np.zeros((2,3)))
    4. print("创建都是1的多维数组：\n",np.ones((2,3)))
    5. print("创建没有具体数值的多维数组：\n",np.empty((2,2,3)))
    6. print("创建指定序列数组：\n",np.arange(10))
    7. print("创建单位数组：\n",np.eye(3,3))

数组的数据类型

  • 数组的数据类型保存在dtype对象中，可使用dtype函数查看
  • 创建ndarray时，dtype作为一个参数可以将一块内存解释为特定的数据类型
  • dtype的命名方式：数据类型+元素位长
  • 对已经创建好的ndarray，可以使用astype函数转换其数据类型
  • Numpy支持的数据类型（如下）：
    | 类型 | 名称 | | —- | —- | | int8、unit8 | 有符号和无符号的8位整型（1个字节） | | int16、unit16 | 有符号和无符号的16位整型（2个字节） | | int32、unit32 | 有符号和无符号的32位整型（4个字节） | | int64、unit64 | 有符号和无符号的64位整型（8个字节） | | float16 | 半精度浮点数 | | float32 | 标准的单精度浮点数 | | float64 | 标准的双精度浮点数 | | complex64、complex128、complex256 | 用两个32位、64位、128位浮点数表示的复数 | | bool | 布尔类型，True和False | | object | Python对象类型 | | string | 固定长度的字符串类型（每个字符1个字节） | | unicode | 固定长度的unicode类型 |

数组的索引和切片

  • 一维数组
    一维numpy数组的索引和切片方法基本与python列表一致，索引：通过对数组使用中括号，中括号中填入元素的位置整数来获取目标元素。切片：通过在中括号中填入元素位置的区间来确定元素片段
    ```python import numpy as np

    一维数组索引

    arr_1d = np.arange(10) print(“arr_1d: “,arr_1d) print(“arr_1d[8]: “,arr_1d[8]) print(“arr_1d[5:9]: “,arr_1d[5:9])

修改索引5到8的值

arr_1d[5:9] = 10 print(“修改索引5到8值：”,arr_1d)

  2.    - ** 二维数组**<br />对于二维数组，每个索引位置上对应的元素不再是标量而是一维数组 <br />`arr_2d`二维数组结构：  
  3. ```python
  4. # 二维数组索引
  5. arr_2d = np.array([[1,2,3],[4,5,6]])
  6. print("arr_2d[1]: ",arr_2d[1])
  7. print("arr_2d[1][1]: ",arr_2d[1][1])
  8. print("arr_2d[1,1]: ",arr_2d[1,1])
索引 0 1
对应数据 [1,2,3] [4,5,6]

  • 多维数组
    对于多维数组的索引，返回对象为降低维度之后的ndarray
    arr_3d三维数组结构： 

    1. # 多维数组索引
    2. arr_3d = np.arange(16).reshape(2,2,4) #见arr_3d三维数组结构
    3. print("创建三维数组：\n",arr_3d)
    4. print("arr_3d[0]: ",arr_3d[0]) # 见arr_3d三维数组结构 找对应0的行数据
    5. print("arr_3d[0,1]: ",arr_3d[0,1]) # 见arr_3d三维数组结构 先对应0的行数据，在找对应1的列数据
    6. #修改元素值
    7. arr_3d[0,1]=10
    8. print("修改元素值: ",arr_3d)

    | | 0 | 1 | | —- | —- | —- | | 0 | [0,1,2,3] | [4,5,6,7] | | 1 | [8,9,10,11] | [12,13,14,15] |

  • 切片索引
    ndarray 的切片索引只需将数组中的每一行每一列都分别看作一个列表，参考列表切片索引的方法，最后返回数组类型的数据
    ```python

    切片索引

    arr = np.arange(25).reshape(5,5) print(“创建二维数组：”,arr)

print(“取出索引为2:3对应的值是7，8：”,arr[1,2:4]) print(“取出行索引1:2,列索引2:3的二维数组：”,arr[1:3,2:4]) print(“取出第三列之后的二维数组：”,arr[:,2:]) # 2: 表示选取索引为2之后的所有列 print(“行方向隔行取数，列方向取第三列之后的二维数组：”,arr[::2,2:]) # ::2 表示取出所有行数据，2表示步长

  2.    -  **布尔型索引**<br />布尔型数据作为数组的索引时，会根据布尔数组的True或者False值筛选对应轴上的数据<br />布尔型索引不仅可以设置正向条件，还可以设置反向条件： 
  3.       - `!=` 表示不等于
  4.       - `～` 表示对于条件的否定
  5.       - `logical_not`函数用于设置反向条件
  6. ```python
  7. # 使用布尔型索引选取arr2数据
  8. '''
  9. arr2: [[ 0  1  2  3  4]
  10.               [ 5  6  7  8  9]
  11.               [10 11 12 13 14]
  12.               [15 16 17 18 19]
  13.               [20 21 22 23 24]]
  14. '''
  15. arr2 = np.arange(25).reshape(5,5)
  16. # 设置一个x作为筛选条件
  17. x = np.array([0,1,2,3,1])
  18. print("判断x是否等于1：",x==1)
  20. print("索引x=1时对应arr2中的数据：",arr2[x==1])
  21. # 布尔型数组的长度必须跟被索引的轴长度一致
  22. print("布尔型索引与切片结合使用：",arr2[x==1,3:])
  24. # 布尔型反向索引
  25. print(arr2[x != 1])
  26. print(arr2[~(x == 1)])
  27. print(arr2[np.logical_not(x==1)])
  29. # 多条件筛选
  30. print("多条件筛选: ",arr2[(x==1)|(x==0)])
  32. # 布尔型筛选索引修改值
  33. arr2_copy = arr2.copy()
  34. arr2[arr2>15]=20
  35. print("修改之前：",arr2_copy)
  36. print("修改之后：",arr2)

函数调用

  • 统计运算
    Numpy提供一些数学函数，可以直接对整个数组或者某个轴向上的数据进行数学统计计算。比如：求和公式、求平均值、方差、标准差、最大值、最小值、累计和、累计积、最大最小元素的索引等。
    ```python import numpy as np

统计运算

arr = np.arange(25).reshape(5,5) print(“对所有元素求和：”,arr.sum()) print(“求所有元素的均值：”,arr.mean()) print(“求所有元素的标准差：”,arr.std()) print(“求所有元素的方差：”,arr.var()) print(“求元素中的最大值：”,arr.max()) print(“求元素中的最小值：”,arr.min()) print(“求所有元素的累计和：”,arr.cumsum()) print(“求所有元素的累计积：”,arr.cumprod()) print(“求最小元素的索引：”,arr.argmin()) print(“求最大元素的索引：”,arr.argmax())

  2.    -  **矩阵运算**<br />Numpy中的二维数组可以被看作是矩阵，矩阵运算对应的是元素量级，Numpy中矩阵运算的相关函数：矩阵的转置函数(.T)、矩阵的点乘(.dot)、矩阵的迹(trace)等  
  3. ```python
  4. #矩阵的转置：转置是将矩阵中的元素行列对调，得到一个新的矩阵，Numpy中使用 arr.T函数返回矩阵的转置矩阵
  5. arr1 = np.arange(9).reshape(3,3)
  6. print("arr1: ",arr1)
  7. print("转置矩阵: ",arr1.T)
  9. #矩阵的逆：逆矩阵使用np.linalg.inv函数获得
  10. arr2 = np.arange(1,10).reshape(3,3)
  11. print("arr2：",arr2)
  12. print("逆矩阵：",np.linalg.inv(arr2))
  14. #矩阵的加减法：两矩阵相加减，直接使用加减号即可，但要保证两矩阵的结构相同
  15. arr3 = np.arange(9).reshape(3,3)
  16. print("矩阵相加：",arr1+arr3)
  17. print("矩阵相减：",arr1-arr3)
  19. '''
  20. 矩阵的乘法：将第一个矩阵的第m行元素与第二矩阵的第n列元素对应相乘并求和，
  21. 得到结果矩阵中(m,n)对应的元素.(对应第一矩阵使用.dot函数，传入第二个矩阵的转置矩阵作为函数参数)
  23. 矩阵的点乘：是两个结构相同的矩阵对应元素相乘
  24. '''
  25. print("矩阵arr1点乘arr3：",arr1*arr3)
  26. print("arr1乘arr3：",arr1.dot(arr3.T))
  28. #矩阵的迹：在线性代数中，矩阵的迹为矩阵主对角线上各元素的总和，Numpy使用np.trace函数获取矩阵的迹
  29. print("arr1的迹：",np.trace(arr1))
  31. '''
  32. 特征值、特征向量 ：
  33. 如果一个矩阵A是n阶方阵，存在常量m和非零n维向量x，使得Ax=mx，那么称m是矩阵A的一个特征值，向量x为特征值m对应的特征向量
  34. '''
  35. m,x = np.linalg.eig(arr2)
  36. print("特征值：",m)
  37. print("特征向量：",x)

  • 数据处理

    • 排序
      Numpy中的sort函数可对数组做排序处理，当函数中的参数axis=0时，每一列上的元素按照行的方向排序，axis=1时每一行上的元素按照列的方向排序 

      1. # 排序
      2. arr4 = np.array([[3,1,2],[4,3,5],[7,5,1]])
      3. print("排序前：",arr4)
      4. arr4_sort = np.sort(arr4,axis=1)
      5. print("排序后：",arr4)
      6. print("按行排序后：",arr4_sort)
      7. print("-------------------------------------")
      8. arr5 = np.array([[3,1,2],[4,3,5],[7,5,1]])
      9. print("排序前：",arr5)
      10. arr5_sort = np.sort(arr5,axis=0)
      11. print("排序后：",arr5)
      12. print("按列排序后：",arr5_sort)

    • 去重
      Numpy中提供列对一维数组去重的unique函数，该函数的返回值为数组中按照从小到大的顺序排序的非重复元素的元组或列表 

      1. # 去重
      2. arr6 = np.array([1,3,6,4,2,2,1,0])
      3. print("去重后的元素: ",np.unique(arr6))

      文件读写


      Numpy提供了文件读取和写入函数loadtxt和savetxt

  • 写入文件 

    1. arr7 = np.arange(9).reshape(3,3)
    2. np.savetxt("arr7.txt",arr7)

  • 读取文件 

    1. a7 = np.loadtxt("arr7.txt")
    2. print("文件读取内容：",a7)
  • 当才华还配不上野心，就静下来学习