机器学习技术(二)——Python科学运算模块(Numpy、Pandas)
文章目录
- 机器学习技术(二)——Python科学运算模块(Numpy、Pandas)
-
- 一、Numpy
-
- 1、介绍、安装与导入
- 2、Numpy常用操作
- 二、Pandas
-
-
- 1.导入相关依赖库
- 2.创建Series
- 3.创建DataFrame
- 4.查看DataFrame中的数据
- 5.DataFrame数据的操作
- 6.Pandas中缺失数据的操作
-
- 三、总结
一、Numpy
1、介绍、安装与导入
使用NumPy库中的函数实现对数组的基本操作。对一些数据处理方法有所了解,在以后对机器学习实验中与处理数据以及底层代码实现打下基础。
首先使用“pip install 包名”的方式安装实验所需要的库:
pip install numpy
也可以下载相关包的源码文件进行安装。如果实验环境中已存在所需要的库
(使用pip list
可查看已安装的库)则跳过此步骤
(Python中一些库在安装时需要事先安装一些依赖环境,如果使用pip命令安装失败,可以尝试安装依赖的库后再进行安装,或者使用源码安装)
2、Numpy常用操作
导入numpy,使用NumPy库中的方法生成数组,并查看数组的属性。
import numpy as np # 导入库时可以使用as来为为库起别名
np.zeros(shape, dtype=float, order='C')
创建一个形状为shape
的全零数组。dtype
为数据类型。order=C
代表与c语言类似,行优先;order=F
代表列优先
n = np.zeros([2,2]) # 创建一个2*2的全0数组
print(n)
''' 输出[[0. 0.]
[0. 0.]] '''
np.ones(shape, dtype=None, order='C')
创建一个全1数组,和np.zeros()类
m = np.ones([2,2]) # 创建一个2*2的全1数组
print(m)
'''输出[[1. 1.]
[1. 1.]]'''
np.eye(N, M=None, k=0, dtype=float, order='C')
生成一个对角矩阵,N为行数;M为列数,默认和N一样;k为对角线的索引,0代表主对角线。
e = np.eye(2) # 创建一个2X2的对角矩阵
print(e)
'''输出[[1. 0.]
[0. 1.]]'''s
numpy.empty(shape, dtype=float, order='C')
生成一个未初始化的数组。
print(np.empty([3,3]))
''' 输出[[0.00000000e+000 0.00000000e+000 0.00000000e+000]
[0.00000000e+000 0.00000000e+000 1.54148482e-321]
[8.34448956e-308 1.42404727e-306 1.44629801e-307]] '''
numpy.full(shape, fill_value, dtype=None, order='C')
二、Pandas
在Python中对数据进行处理时,经常会使用到Pandas这个库,它提供了诸多的数据处理方法和时间序列的操作方法,是当下最重要的Python 科学运算模块之一,也是提供高性能易用数据类型和分析工具。
1.导入相关依赖库
import pandas as pd
import numpy as np
2.创建Series
Series是Pandas中数据结构之一,它是一种类似于一维数组的对象,由一组数据以及一组与之相关的数据标签(即索引)组成。
- pandas生成Series
pandas.Series(data=None, index=None, dtype=None, name=None, copy=False, fastpath=False)
生成一个Series数据。data为数据可以是数组和字典等;index为索引值,要求与数据长度相同,dtype为数据类型。
s = pd.Series([1,3,5,np.nan,6,8]) # nan 缺失值
print(s)
输出:
0 1.0
1 3.0
2 5.0
3 NaN
4 6.0
5 8.0
dtype: float64
- 通过ndarray创建一个Series
x data = np.array(['a','b','c','d'])s = pd.Series(data)print(s)
输出:
0 a
1 b
2 c
3 d
dtype: object
- 通过字典创建一个Series
字典(dict)可以作为输入传递,如果没有指定索引,则按排序顺序取得字典键以构造索引。 如果传递了索引,索引中与标签对应的数据中的值将被取出。
data1 = {'a' : 0., 'b' : 1., 'c' : 2.}
s = pd.Series(data1)
print(s)
输出:
a 0.0
b 1.0
c 2.0
dtype: float64
3.创建DataFrame
DataFrame 是Pandas中最常用的数据结构,类似于数据库中的表,不过DataFrame不仅仅限制于2维,可以创建多维数据表。DataFrame既有行索引,也有列索引,可以看做是Series组成的字典,每个Series看做DataFrame的一个列。
pandas.date_range(start = None,end = None,periods = None,freq = "D",tz = None,normalize = False,name = None,closed = None,**kwargs )
生成一个时间序列的索引DatetimeIndex。start为日期起点,end为日期终点,periods为个数,freq表示间隔(D表示以日为间隔),tz表示时区。
pandas.DataFrame(data=None, index=None, columns=None,dtype=None,copy=False)
生成一个DataFraem数据。data是数据,index是索引,columns是列名。
dates = pd.date_range('20230703', periods=7)# 生成作为行索引的时间序列
print(dates)
print("--"*16)
df = pd.DataFrame(np.random.randn(7,4), index=dates, columns=list('ABCD'))
print(df)
结果:
DatetimeIndex(['2023-07-03', '2023-07-04', '2023-07-05', '2023-07-06',
'2023-07-07', '2023-07-08', '2023-07-09'],
dtype='datetime64[ns]', freq='D')
--------------------------------
A B C D
2023-07-03 0.363595 0.296730 -1.701725 -0.323202
2023-07-04 0.337387 1.545662 -0.598071 0.399948
2023-07-05 0.561122 -0.244265 1.874373 -0.500115
2023-07-06 -0.045536 -0.440416 0.679049 -0.343199
2023-07-07 -1.767418 0.141762 -3.015787 1.072641
2023-07-08 -1.085728 0.034458 -0.180272 -0.870009
2023-07-09 0.993971 0.589281 -1.142692 1.395541
- 使用字典形式创建DataFrame
输入:
df1 = pd.DataFrame({ 'A' : 1.,
'B' : pd.Timestamp('20190610'), # Timestamp 方法生成时间戳
'C' : pd.Series(1,index=list(range(4)),dtype='float32'),
'D' : np.array([3] * 4,dtype='int32'),
# Categoricals 是 pandas 的一种数据类型,对应着被统计的变量,
# categorical 类型的数据可以具有特定的顺序,这个顺序是创建时手工设定的,是静态的
'E' : pd.Categorical(["test","train","test","train"]),
'F' : 'foo' })
print(df1)
输出:
A B C D E F
0 1.0 2023-07-03 1.0 3 test foo
1 1.0 2023-07-03 1.0 3 train foo
2 1.0 2023-07-03 1.0 3 test foo
3 1.0 2023-07-03 1.0 3 train foo
4.查看DataFrame中的数据
- 查看顶部和底部的数据
接收一个用户输入的分数,然后判断用户所输入的分数属于什么级别。使用Python中的if语句可以完成此功能。
输入:
data2 = np.arange(30).reshape(6,5) # 生成一个维度(6,5)的数组
df2 = pd.DataFrame(data2,index=['a','b','c','d' ,'e' , 'f'] , columns = ['A', 'B', 'C','D','E']) # 创建DataFrame
print(df2)
print("--" * 10)
# DataFrame.head(n=5):显示前n条数据。n表示显示的数据量。
print(df2.head())
print("--" * 10)
# DataFrame.tail(n=5):显示底部数据,和head的参数一样
print(df2.tail(3))
输出:
A B C D E
a 0 1 2 3 4
b 5 6 7 8 9
c 10 11 12 13 14
d 15 16 17 18 19
e 20 21 22 23 24
f 25 26 27 28 29
--------------------
A B C D E
a 0 1 2 3 4
b 5 6 7 8 9
c 10 11 12 13 14
d 15 16 17 18 19
e 20 21 22 23 24
--------------------
A B C D E
d 15 16 17 18 19
e 20 21 22 23 24
f 25 26 27 28 29
- 显示索引,列和数据
输入:
print("index is :" )
print(df2.index) # 输出行索引
print("columns is :" )
print(df2.columns) # 输出列索引
print("values is :" )
print(df2.values) # 输出数据
输出:
index is :
Index(['a', 'b', 'c', 'd', 'e', 'f'], dtype='object')
columns is :
Index(['A', 'B', 'C', 'D', 'E'], dtype='object')
values is :
[[ 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]]
使用loc方法,根据列名对相关索引进行切片,得到想要访问的数据。
# DataFrame.loc:按标签或布尔数组访问一组行和列
print(df2.loc['a':'f':2,'A']) # 获取A列,索引为a到f(包括f)中的数据,步长为2
输出:
a 0
c 10
e 20
Name: A, dtype: int64
- 查看数据的详细信息
DataFrame.describe(percentiles=None, include=None, exclude=None)
生成描述性统计数据,总结数据集分布的集中趋势,分散和形状,不包括 NaN值。
print(df2.describe()) # describe描述了数据的详细信息
输出:
A B C D E
count 6.000000 6.000000 6.000000 6.000000 6.000000
mean 12.500000 13.500000 14.500000 15.500000 16.500000
std 9.354143 9.354143 9.354143 9.354143 9.354143
min 0.000000 1.000000 2.000000 3.000000 4.000000
25% 6.250000 7.250000 8.250000 9.250000 10.250000
50% 12.500000 13.500000 14.500000 15.500000 16.500000
75% 18.750000 19.750000 20.750000 21.750000 22.750000
max 25.000000 26.000000 27.000000 28.000000 29.000000
5.DataFrame数据的操作
- 使用drop方法删除不需要的列或行
DataFrame.drop(labels = None,axis = 0,index = None,columns = None,level = None,inplace = False,errors ='raise' )
通过指定标签名称和相应的轴,或直接指定索引或列名称来删除行或列。labels标签名,axis选择行或列(0表示行,1表示列),index 直接指定要删除的行,columns 直接指定要删除的列,inplace=False,默认该删除操作不改变原数据,而是返回一个执行删除操作后的新DataFrame。
data3 = np.arange(30).reshape(6,5)
df3 = pd.DataFrame(data3,index=['a','b','c','d','e', 'f'] , columns = ['A', 'B', 'C', 'D', 'E'])
a = df3.drop(['a'], axis=0) # axis=0时 删除指定的行
b = df3.drop(['A'], axis=1) # axis=1时,删除指定的列
print('-------原始数据df-----')
print(df3)
print('-------删除行---------')
print(a)
print('-------删除列---------')
print(b)
输出:
-------原始数据df-----
A B C D E
a 0 1 2 3 4
b 5 6 7 8 9
c 10 11 12 13 14
d 15 16 17 18 19
e 20 21 22 23 24
f 25 26 27 28 29
-------删除行---------
A B C D E
b 5 6 7 8 9
c 10 11 12 13 14
d 15 16 17 18 19
e 20 21 22 23 24
f 25 26 27 28 29
-------删除列---------
B C D E
a 1 2 3 4
b 6 7 8 9
c 11 12 13 14
d 16 17 18 19
e 21 22 23 24
f 26 27 28 29
- 使用append方法合并两个DataFrame
DataFrame.append(other,ignore_index = False,verify_integrity = False,sort = None )
将其他行附加到调用者的末尾,返回一个新对象。other为要追加的数据。
c = b.append(a,sort=True)
print(b)
print('------合并后产生的新数据------')
print(c)
输出:
B C D E
a 1 2 3 4
b 6 7 8 9
c 11 12 13 14
d 16 17 18 19
e 21 22 23 24
f 26 27 28 29
------合并后产生的新数据------
A B C D E
a NaN 1 2 3 4
b NaN 6 7 8 9
c NaN 11 12 13 14
d NaN 16 17 18 19
e NaN 21 22 23 24
f NaN 26 27 28 29
b 5.0 6 7 8 9
c 10.0 11 12 13 14
d 15.0 16 17 18 19
e 20.0 21 22 23 24
f 25.0 26 27 28 29
- 使用reset_index方法还原索引,让索引变为数据中的一列
DataFrame.reset_index(level = None,drop = False,inplace = False,col_level = 0,col_fill ='' )
重置索引:level默认为None仅从索引中删除给定的级别,默认情况下删除所有级别。drop表示是否将索引添加至数据成为一列。
b.reset_index(inplace=True)# inplace为true时会修改原始数据,为False会产生新的数据
6.Pandas中缺失数据的操作
- Pandas中缺少的数据默认使用NaN填充
df6 = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])
# 使用reindex方法设置新的索引,多出的索引对应的数据使用NaN填充
df6 = df6.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print(df6)
输出:
one two three
a -1.301964 -0.073759 -0.008598
b NaN NaN NaN
c -0.410554 -0.226690 0.508727
d NaN NaN NaN
e -0.420417 0.264073 -0.232839
f 0.273617 1.037572 0.623791
g NaN NaN NaN
h -0.136863 -0.964579 -0.173560
- 检查是否存在缺失
df7 = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])
df7 = df7.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
# reindex方法可以重置索引,多余的索引会被填充NaN
print(df7['one'].isnull()) # isnull方法可以检查数据中是否有空值
输出:
a False
b True
c False
d True
e False
f False
g True
h False
Name: one, dtype: bool
- 缺失数据的计算
求和数据时,NaN将被视为0,如果数据全部是NaN,那么结果将是NaN。
df8 = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])
df8 = df8.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print(df8)
print(df8['one'].sum())
输出:
one two three
a 2.027398 0.056812 0.472538
b NaN NaN NaN
c 1.569014 -0.449907 2.184448
d NaN NaN NaN
e 0.178915 -0.259276 -0.350310
f -0.880906 0.132635 0.255886
g NaN NaN NaN
h -0.313819 0.464704 1.117843
2.580602384482807
- 用标量替换NaN
DataFrame.fillna(value = None,method = None,axis = None,inplace = False,limit = None,downcast = None,** kwargs )
使用指定的方法和数据填充NA / NaN值。Value表示填充数据,method表示填充方法(‘backfill’,‘bfill’,‘pad’,‘ffill’,None)
df9 = pd.DataFrame(np.random.randn(3, 3), index=['a', 'c', 'e'],columns=['one',
'two', 'three'])
df9 = df9.reindex(['a', 'b', 'c'])
print(df9)
print("NaN replaced with '0':")
print(df9.fillna(0)) # fillna方法可以使用指定数据来填充NaN
输出:
one two three
a -2.171272 -1.143815 -2.022801
b NaN NaN NaN
c 1.041079 0.523148 0.079901
NaN replaced with '0':
one two three
a -2.171272 -1.143815 -2.022801
b 0.000000 0.000000 0.000000
c 1.041079 0.523148 0.079901
- 删除带有NaN的数据
DataFrame.dropna(axis = 0,how ='any',thresh = None,subset = None,inplace = False )
删除缺失值。How表示删除的方式(any:删除存在NA值的行或列;all:删除全部为NA的列或行)
df10 = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f','h'],columns=['one', 'two', 'three'])
df10 = df10.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print(df10)
print("---"*10)
print(df10.dropna())# 丢弃全部值为NaN的行,可以设置参数how=all来删除所有存在NaN值的行
输出:
one two three
a 0.314272 0.359712 -0.384114
b NaN NaN NaN
c 1.105737 1.290604 2.356330
d NaN NaN NaN
e 0.995182 0.150164 1.460220
f 1.691751 2.155625 0.143025
g NaN NaN NaN
h 1.859988 -1.575294 0.063176
------------------------------
one two three
a 0.314272 0.359712 -0.384114
c 1.105737 1.290604 2.356330
e 0.995182 0.150164 1.460220
f 1.691751 2.155625 0.143025
h 1.859988 -1.575294 0.063176
三、总结
系统性地介绍了
1、python科学计算的第三方库NumPy的相关操作。其中包含numpy的导入,numpy中的数据类型,以及numpy中一些简单运算函数的使用等知识。
2、python第三方库Pandas一些基本命令,它提供了诸多的数据处理方法和时间序列的操作方法,也是提供高性能易用数据类型和分析工具。在实验中介绍了DataFrame,Series两种数据结构的常用操作以及关于缺失值的处理。为后期机器学习打基础。
服务器托管,北京服务器托管,服务器租用 http://www.fwqtg.net
缓存更新策略 缓存更新是指在数据发生变化时,保持缓存和数据库的数据一致性的问题。如果缓存和数据库的数据不一致,会导致用户看到过期或者错误的数据,影响业务逻辑和用户体验。 为了实现缓存更新,我们可以采用以下四种方式: Cache Aside策略:应用程序直接与数…