机器学习技术（二）——Python科学运算模块（Numpy、Pandas）
机器学习技术（二）——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两种数据结构的常用操作以及关于缺失值的处理。为后期机器学习打基础。