文章目录
pandas简介
pandas是基于numpy的一种工具，该工具是为了解决数据分析任务而创建的。pandas纳入了大量库和一些标准的数据模型，提高了高效的操作大型数据所需的工具，pandas提供了大量能使我们快速便捷处理数据的函数和方法。
在使用第三方库之前需要先进行导包：import pandas as pd这里对其取别名为pd。
pandas基本数据结构
Series
一维数组，与numpy中的一维array类似，Series只能保存同一种的数据类型，如填入不同的数据类型则dtype会变成Object。
使用list初始化Series
使用list初始化一个Series：
# 使用列表初始化一个Series
s = pd.Series([1, 2, 3, 'hello'])
print(s)
输出：
0 1
1 2
2 3
3 hello
dtype: object
注意：输出的第一列是Series中数据的索引。
自定义Series索引
初始化时使用默认值参数index自定义索引：
# 使用index自定义索引
s = pd.Series([1, 2, 3, 'hello'], index = ['a', 'b', 'c', 'd'])
print(s)
输出：
a 1
b 2
c 3
d hello
dtype: object
获取索引和数据
使用index属性获取Series的索引，使用values获取Series的数据：
s = pd.Series([1, 2, 3, 'hello'], index = ['a', 'b', 'c', 'd'])
# 获取索引
print(s.index)
# 获取值
print(s.values)
输出：
Index(['a', 'b', 'c', 'd'], dtype='object')
[1 2 3 'hello']
Series切片
首先初始化一个Series方便测试：
s = pd.Series([1, 2, 3, 'hello'], index = ['a', 'b', 'c', 'd'])
注意：Series切片使用引用机制，不会分配内存。容易导致原数据发生改变，可以根据需求进行深拷贝。
当使用默认索引时切片方式与list一致，这里着重说明自定义索引时的情况。
自定义索引时切片是左闭右闭的（非自定义左闭右开），其它均一致。
使用自定义索引切片：
# 注意区间为['a', 'd']
print(s['a':'d'])
# 反向切
print(s['d':'a':-1])
输出：
a 1
b 2
c 3
d hello
dtype: object
d hello
c 3
b 2
a 1
dtype: object
并且，设置了自定义索引也可以使用默认索引，此时切片是左闭右开的。
使用默认索引切片：
# 注意区间为[0, 4）
print(s[0:4])
# 反向切
print(s[-1::-1])
输出：
a 1
b 2
c 3
d hello
dtype: object
d hello
c 3
b 2
a 1
dtype: object
DataFrame
二维表格型数据结构。类似于数据库中的表，每一行是一个实体，每一列是一种属性。列与列之间的数据类型可以不同。
可以将DataFrame理解为Series的容器，其中每一个Series按列排放，即每一个Series是一种属性。
索引和列名
默认值参数index用于指定行索引（实体索引），默认值参数columns用于指定属性名（每一列的列名）。不指定索引和列名时默认均为从0开始的序列。
通常使用时间序列作为行索引（也可以自定义），使用date_range(起始日期字符串, periods = n)来生成以其实日期为开始，共n个日期的时间序列。
通常使用字符串作为列名。
使用传入二维列表（也可以是二维数组）的方式创建DateFrame：
# 生成行索引
idx = pd.date_range('20220101', periods = 2)
# 使用传入二维列表的方式生成DateFrame，并指定index和columns
df = pd.DataFrame([['智子', '男', 18, '34567'],
['张三', '男', 21, '33333']], index = idx, columns = ['姓名', '性别', '年龄' , 'ID'])
print(df)
输出：
姓名 性别 年龄 ID
2022-01-01 智子 男 18 34567
2022-01-02 张三 男 21 33333
创建DataFrame
a.通过传入二维列表创建DataFrame
col = ['姓名', '性别', '年龄' , 'ID']
# 传入二维列表
df = pd.DataFrame([['智子', '男', 18, '34567'],
['张三', '男', 21, '33333']], columns = col)
print(df)
b.通过传入二维数组创建DataFrame
col = ['姓名', '性别', '年龄' , 'ID']
# 传入二维数组
data = np.array([['智子', '男', 18, '34567'],
['张三', '男', 21, '33333']])
df = pd.DataFrame(data, columns = col)
print(df)
c.通过传入字典创建DataFrame。
注意：使用这种方式创建DataFrame会以字典的Key值作为列名。如果字典的value值非Series，并且行数大于1时（即有多个数据对象）会重复value值以填充表格。
# 字典 + Series
df = pd.DataFrame({'姓名':pd.Series(['智子', '张三']),
'性别' : '男',
'年龄' : pd.Series([18, 21]),
'ID' : pd.Series(['34567', '33333'])})
print(df)
上面几段代码输出均为：
姓名 性别 年龄 ID
0 智子 男 18 34567
1 张三 男 21 33333
查看数据
首先生成一个DataFrame数据以备测试：
df = pd.DataFrame({'姓名':pd.Series(['智子', '张三', '小红', '王五', '路人甲', '流氓丙']),
'性别' : pd.Series(['男', '男', '女', '男', '男', '男']),
'年龄' : pd.Series([18, 21, 17, 19, 24, 55]),
'ID' : pd.Series(['34567', '33333', '12323', '43524', '77777', '89798'])})
头尾数据
使用head()和tail()方法查看DataFrame数据（默认查看前/后五行）：
# 使用head()
print(df.head())
# 使用tail(), 传入参数3只查看后三行
print(df.tail(3))
输出：
姓名 性别 年龄 ID
0 智子 男 18 34567
1 张三 男 21 33333
2 小红 女 17 12323
3 王五 男 19 43524
4 路人甲 男 24 77777
姓名 性别 年龄 ID
3 王五 男 19 43524
4 路人甲 男 24 77777
5 流氓丙 男 55 89798
查看列数据类型
使用dtypes属性查看每一列的数据类型：
print(df.dtypes)
输出：
姓名 object
性别 object
年龄 int64
ID object
dtype: object
下标、列标和数据
分别使用index、columns和values查看DataFrame的下标、列标和数据：
# 下标
print(df.index)
# 列标
print(df.columns)
# 数据 返回值为列表，方便操作数据
print(df.values)
输出：
RangeIndex(start=0, stop=6, step=1)
Index(['姓名', '性别', '年龄', 'ID'], dtype='object')
[['智子' '男' 18 '34567']
['张三' '男' 21 '33333']
['小红' '女' 17 '12323']
['王五' '男' 19 '43524']
['路人甲' '男' 24 '77777']
['流氓丙' '男' 55 '89798']]
pandas读取数据及数据操作
以鸢尾花iris.xlsx数据（150
×
\times
× 5的excel数据集）测试pandas读取数据及数据操作。
读入数据
使用read_excel('文件路径')读入excel数据。返回一个DataFrame数据：
如果excel文件里有多张表格，可以使用sheet_name默认值参数（默认为0，即第一张表格）改变表格。例如，sheet_name = 1表示修改为第二张表格。
# 文件在E盘的根目录下
df = pd.read_excel('E:\iris.xlsx')
print(df)
输出（文件的整体预览）：
萼片长度 萼片宽度 花瓣长度 花瓣宽度 品种
0 5.1 3.5 1.4 0.2 setosa
1 4.9 3.0 1.4 0.2 setosa
2 4.7 3.2 1.3 0.2 setosa
3 4.6 3.1 1.5 0.2 setosa
4 5.0 3.6 1.4 0.2 setosa
.. ... ... ... ... ...
145 6.7 3.0 5.2 2.3 virginica
146 6.3 2.5 5.0 1.9 virginica
147 6.5 3.0 5.2 2.0 virginica
148 6.2 3.4 5.4 2.3 virginica
149 5.9 3.0 5.1 1.8 virginica
[150 rows x 5 columns]
数据操作
将DataFrame数据转化为List
使用values属性，获取DataFrame中的数据返回值为一个二维列表：
print(df.values)
数据量太多手动去掉一部分数据：
[[5.1 3.5 1.4 0.2 'setosa']
[4.9 3.0 1.4 0.2 'setosa']
[4.7 3.2 1.3 0.2 'setosa']
[4.6 3.1 1.5 0.2 'setosa']
...
[6.3 2.5 5.0 1.9 'virginica']
[6.5 3.0 5.2 2.0 'virginica']
[6.2 3.4 5.4 2.3 'virginica']
[5.9 3.0 5.1 1.8 'virginica']]
行数据操作（查、增和删）
a.使用库函数len()查看行数
print(len(df)) # 输出：150
b.使用iloc获取指定行
# 同列表，下标从0开始
print(df.iloc[3])
输出（一个DataFrame对象）：
萼片长度 4.6
萼片宽度 3.4
花瓣长度 1.4
花瓣宽度 0.3
品种 setosa
Name: 6, dtype: object
c.使用iloc和loc切片。
注意：iloc切片区间是左闭右开的，而loc区间是左右均闭的。
# iloc切片 范围[4, 9)
print(df.iloc[4 : 9])
# loc切片 范围[4, 9]
print(df.loc[4 : 9])
输出：
萼片长度 萼片宽度 花瓣长度 花瓣宽度 品种
4 5.0 3.6 1.4 0.2 setosa
5 5.4 3.9 1.7 0.4 setosa
6 4.6 3.4 1.4 0.3 setosa
7 5.0 3.4 1.5 0.2 setosa
8 4.4 2.9 1.4 0.2 setosa
萼片长度 萼片宽度 花瓣长度 花瓣宽度 品种
4 5.0 3.6 1.4 0.2 setosa
5 5.4 3.9 1.7 0.4 setosa
6 4.6 3.4 1.4 0.3 setosa
7 5.0 3.4 1.5 0.2 setosa
8 4.4 2.9 1.4 0.2 setosa
9 4.9 3.1 1.5 0.1 setosa
d.添加行
首先，使用字典的方式生成一行数据，并使用字典来初始化Series。注意字典的key值与列名一致：
dic = {'萼片长度': 6, '萼片宽度': 3, '花瓣长度': 5, '花瓣宽度': 2, '品种':'virginica'}
# 初始化Series
s = pd.Series(dic)
然后，使用apped末尾追加数据。append会返回一个追加后的DataFrame，将其赋值给原数据以改变原数据：
# 单独的一个Series是不能直接append的
## 需要让单独的Series有一个名字
s.name = 150
# 赋值给原数据
df = df.append(s)
print(df)
输出追加后的数据：
萼片长度 萼片宽度 花瓣长度 花瓣宽度 品种
0 5.1 3.5 1.4 0.2 setosa
1 4.9 3.0 1.4 0.2 setosa
2 4.7 3.2 1.3 0.2 setosa
3 4.6 3.1 1.5 0.2 setosa
4 5.0 3.6 1.4 0.2 setosa
.. ... ... ... ... ...
146 6.3 2.5 5.0 1.9 virginica
147 6.5 3.0 5.2 2.0 virginica
148 6.2 3.4 5.4 2.3 virginica
149 5.9 3.0 5.1 1.8 virginica
150 6.0 3.0 5.0 2.0 virginica
[151 rows x 5 columns]
e.删除行
使用drop()删除指定行，同样会返回一个删除后的DataFrame，要改变原数据需要进行赋值（可以设置默认值参数inplace = True直接修改原数据）：
# 删除索引为150那一行
print(df.drop([150]))
# 原数据修改
# df.drop([150], inplace = True)
输出删除后的序列：
萼片长度 萼片宽度 花瓣长度 花瓣宽度 品种
0 5.1 3.5 1.4 0.2 setosa
1 4.9 3.0 1.4 0.2 setosa
2 4.7 3.2 1.3 0.2 setosa
3 4.6 3.1 1.5 0.2 setosa
4 5.0 3.6 1.4 0.2 setosa
.. ... ... ... ... ...
145 6.7 3.0 5.2 2.3 virginica
146 6.3 2.5 5.0 1.9 virginica
147 6.5 3.0 5.2 2.0 virginica
148 6.2 3.4 5.4 2.3 virginica
149 5.9 3.0 5.1 1.8 virginica
[150 rows x 5 columns]
列数据操作（查、增和删）
a.使用columns属性获取所有列名：
print(df.columns)
输出：
Index(['萼片长度', '萼片宽度', '花瓣长度', '花瓣宽度', '品种'], dtype='object')
b.获取指定列（单列）
# 通过列名获取指定列
print(df['萼片长度'])
# 对获取的列数据进行切片
print(df['萼片长度'][::2])
输出：
0 5.1
1 4.9
2 4.7
3 4.6
4 5.0
...
145 6.7
146 6.3
147 6.5
148 6.2
149 5.9
Name: 萼片长度, Length: 150, dtype: float64
0 5.1
2 4.7
4 5.0
6 4.6
8 4.4
...
140 6.7
142 5.8
144 6.7
146 6.3
148 6.2
Name: 萼片长度, Length: 75, dtype: float64
c.获取指定列（多列）
# 通过列表获取指定多列
print(df[['萼片长度', '品种']])
# 多列数据同样可以切片
print(df[['萼片长度', '品种']][::2])
输出：
萼片长度 品种
0 5.1 setosa
1 4.9 setosa
2 4.7 setosa
3 4.6 setosa
4 5.0 setosa
.. ... ...
145 6.7 virginica
146 6.3 virginica
147 6.5 virginica
148 6.2 virginica
149 5.9 virginica
[150 rows x 2 columns]
萼片长度 品种
0 5.1 setosa
2 4.7 setosa
4 5.0 setosa
6 4.6 setosa
8 4.4 setosa
.. ... ...
140 6.7 virginica
142 5.8 virginica
144 6.7 virginica
146 6.3 virginica
148 6.2 virginica
[75 rows x 2 columns]
d.增加一列
通过直接赋值的方式增加一列，该操作直接改变原来的DataFrame。
df['数量'] = pd.Series([np.random.randint(40, 80) for _ in range(150)])
print(df)
输出：
萼片长度 萼片宽度 花瓣长度 花瓣宽度 品种 数量
0 5.1 3.5 1.4 0.2 setosa 74
1 4.9 3.0 1.4 0.2 setosa 78
2 4.7 3.2 1.3 0.2 setosa 62
3 4.6 3.1 1.5 0.2 setosa 56
4 5.0 3.6 1.4 0.2 setosa 53
.. ... ... ... ... ... ..
145 6.7 3.0 5.2 2.3 virginica 59
146 6.3 2.5 5.0 1.9 virginica 47
147 6.5 3.0 5.2 2.0 virginica 47
148 6.2 3.4 5.4 2.3 virginica 53
149 5.9 3.0 5.1 1.8 virginica 78
[150 rows x 6 columns]
e.删除一列
使用drop('列名', axis = 1)删除指定列，同样会返回一个删除后的DataFrame，要改变原数据需要进行赋值（可以设置默认值参数inplace = True直接修改原数据）：
# 删除列名为'数量'那一列
df = df.drop('数量', axis = 1)
print(df)
# 原数据修改，不用赋值
# df.drop('数量', axis = 1, inplace = True)
输出：
萼片长度 萼片宽度 花瓣长度 花瓣宽度 品种
0 5.1 3.5 1.4 0.2 setosa
1 4.9 3.0 1.4 0.2 setosa
2 4.7 3.2 1.3 0.2 setosa
3 4.6 3.1 1.5 0.2 setosa
4 5.0 3.6 1.4 0.2 setosa
.. ... ... ... ... ...
145 6.7 3.0 5.2 2.3 virginica
146 6.3 2.5 5.0 1.9 virginica
147 6.5 3.0 5.2 2.0 virginica
148 6.2 3.4 5.4 2.3 virginica
149 5.9 3.0 5.1 1.8 virginica
[150 rows x 5 columns]
取出指定行和列的元素
(1)使用loc[索引, '列名']取出指定行和列的元素，取出的单元格可以进行赋值：
# 取出单元格中的数据（指定行和列）
## 取出索引为3的实体的品种
print(df.loc[3, '品种'])
输出：
setosa
(2)使用loc[[索引1,索引2,...,索引n], ['列名1','列2',...,'列名n']]取出指定多行和多列的元素：
# 取出指定多行多列元素
print(df.loc[[1, 51, 149], ['花瓣长度', '品种']])
输出：
花瓣长度 品种
1 1.4 setosa
51 4.5 versicolor
149 5.1 virginica
条件筛选数据
使用直接书写条件语句的方式，筛选数据。其原理是：条件语句会返回一个bool数组，利用数组索引的方式取出筛选的数据。
注意：条件语句只能使用&、|和~。
# 取出花瓣长小于2.0且品种名为virginica的鸢尾花
# 对取出的数据仍然可以切片（数据量过多，只截取前5行）
print(df[(df.花瓣宽度 < 2.0) & (df.品种 == 'virginica')][:5])
输出：
萼片长度 萼片宽度 花瓣长度 花瓣宽度 品种
101 5.8 2.7 5.1 1.9 virginica
103 6.3 2.9 5.6 1.8 virginica
106 4.9 2.5 4.5 1.7 virginica
107 7.3 2.9 6.3 1.8 virginica
108 6.7 2.5 5.8 1.8 virginica
修改列数据数据类型
(1)获取列数据类型：
# 获取列数据类型
print(df.dtypes)
输出：
萼片长度 float64
萼片宽度 float64
花瓣长度 float64
花瓣宽度 float64
品种 object
dtype: object
(2)使用astype()修改列数据类型。注意：存在异常值时可能无法进行强制类型转换，可以预处理删除或修改异常值。
# 获取列指定数据类型
print(df['萼片长度'].dtype)
# 修改萼片长度列数据类型为int
df['萼片长度'] = df['萼片长度'].astype('int')
# 打印修改后
print(df['萼片长度'].dtype)
输出：
float64
int32
统计每种数据个数
使用value_counts()统计每种数据出现次数。
注意：默认按照数量多少降序排列。
# 统计不同品种数
print(df['品种'].value_counts())
输出：
山鸢尾 50
多色鸢尾 50
锦葵 50
Name: 品种, dtype: int64
数据替换
使用replace(from_data, to_data)进行数据替换。同样地，可以使用inplace = True设置直接在原数据上进行替换。
a.单个值替换
# 替换setosa为山鸢尾
df['品种'].replace('setosa', '山鸢尾', inplace = True)
print(df[:5])
输出：
萼片长度 萼片宽度 花瓣长度 花瓣宽度 品种
0 5.1 3.5 1.4 0.2 山鸢尾
1 4.9 3.0 1.4 0.2 山鸢尾
2 4.7 3.2 1.3 0.2 山鸢尾
3 4.6 3.1 1.5 0.2 山鸢尾
4 5.0 3.6 1.4 0.2 山鸢尾
b.多值替换
# 替换多个值 使用列表一一对应from_data和to_data
# 替换versicolor为多色鸢尾；替换virginica为锦葵
df['品种'].replace(['versicolor', 'virginica'], ['多色鸢尾', '锦葵'], inplace = True)
print(df.iloc[0].values, df.iloc[50].values, df.iloc[100].values, sep = '\n')
输出：
[5.1 3.5 1.4 0.2 '山鸢尾']
[7.0 3.2 4.7 1.4 '多色鸢尾']
[6.3 3.3 6.0 2.5 '锦葵']
数据透视表
数据透视表：固定一个或多个属性，并对其它数值型数据进行分析汇总的一张表格。相当于使用一个或多个属性对原数据进行分组，然后对每个分组进行数据分析。
例如，使用’品种‘进行分组，并统计每一分组’萼片长度’的均值，和’花瓣长度‘的中位数：
# 数据透视表 返回值为DataFrame
tb = pd.pivot_table(df, index = ['品种'], values = ['萼片长度', '花瓣长度'], aggfunc = {'萼片长度' : np.mean, '花瓣长度' : np.median}, fill_value = 0)
print(tb)
输出：
花瓣长度 萼片长度
品种
setosa 1.50 5.006
versicolor 4.35 5.936
virginica 5.55 6.588
其中有几个需要解释的参数：
index：可以向其中传入多个属性，用以分组
values: 传入需要分析的数据名
aggfunc: 可以向字典中传入需要分析的数据名和对应的分析函数
fill_value = 0: 设置当存在缺失值或异常值时使用0来填充
margins = True: 默认为False，设置对最终数据进行整体（每一列）分析
数据排序
排序中几个比较重要的参数：
inplace默认值为False，为True时表示直接操作原数据
ascending默认为True表示升序排序，为False时表示降序排序
key编辑排序规则，通常使用Lambda设置排序规则
a.按属性（列）排序：
# 按照鸢尾花花瓣宽度排序
print(df.sort_values(by = '花瓣宽度'))
输出：
萼片长度 萼片宽度 花瓣长度 花瓣宽度 品种
32 5.2 4.1 1.5 0.1 setosa
13 4.3 3.0 1.1 0.1 setosa
37 4.9 3.1 1.5 0.1 setosa
9 4.9 3.1 1.5 0.1 setosa
12 4.8 3.0 1.4 0.1 setosa
.. ... ... ... ... ...
140 6.7 3.1 5.6 2.4 virginica
114 5.8 2.8 5.1 2.4 virginica
100 6.3 3.3 6.0 2.5 virginica
144 6.7 3.3 5.7 2.5 virginica
109 7.2 3.6 6.1 2.5 virginica
[150 rows x 5 columns]
b.多字段排序，即第一属性（列）相同时使用第二属性（列）排序：
# 按照鸢尾花 花瓣宽度和萼片长度 排序
# ascending设置第一字段升序，第二字段降序
print(df.sort_values(by = ['花瓣宽度', '萼片长度'], ascending = [True, False]))
输出：
萼片长度 萼片宽度 花瓣长度 花瓣宽度 品种
32 5.2 4.1 1.5 0.1 setosa
9 4.9 3.1 1.5 0.1 setosa
34 4.9 3.1 1.5 0.1 setosa
37 4.9 3.1 1.5 0.1 setosa
12 4.8 3.0 1.4 0.1 setosa
.. ... ... ... ... ...
136 6.3 3.4 5.6 2.4 virginica
114 5.8 2.8 5.1 2.4 virginica
109 7.2 3.6 6.1 2.5 virginica
144 6.7 3.3 5.7 2.5 virginica
100 6.3 3.3 6.0 2.5 virginica
[150 rows x 5 columns]
描述性统计
使用describe()输出DataFrame中数值型数据的描述性统计：
print(df.describe())
输出：
萼片长度 萼片宽度 花瓣长度 花瓣宽度
count 150.000000 150.000000 150.000000 150.000000
mean 5.843333 3.054000 3.758667 1.198667
std 0.828066 0.433594 1.764420 0.763161
min 4.300000 2.000000 1.000000 0.100000
25% 5.100000 2.800000 1.600000 0.300000
50% 5.800000 3.000000 4.350000 1.300000
75% 6.400000 3.300000 5.100000 1.800000
max 7.900000 4.400000 6.900000 2.500000
常用统计性函数
a.最值
# 最大值
print(df['萼片宽度'].max()) # 输出：4.4
# 最小值
print(df['萼片宽度'].min()) # 输出：2.0
b.均值和中位数
# 均值
print(df['萼片宽度'].mean()) # 输出：3.0540000000000007
# 中位数
print(df['萼片宽度'].median()) # 输出：3.0
c.方差和标准差
# 方差
print(df['萼片宽度'].var()) # 输出：0.18800402684563763
# 标准差
print(df['萼片宽度'].std()) # 输出：0.4335943113621737
d.求和
# 求和
print(df['萼片宽度'].sum()) # 输出：458.1
e.统计去重后的所有元素
# 统计所有品种
print(df['品种'].unique())
输出：
['setosa' 'versicolor' 'virginica']
f.相关系数协方差
相关系数：
# 相关系数
print(df[['萼片宽度','花瓣长度']].corr())
输出：
萼片宽度 花瓣长度
萼片宽度 1.000000 -0.420516
花瓣长度 -0.420516 1.000000
协方差：
# 协方差
print(df[['萼片宽度','花瓣长度']].cov())
输出：
萼片宽度 花瓣长度
萼片宽度 0.188004 -0.321713
花瓣长度 -0.321713 3.113179
pandas缺失值和异常值处理
首先，插入一行缺失值以供测试（np.nan为numpy的属性，即空值）：
dic = {'萼片长度': np.nan, '萼片宽度': 3, '花瓣长度': 5, '花瓣宽度': np.nan, '品种':np.nan}
# 初始化Series
s = pd.Series(dic)
s.name = 150
# 赋值给原数据
df = df.append(s)
查找缺失值
使用isnull()查找缺失值。返回值为bool数组，可以用来取下标：
# 查找全体缺失值
print(df.isnull())
# 查找指定列的缺失值
print(df['花瓣宽度'].isnull())
输出：
萼片长度 萼片宽度 花瓣长度 花瓣宽度 品种
0 False False False False False
1 False False False False False
2 False False False False False
3 False False False False False
4 False False False False False
.. ... ... ... ... ...
146 False False False False False
147 False False False False False
148 False False False False False
149 False False False False False
150 True False False True True
[151 rows x 5 columns]
0 False
1 False
2 False
3 False
4 False
...
146 False
147 False
148 False
149 False
150 True
Name: 花瓣长度, Length: 151, dtype: bool
填充缺失值
使用fillna()填充缺失值。令位置参数inplace = True表示直接在原数据集上修改，不设置的话会返回一个新的DataFrame。
a.填充数值型数据：
# 填充缺失值
# 这里使用均值进行填充
df['花瓣宽度'].fillna(np.mean(df['花瓣宽度']), inplace = True)
print(df.loc[150, '花瓣宽度'])
输出：
1.1986666666666672
b.填充字符型数据：
# 这里使用字符串进行填充
df['品种'].fillna('未知品种', inplace = True)
print(df.loc[150, '品种'])
输出：
未知品种
删除缺失值
使用dropna()删除缺失值。
几个比较重要的默认值参数：
how = 'all'删除全为空值的行或列
inplace在原数据集上直接修改
axis = 0选择删除行或列默认为0，即删除行
# 输出删除前数据集长度
print(len(df))
# 删除含空值的行
df.dropna(axis = 0, inplace = True)
# 输出删除后数据集长度
print(len(df))
输出：
151
150
数据保存
使用to_excel('路径')将DataFrame数据进行保存：
df.to_excel('E:/df.xlsx')
在E盘的根目录下就可以找到数据了
6471
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
