数据挖掘——numpy基础
前言：python数据挖掘numpy的基础知识，参考网上资料和博客进行简单总结，主要是为了方便自己写代码的时候查看，发现有用的方法，随时补充，欢迎指正
数据挖掘专栏
- 数据挖掘——python基础
- 数据挖掘——numpy基础
- 数据挖掘——pandas基础
- 数据挖掘——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）特殊数组的创建
- np.zeros()：创建全0数组
In[9]: np.zeros((1,4))
Out[9]: array([[0., 0., 0., 0.]])
- np.ones()：创建全1数组
In[10]: np.ones((1,4))
Out[10]: array([[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]])
- np.arange()：创建等间距数组（包括左端点不包括右端点）
In[16]: np.arange(1,10,3)
Out[16]: array([1, 4, 7])
- np.eye(n)：生成单位矩阵
In[3]: np.eye(2)
Out[3]:
array([[1., 0.],
[0., 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]])
- np.zeros_like(a)：按照a的形状生成0矩阵
In[6]: np.zeros_like(a)
Out[6]:
array([[0, 0, 0],
[0, 0, 0]])
- np.ones_like(a)：按照a的形状生成1矩阵
In[7]: np.ones_like(a)
Out[7]:
array([[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）单个元素索引
- 一维数组的索引
In[17]: a = np.array([1,2,3])
In[18]: a[0]
Out[18]: 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
- 数组切片
从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）使用数组索引数组
- 选取个别元素
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])
- 数组切片
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）向量化运算
- 加法
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]])
- 减法
In[47]: data1 - data2
Out[47]:
array([[0, 0, 0],
[0, 0, 0]])
- 乘法
In[46]: data1 * data2
Out[46]:
array([[ 1, 4, 9],
[16, 25, 36]])
- 除法
In[48]: data1 / data2
Out[48]:
array([[1., 1., 1.],
[1., 1., 1.]])
- 幂运算
In[49]: data1 ** data2
Out[49]:
array([[ 1, 4, 27],
[ 256, 3125, 46656]], dtype=int32)
- 比较运算
In[51]: data1 > data2
Out[51]:
array([[False, False, False],
[False, False, False]])
- 逻辑运算（any、all）
any相当于或运算，all是与运算
In[54]: np.any(data1 > data2)
Out[54]: False
In[55]: np.all(data1 == data2)
Out[55]: True
- 点乘运算
第一个矩阵的列数 == 第二个矩阵的行数
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的广播机制：
（图源这篇博客，侵删）
4、array的常用方法
- type(arr)：查看数组的数据结构
In[69]: type(arr)
Out[69]: numpy.ndarray
- arr.dtype：查看数组元素的数据类型
In[70]: arr.dtype
Out[70]: dtype('int32')
- arr.ndim：查看数据的维数
In[71]: arr.ndim
Out[71]: 2
- arr.shape：行列数
In[68]: arr.shape
Out[68]: (4, 3)
- arr.size：数组的元素个数
In[72]: arr.size
Out[72]: 12
- 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]])
- astype()：数据类型的转换
In[42]: a.astype(np.float)
Out[42]:
array([[1., 2., 3.],
[3., 4., 5.]])
- arr.tolist()：数组向列表转换
In[44]: a.tolist()
Out[44]: [[1, 2, 3], [3, 4, 5]]
- arr.cumsum()：计算元素的累计和
In[47]: a.cumsum()
Out[47]: array([ 1, 3, 6, 9, 13, 18], dtype=int32)
- 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）数据处理常用函数
- 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表示纵坐标，两者一一对应
- 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]])
- np.median(a) : 计算数组a中元素的中位数（中值）
In[67]: np.median(a)
Out[67]: 3.0
- np.ptp(a) : 计算数组a最大值和最小值的差
In[68]: np.ptp(a)
Out[68]: 4
- np.unique(a)：去重函数
In[69]: np.unique(a)
Out[69]: array([1, 2, 3, 4, 5])
- 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])
- np.setdiff1d(a,b)：集合的差，即元素在a中且不在b中
In[76]: np.setdiff1d(a,b)
Out[76]: array([3, 5])
- np.intersect1d(a,b)：返回两个数组共有的唯一值数组(按值排序)
In[77]: np.intersect1d(a,b)
Out[77]: array([1, 2, 4])
- np.setxor1d(a,b)：(异或)集合的对称差，即存在于一个数组中但不同时存在于两个数组中的元素
In[78]: np.setxor1d(a,b)
Out[78]: array([3, 5])
- np.union1d(a,b)：(并)计算a，b的并集，并返回有序数组
In[79]: np.union1d(a,b)
Out[79]: array([1, 2, 3, 4, 5])
- 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）数组合并
- 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.]])
- 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.]])