数据挖掘——numpy基础

前言:python数据挖掘numpy的基础知识,参考网上资料和博客进行简单总结,主要是为了方便自己写代码的时候查看,发现有用的方法,随时补充,欢迎指正

数据挖掘专栏

  1. 数据挖掘——python基础
  2. 数据挖掘——numpy基础
  3. 数据挖掘——pandas基础
  4. 数据挖掘——pandas+matplotlib+seaborn数据可视化

numpy基础

  • 一、认识numpy
  • 二、numpy数组对象(ndarray)
    • 1、创建数组
      • (1)array方法创建数组
      • (2)特殊数组的创建
    • 2、数组的索引
      • (1)单个元素索引
      • (2)使用数组索引数组
      • (3)条件索引
    • 3、数组的运算
      • (1)向量化运算
      • (2)数组的广播
    • 4、array的常用方法
  • 三、numpy常用函数
    • 1、数学函数
      • (1)常用的数学函数
      • (2)随机生成数
    • 2、数据处理
      • (1)数据处理常用函数
      • (2)数组合并

一、认识numpy

numpy是Python中的一个运算速度非常快的一个数学库,它非常重视数组。它允许你在Python中进行向量和矩阵计算,并且由于许多底层函数实际上是用C编写的,因此你可以体验在原生Python中永远无法体验到的速度。
numpy包括:

  • 一个强大的 N 维数组对象 Array;
  • 比较成熟的(广播)函数库;
  • 用于整合 C/C++和 Fortran 代码的工具包;
  • 实用的线性代数、傅里叶变换和随机数生成函数。numpy 和稀疏矩阵运算包 scipy 配合使用更加方便。

二、numpy数组对象(ndarray)

1、创建数组

(1)array方法创建数组

In[2]: import numpy as np
In[3]: a = np.array([1,2,3])   # 一维数组
In[4]: a
Out[4]: array([1, 2, 3])
In[5]: b = np.array([[1, 2, 3], [4, 5, 6]])  # 二维数组
In[6]: b
Out[6]: 
array([[1, 2, 3],
       [4, 5, 6]])

(2)特殊数组的创建

  1. np.zeros():创建全0数组
In[9]: np.zeros((1,4))
Out[9]: array([[0., 0., 0., 0.]])
  1. np.ones():创建全1数组
In[10]: np.ones((1,4))
Out[10]: array([[1., 1., 1., 1.]])

  1. np.empty():创建全空数组,其实每个值都是接近于0的数
In[15]: np.empty((5, 2))
Out[15]: 
array([[6.95332015e-310, 1.31037034e-311],
       [1.31038381e-311, 0.00000000e+000],
       [0.00000000e+000, 0.00000000e+000],
       [0.00000000e+000, 0.00000000e+000],
       [0.00000000e+000, 0.00000000e+000]])
  1. np.arange():创建等间距数组(包括左端点不包括右端点)
In[16]: np.arange(1,10,3)
Out[16]: array([1, 4, 7])
  1. np.eye(n):生成单位矩阵
In[3]: np.eye(2)
Out[3]: 
array([[1., 0.],
       [0., 1.]])
  1. np.full((m,n),val):生成(m,n)元素值全为val的矩阵
In[83]: b = np.full((2,3),4)
In[84]: b
Out[84]: 
array([[4, 4, 4],
       [4, 4, 4]])
  1. np.zeros_like(a):按照a的形状生成0矩阵
In[6]: np.zeros_like(a)
Out[6]: 
array([[0, 0, 0],
       [0, 0, 0]])
  1. np.ones_like(a):按照a的形状生成1矩阵
In[7]: np.ones_like(a)
Out[7]: 
array([[1, 1, 1],
       [1, 1, 1]])
  1. np.full_like(a, val):按照a的形状生成全val矩阵
In[8]: np.full_like (a, 2)
Out[8]: 
array([[2, 2, 2],
       [2, 2, 2]])

2、数组的索引

(1)单个元素索引

  1. 一维数组的索引
In[17]: a = np.array([1,2,3])
In[18]: a[0]
Out[18]: 1
  1. 二维数组的索引
    从0开始索引
In[22]: b = np.array([[1, 2, 3], [4, 5, 6]])
In[23]: b
Out[23]: 
array([[1, 2, 3],
       [4, 5, 6]])
In[24]: b[1,2]  # 第1行第2列
Out[24]: 6
  1. 数组切片
    从0开始索引,包括左端点,不包括右端点
In[25]: b = np.array([[1, 2, 3], [4, 5, 6]])
In[26]: b
Out[26]: 
array([[1, 2, 3],
       [4, 5, 6]])
In[27]: b[:,0:1]
Out[27]: 
array([[1],
       [4]])
In[28]: b[0:2,0:2]
Out[28]: 
array([[1, 2],
       [4, 5]])

(2)使用数组索引数组

  1. 选取个别元素
In[34]: c = np.arange(35).reshape(5,7)
In[35]: c
Out[35]: 
array([[ 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, 25, 26, 27],
       [28, 29, 30, 31, 32, 33, 34]])
In[36]: c[np.array([0,2,4]), np.array([0,1,2])] 
# 选取0、2、4行,0、1、2列元素
Out[36]: array([ 0, 15, 30])
  1. 数组切片
In[37]: c[np.array([0,2,4]),0:2]
Out[37]: 
array([[ 0,  1],
       [14, 15],
       [28, 29]])

(3)条件索引

In[38]: d = c > 10  # 设置条件,返回bool数组
In[39]: d
Out[39]: 
array([[False, False, False, False, False, False, False],
       [False, False, False, False,  True,  True,  True],
       [ True,  True,  True,  True,  True,  True,  True],
       [ True,  True,  True,  True,  True,  True,  True],
       [ True,  True,  True,  True,  True,  True,  True]])
In[41]: c[d]   # 或者c[c>10]
Out[41]: 
array([11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,28, 29, 30, 31, 32, 33, 34])

3、数组的运算

(1)向量化运算

  1. 加法
In[43]: data1 = np.array([[1, 2, 3], [4, 5, 6]])
In[44]: data2 = np.array([[1, 2, 3], [4, 5, 6]])
In[45]: data1 + data2
Out[45]: 
array([[ 2,  4,  6],
       [ 8, 10, 12]])
  1. 减法
In[47]: data1 - data2
Out[47]: 
array([[0, 0, 0],
       [0, 0, 0]])
  1. 乘法
In[46]: data1 * data2
Out[46]: 
array([[ 1,  4,  9],
       [16, 25, 36]])
  1. 除法
In[48]: data1 / data2
Out[48]: 
array([[1., 1., 1.],
       [1., 1., 1.]])
  1. 幂运算
In[49]: data1 ** data2
Out[49]: 
array([[    1,     4,    27],
       [  256,  3125, 46656]], dtype=int32)
  1. 比较运算
In[51]: data1 > data2
Out[51]: 
array([[False, False, False],
       [False, False, False]])
  1. 逻辑运算(any、all)
    any相当于或运算,all是与运算
In[54]: np.any(data1 > data2)
Out[54]: False
In[55]: np.all(data1 == data2)
Out[55]: True
  1. 点乘运算
    第一个矩阵的列数 == 第二个矩阵的行数
In[59]: a = np.array([[1,2,3],[4,5,6]])
In[60]: b = np.ones((3,4))
In[61]: a.dot(b)
Out[61]: 
array([[ 6.,  6.,  6.,  6.],
       [15., 15., 15., 15.]])

(2)数组的广播

广播是指 numpy 在算术运算期间处理不同形状的数组的能力, 对数组的算术运算通常在相应的元素上进行,通过填充使两个矩阵具有相同的形状,如果两个阵列具有完全相同的形状,则这些操作被无缝执行。

In[62]: arr1 = np.array([[0], [1], [2], [3]])
In[63]: arr1.shape
Out[63]: (4, 1)
In[64]: arr2 = np.array([1, 2, 3])
In[65]: arr2.shape
Out[65]: (3,)
In[66]: arr = arr1 + arr2
In[67]: arr
Out[67]: 
array([[1, 2, 3],
       [2, 3, 4],
       [3, 4, 5],
       [4, 5, 6]])
In[68]: arr.shape
Out[68]: (4, 3)

我们可以通过这幅图去理解numpy的广播机制:
数据挖掘——numpy基础_第1张图片
(图源这篇博客,侵删)

4、array的常用方法

  1. type(arr):查看数组的数据结构
In[69]: type(arr)
Out[69]: numpy.ndarray
  1. arr.dtype:查看数组元素的数据类型
In[70]: arr.dtype
Out[70]: dtype('int32')
  1. arr.ndim:查看数据的维数
In[71]: arr.ndim
Out[71]: 2
  1. arr.shape:行列数
In[68]: arr.shape
Out[68]: (4, 3)
  1. arr.size:数组的元素个数
In[72]: arr.size
Out[72]: 12
  1. arr.reshape((a,b), order = ‘C’):改变数组的形状,注意怎么改变,但是真实形状没变(与resize的区别)
    order : 可选范围为{‘C’, ‘F’, ‘A’}。使用索引顺序读取a的元素,并按照索引顺序将元素放到变换后的的数组中。如果不进行order参数的设置,默认参数为C。
    (1)“C”指的是用类C写的读/索引顺序的元素,最后一个维度变化最快,第一个维度变化最慢。以二维数组为例,简单来讲就是横着读,横着写,优先读/写一行。
    (2)“F”是指用FORTRAN类索引顺序读/写元素,最后一个维度变化最慢,第一个维度变化最快。竖着读,竖着写,优先读/写一列。注意,“C”和“F”选项不考虑底层数组的内存布局,只引用索引的顺序。
    (3)“A”选项所生成的数组的效果与原数组a的数据存储方式有关,如果数据是按照FORTRAN存储的话,它的生成效果与”F“相同,否则与“C”相同。这里可能听起来有点模糊,下面会给出示例。
    原文链接,侵删
In[82]: arr.reshape((1,-1),order = 'F')  # 1行
Out[82]: array([[1, 2, 3, 4, 2, 3, 4, 5, 3, 4, 5, 6]])
In[83]: arr.reshape((-1,1),order = 'F')  # 1列
Out[83]: 
array([[1],
       [2],
       [3],
       [4],
       [2],
       [3],
       [4],
       [5],
       [3],
       [4],
       [5],
       [6]])

  1. astype():数据类型的转换
In[42]: a.astype(np.float)
Out[42]: 
array([[1., 2., 3.],
       [3., 4., 5.]])
  1. arr.tolist():数组向列表转换
In[44]: a.tolist()
Out[44]: [[1, 2, 3], [3, 4, 5]]
  1. arr.cumsum():计算元素的累计和
In[47]: a.cumsum()
Out[47]: array([ 1,  3,  6,  9, 13, 18], dtype=int32)
  1. arr.cumprod():计算元素的累计积
In[48]: a.cumprod()
Out[48]: array([  1,   2,   6,  18,  72, 360], dtype=int32)

三、numpy常用函数

1、数学函数

(1)常用的数学函数

函数 作用
np.fabs() 取绝对值
np.exp() 以e为低的指数
np.modf() 返回小数部分和整数部分
np.power() 求指数
np.log/log2/log10() 以e,2,10为低的对数
np.sum(arr,axis=1/0) 返回行/列求和
np.ceil(a)/np.floor(a) 计算各元素的ceiling 值, floor值(ceiling向上取整,floor向下取整)
np.rint(a) 各元素四舍五入
np.sign(a) 计算各元素的符号值 1(+),0,-1(-)
np.fmax()/np.fmin() 比较元素级的最大(小)值
np.mod(a,b) 元素级的模运算

(2)随机生成数

函数 作用
random.seed(n) 用于改变随机数生成器的种子,不然每次会生成同样的随机数
random.uniform(a,b) 用于生成一个[a,b)范围内的随机浮点数
random.random() 用于生成一个0到1之间的随机浮点数
random.randint(a,b,(x,y)) 用于生成一个[a,b)范围内的(x,y)整数矩阵
random.randrange() 从指定范围内,按指定基数递增的集合中获取一个随机数
random.randn(d0, d1, …, dn) 从标准正态分布中返回array,d0~表示维数
random.rand(d0, d1, …, dn) 的随机样本位于[0, 1)中,d0等是维度

2、数据处理

(1)数据处理常用函数

  1. np.where():条件索引(第二种方式)
array([[1, 2, 3],
       [3, 4, 5]])
In[52]: np.where(a>3)
Out[52]: (array([1, 1], dtype=int64), array([1, 2], dtype=int64))

返回的第一个array表示行坐标,第二个array表示纵坐标,两者一一对应

  1. np.sort(a):排序函数
n[65]: np.sort(a[:,1])
Out[65]: array([2, 4])
In[66]: np.sort(a)
Out[66]: 
array([[1, 2, 3],
       [3, 4, 5]])
  1. np.median(a) : 计算数组a中元素的中位数(中值)
In[67]: np.median(a)
Out[67]: 3.0
  1. np.ptp(a) : 计算数组a最大值和最小值的差
In[68]: np.ptp(a)
Out[68]: 4
  1. np.unique(a):去重函数
In[69]: np.unique(a)
Out[69]: array([1, 2, 3, 4, 5])
  1. np.in1d(a,b):查找函数,得到一个表示a的元素是否包含于b的布尔型数组
In[74]: b = np.array([1,2,4])
In[75]: np.in1d(b,a)
Out[75]: array([ True,  True,  True])
  1. np.setdiff1d(a,b):集合的差,即元素在a中且不在b中
In[76]: np.setdiff1d(a,b)
Out[76]: array([3, 5])
  1. np.intersect1d(a,b):返回两个数组共有的唯一值数组(按值排序)
In[77]: np.intersect1d(a,b)
Out[77]: array([1, 2, 4])
  1. np.setxor1d(a,b):(异或)集合的对称差,即存在于一个数组中但不同时存在于两个数组中的元素
In[78]: np.setxor1d(a,b)
Out[78]: array([3, 5])
  1. np.union1d(a,b):(并)计算a,b的并集,并返回有序数组
In[79]: np.union1d(a,b)
Out[79]: array([1, 2, 3, 4, 5])

  1. p_arr = np.append(p_arr,p) :直接向p_arr里添加p
In[10]: a=np.append(a,10)
In[11]: a
Out[11]: array([ 1,  2,  3, 10])

(2)数组合并

  1. np.vstack([a,b]):垂直方向叠加,要求a列数=b列数,d行数=a行数+b行数,d列数=a列数=b列数
In[88]: a = np.ones((3,4))
In[89]: b = np.full((3,3),4)
In[90]: np.hstack([a,b])
Out[90]: 
array([[1., 1., 1., 1., 4., 4., 4.],
       [1., 1., 1., 1., 4., 4., 4.],
       [1., 1., 1., 1., 4., 4., 4.]])
  1. np.hstack([a,b]):水平方向叠加,要求a行数=b行数,c行数=a行数=b行数,c列数=a列数+b列数
In[91]: a = np.ones((3,4))
In[92]: b = np.full((2,4),3)
In[93]: np.vstack([a,b])
Out[93]: 
array([[1., 1., 1., 1.],
       [1., 1., 1., 1.],
       [1., 1., 1., 1.],
       [3., 3., 3., 3.],
       [3., 3., 3., 3.]])

你可能感兴趣的:(数据挖掘专栏,numpy)