数据挖掘——numpy基础

最新推荐文章于 2022-02-26 01:16:33 发布

Tao_RY

最新推荐文章于 2022-02-26 01:16:33 发布

阅读量385

点赞数 1

分类专栏：数据分析专栏文章标签： numpy

本文链接：https://blog.csdn.net/weixin_43008804/article/details/101473747

版权

数据分析专栏专栏收录该内容

16 篇文章 7 订阅

订阅专栏

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

数据挖掘专栏

一、认识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.]])

Tao_RY

关注

1
点赞
踩
4

收藏

觉得还不错? 一键收藏
打赏
0
评论
数据挖掘——numpy基础

前言：python数据挖掘numpy的基础知识，参考网上资料和博客进行简单总结，主要是为了方便自己写代码的时候查看，发现有用的方法，随时补充，欢迎指正数据挖掘专栏数据挖掘——python基础数据挖掘——numpy基础数据挖掘——pandas基础数据挖掘——pandas+matplotlib+seaborn数据可视化numpy基础一、认识numpy二、numpy数组对象（ndarr...
复制链接

扫一扫