Python中的第三方库（Pandas）
目录
1 引入
2 安装
3 内置数据结构
4 Series
4.1 创建Series对象
4.1.1 创建Series空对象
4.1.2 ndarry创建Series对象
4.1.3 字典创建Series对象
4.2 访问Series数据
4.3 Series遍历
4.3.1 使用items()
4.3.2 使用index属性
4.3.3 使用values属性
4.4 Series常用方法
5 DataFrame
5.1 创建DataFrame对象
5.1.1 创建DataFrame空对象
5.1.2 列表嵌套字典创建DataFrame对象
5.1.3字典嵌套列表创建DataFrame对象
5.1.4 Series创建DataFrame对象
5.2 列索引操作
5.2.1 选取数据
5.2.2 添加数据
5.2.3 修改数据
5.2.4 删除数据
5.3 行索引操作
5.3.1 loc选取数据
5.3.2 iloc选取数据
5.3.3 切片多行选取
5.3.4 添加数据行
5.3.5 删除数据行
6 函数
6.1 常用的统计学函数
6.2 重置索引
6.3 遍历
6.3.1 遍历行
6.3.2 遍历列
6.3.3 使用属性遍历
6.4 排序
6.4.1 sort_index
6.4.2 sort_values
6.5 去重
6.6 分组
6.6.1 groupby
6.6.2 filter
6.7 合并
6.8 随机抽样
6.9 空值处理
6.9.1 检测空值
6.9.2 填充空值
6.9.3 删除空值
7 读取CSV文件
7.2 read_csv()
8 绘图
1 引入
Pandas 是一个开源的第三方 Python 库，从 Numpy 和 Matplotlib 的基础上构建而来
2 安装
pip install pandas -i https://pypi.tuna.tsinghua.edu.cn/simple/3 内置数据结构
| 数据结构 | 维度 | 说明 |
|---|---|---|
| Series | 1 | 该结构能够存储各种数据类型，比如字符数、整数、浮点数、Python 对象等，Series 用 name 和 index 属性来描述数据值。Series 是一维数据结构，因此其维数不可以改变 |
| DataFrame | 2 | DataFrame 是一种二维表格型数据的结构，既有行索引，也有列索引。行索引是 index，列索引是 columns。 在创建该结构时，可以指定相应的索引值 |
4 Series
| 函数名 | 参数 |
|---|---|
| pandas.Series(data,index,dtype,copy) | data：一组数据（ndarray 类型） index：数据索引标签，如果不指定，默认从 0 开始 dtype：数据类型，默认会自己判断 copy：表示对 data 进行拷贝，默认为 False |
结构图：
- 0、1、2 表示行索引
- 李四、王五、张三表示数据值
- dtype 表示数据值的类型
4.1 创建Series对象
4.1.1 创建Series空对象
案例：
# 创建空Series对象
s = pd.Series()
print(s) # 输出 Series([], dtype: object)
# 通过python列表创建
s = pd.Series([1,2,3,4,5])
print(s)输出：
0 1
1 2
2 3
3 4
4 5
dtype: int644.1.2 ndarry创建Series对象
案例：
# ndarry创建Series
s = pd.Series(np.array([1,2,3,4,5]))
print(s) 输出：
0 1
1 2
2 3
3 4
4 5
dtype: int324.1.3 字典创建Series对象
案例：
# 字典创建Series:字典中的Key是Series的标签名，Value是Series的值
dic = {"id":1,"age":20,"name":"zhangsan"}
s = pd.Series(dic)
print(s)输出：
id 1
age 20
name zhangsan
dtype: object4.2 访问Series数据
案例：
s = pd.Series([1,2,3,4,5,6])
print(s[3]) # 输出 4
# 使用下标做切片时，终止值不被包含
print(s[:2])
# 输出
# 0 1
# 1 2
# dtype: int64
s = pd.Series([1,2,3,4],index=['a','b','c','d'])
print(s)
# 输出
# a 1
# b 2
# c 3
# d 4
# dtype: int64
print(s['d']) # 输出 4
# 使用终止值做切片时，终止值被包含
print(s['a':'c'])
# 输出
# a 1
# b 2
# c 3
# dtype: int644.3 Series遍历
4.3.1 使用items()
案例：
# 使用items()遍历，返回index和value
s = pd.Series([1,2,3,4],index=['a','b','c','d'])
for idx,val in s.items():
print(idx,val)
# 输出
# a
# b
# c
# d4.3.2 使用index属性
案例：
# 1.使用index遍历
s = pd.Series([1,2,3,4],index=['a','b','c','d'])
# index:获取标签
for idx in s.index:
print(idx)
# 输出
# a
# b
# c
# d4.3.3 使用values属性
案例：
v# 2.使用Values遍历
s = pd.Series([1,2,3,4],index=['a','b','c','d'])
for v in s.index:
print(v)
# 输出
# a
# b
# c
# d4.4 Series常用方法
| 方法名 | 说明 |
|---|---|
| isnull() | 如果为值不存在或者缺失，则返回 True |
| notnull() | 如果值不存在或者缺失，则返回 False |
案例：
import pandas as pd
'''
isnull() 和 nonull() 用于检测 Series 中的缺失值
isnull()：如果为值不存在或者缺失，则返回 True
notnull()：如果值不存在或者缺失，则返回 False
'''
def eight():
result = pd.Series(['a','b','c','d','e','f',None])
print("isnull()如果为值不存在或者缺失，则返回 True：")
print(result.isnull())
print("notnull()如果值不存在或者缺失，则返回 False：")
print(result.notnull())
#过滤掉缺失值
print(result[result.notnull()])输出：
isnull()如果为值不存在或者缺失，则返回 True：
0 False
1 False
2 False
3 False
4 False
5 False
6 True
dtype: bool
notnull()如果值不存在或者缺失，则返回 False：
0 True
1 True
2 True
3 True
4 True
5 True
6 False
dtype: bool
0 a
1 b
2 c
3 d
4 e
5 f
dtype: object5 DataFrame
5.1 创建DataFrame对象
5.1.1 创建DataFrame空对象
案例：
# 创建DataFrame对象
df = pd.DataFrame()
print(df)
# 输出
# Empty DataFrame
# Columns: []
# Index: []
5.1.2 列表嵌套字典创建DataFrame对象
案例：
# # 列表嵌套字典创建
# # 如果字典中有不同的键值对，则创建DataFram时取所有字典中键值对的并集
l = [{"name":"zhangsan","age":20,"address":"1111"},{"name":"lisi","age":21,"sex":0}]
df = pd.DataFrame(l)
print(df)
# 输出
# name age address sex
# 0 zhangsan 20 1111 NaN
# 1 lisi 21 NaN 0.05.1.3字典嵌套列表创建DataFrame对象
案例：
# # 字典嵌套列表来创建
# # 字典中value数组的长度要一致
dic = {"name":["zhangsan","lisi"],"age":[20,22]}
df = pd.DataFrame(dic)
print(df)
# 输出
# name age
# 0 zhangsan 20
# 1 lisi 225.1.4 Series创建DataFrame对象
案例：
# 字典嵌套Series创建
# 字典中value使用Series时，如果有字段的行有缺失，则默认填充NaN
dic = {"name":pd.Series([1,2,3],index=['a','b','c']),
"age":pd.Series([10,20,30],index=['a','b','c'])}
df = pd.DataFrame(dic)
print(df)
# 输出
# name age
# a 1 10
# b 2 20
# c 3 30
#
dic = {"name":pd.Series(["zhangsan","lisi","wnagwu"],index=['a','b','c']),
"sex":pd.Series(["nan","nv","nan","nv"],index=['a','b','c','d'])}
df = pd.DataFrame(dic)
print(df)
# 输出
# name sex
# a zhangsan nan
# b lisi nv
# c wnagwu nan
# d NaN nv5.2 列索引操作
5.2.1 选取数据
案例：
# 获取数据
dic = {"one":[1,2,3,4,5],
"two":[6,7,8,9,10],
"three":[11,12,13,14,15]}
df = pd.DataFrame(dic)
print(df)
# 取一列返回Series
print(df['one'])
# 取多列返回DataFrame
print(df[['one','two']])
# 不能直接对列做切片操作，可以通过loc或iloc实现
# print(df['one':'three'])输出：
one two three
0 1 6 11
1 2 7 12
2 3 8 13
3 4 9 14
4 5 10 15
0 1
1 2
2 3
3 4
4 5
Name: one, dtype: int64
one two
0 1 6
1 2 7
2 3 8
3 4 9
4 5 105.2.2 添加数据
案例1，添加一个空列：
# 添加一个空列
data = {"one":pd.Series([1,2,3],index=['a','b','c']),
"two":pd.Series([5,6,7,8],index=['a','b','c','d'])}
df = pd.DataFrame(data)
print(df)
df['three']=None
print(df)输出：
# 添加一个空列
data = {"one":pd.Series([1,2,3],index=['a','b','c']),
"two":pd.Series([5,6,7,8],index=['a','b','c','d'])}
df = pd.DataFrame(data)
print(df)
df['three']=None
print(df)案例2，通过列表添加一列：
# 通过列表添加一列
data = {"one":pd.Series([1,2,3],index=['a','b','c']),
"two":pd.Series([5,6,7,8],index=['a','b','c','d'])}
df = pd.DataFrame(data)
df['three']=[10,20,30,40]
print(df)输出：
one two three
a 1.0 5 10
b 2.0 6 20
c 3.0 7 30
d NaN 8 40案例3，使用insert方法：
# # insert():在指定位置插入数据
# # 参数：loc-要插入的索引下标，coloumn-要插入的列名，value-要插入的数据
data = {
"A":[1,2,3,4],
"B":[5,6,7,8],
"C":[9,10,11,12]
}
df =pd.DataFrame(data)
df.insert(1,'D',[13,14,15,16])
print(df)输出：
A D B C
0 1 13 5 9
1 2 14 6 10
2 3 15 7 11
3 4 16 8 12案例4，使用asign()方法：
# # 通过assign():参数是赋值语句，等号左边是要添加的列名，右边是要添加的值
# # assign()是链式调用
# 链式编程：方法返回的数据类型是对象本身，这种方式就是链式编程，连续调用链式编程的方法叫链式调用
data = {"one":pd.Series([1,2,3],index=['a','b','c']),
"two":pd.Series([5,6,7,8],index=['a','b','c','d'])}
df = pd.DataFrame(data)
df1 = df.assign(three=[10,20,30,40]).assign(four=[1,2,3,4])
print(df1)输出：
one two three four
a 1.0 5 10 1
b 2.0 6 20 2
c 3.0 7 30 3
d NaN 8 40 45.2.3 修改数据
案例1，修改数据：
# # 修改数据
data = {
"A":[1,2,3,4],
"B":[5,6,7,8]
}
df =pd.DataFrame(data)
print(df.dtypes)
df['A'] = df['A'].astype(np.float32)
print(df.dtypes)
df['B'] = [10,11,12,13]
print(df)
df['B'] = df['A'] + 100
print(df)输出：
A int64
B int64
dtype: object
A float32
B int64
dtype: object
A B
0 1.0 10
1 2.0 11
2 3.0 12
3 4.0 13
A B
0 1.0 101.0
1 2.0 102.0
2 3.0 103.0
3 4.0 104.0案例2，修改列名：
data = {
"A":[1,2,3,4],
"B":[5,6,7,8]
}
df =pd.DataFrame(data)
# 修改列名
# 1.column属性修改列名，在原数据上直接修改
df.columns = ['C','D']
print(df)
# # 2.rename()修改列名，返回一个新的DataFramem,原数据不受影响
# # columns的数据类型是字典，字典的key是原DataFrame的列名，value是要修改的列名
df1 = df.rename(columns={"C":"E","D":"F"})
print(df1)输出：
C D
0 1 5
1 2 6
2 3 7
3 4 8
E F
0 1 5
1 2 6
2 3 7
3 4 85.2.4 删除数据
通过drop方法删除 DataFrame 中的数据，默认情况下，drop() 不会修改原 DataFrame，而是返回一个新的 DataFrame。
语法：
DataFrame.drop(labels=None, axis=0, index=None, columns=None, level=None, inplace=False, errors='raise')| 参数名 | 类型 | 描述 |
|---|---|---|
| labels | 单个标签或列表。 | 要删除的行或列的标签。如果 axis=0，则 labels 表示行标签；如果 axis=1，则 labels 表示列标签。 |
| axis | 整数或字符串，默认为 0 | 指定删除的方向。axis=0 或 axis='index' 表示删除行，axis=1 或 axis='columns' 表示删除列。 |
| index | 单个标签或列表，默认为 None | 要删除的行的标签。如果指定，则忽略 labels 参数。 |
| columns | 单个标签或列表，默认为 None | 要删除的列的标签。如果指定，则忽略 labels 参数。 |
| level | 整数或级别名称，默认为 None | 用于多级索引（MultiIndex），指定要删除的级别。 |
| inplace | 布尔值，默认为 False | 如果为 True，则直接修改原 DataFrame，而不是返回一个新的 DataFrame。 |
| errors | 字符串，默认为 'raise' | 指定如何处理不存在的标签。'raise' 表示抛出错误，'ignore' 表示忽略错误。 |
案例1，删除列：
# 删除数据
# drop()
# 参数
# labels:要删除标签（行/列）
# axis:轴方向，和labels结合使用，axis=0,labels是行标签，axis=1,labels是列标签
# index:要删除的行标签或列表
# columns:要删除的列标签或列表
# inplace:如果为True,表示原地修改标签，为False表示返回一个新的DataFrame，默认为False
data = {
'A':[1,2,3,4,5],
'B':[6,7,8,9,10]
}
df = pd.DataFrame(data)
# 使用labels和axis删除列
df1 = df.drop(['A'],axis=1)
print("df1:",df1)
# 使用columns删除列
df2 = df.drop(columns=['A'])
print("df2:",df2)
"""
df1: B
0 6
1 7
2 8
3 9
4 10
df2: B
0 6
1 7
2 8
3 9
4 10
"""案例2，删除行：
# 使用labels和axis删除行
df3 = df.drop([0,1],axis=0)
print("df3:",df3)
# 使用index删除行
df4 = df.drop(index=[0,1])
print("df4:",df4)
"""
df3: A B
2 3 8
3 4 9
4 5 10
df4: A B
2 3 8
3 4 9
4 5 10
"""案例3，直接删除原DataFrame的行或列：
# 原地修改:inplace
df.drop(index=[0],inplace=True)
print("原地修改:",df)
"""
原地修改: A B
1 2 7
2 3 8
3 4 9
4 5 10
"""5.3 行索引操作
5.3.1 loc选取数据
df.loc[] 只能使用标签索引，不能使用整数索引。当通过标签索引的切片方式来筛选数据时，它的取值前闭后闭，也就是只包括边界值标签（开始和结束）
loc方法返回的数据类型：
1.如果选择单行或单列，返回的数据类型为Series
2.选择多行或多列，返回的数据类型为DataFrame
3.选择单个元素(某行某列对应的值)，返回的数据类型为该元素的原始数据类型（如整数、浮点数等）。
语法：
DataFrame.loc[row_indexer, column_indexer]参数：
-
row_indexer：行标签或布尔数组。
-
column_indexer：列标签或布尔数组。
案例：
# 获取行
data = {
'A':[1,2,3,4],
'B':[5,6,7,8],
'C':[9,10,11,12]
}
df = pd.DataFrame(data,index=['a','b','c','d'])
print(df)
#
# # 获取a行数据
print(df.loc['a'])
# # 对行切片，获取a行到c行数据
print(df.loc['a':'c'])
# # 对行和列切片
print(df.loc['a':'c','A':'B'])
# # 对列切片
print(df.loc[...,'A':'B'])
"""
A B C
a 1 5 9
b 2 6 10
c 3 7 11
d 4 8 12
A 1
B 5
C 9
Name: a, dtype: int64
A B C
a 1 5 9
b 2 6 10
c 3 7 11
A B
a 1 5
b 2 6
c 3 7
A B
a 1 5
b 2 6
c 3 7
d 4 8
"""
# 获取一个标量
print(df.loc['a','B']) # 输出 5
# 获取多行多列
print(df.loc[['a','c'],['A','C']])
"""
A C
a 1 9
c 3 11
"""5.3.2 iloc选取数据
iloc 方法用于基于位置（integer-location based）的索引，即通过行和列的整数位置来选择数据。
语法：
DataFrame.iloc[row_indexer, column_indexer]案例：
# iloc[row_index,col_index]:根据索引获取数据
# row_index:行索引下标。col_index：列索引下标
data = {
'A':[1,2,3,4],
'B':[5,6,7,8],
'C':[9,10,11,12]
}
df = pd.DataFrame(data,index=['a','b','c','d'])
# 获取单行，获取第0行数据
print(df.iloc[0])
# 行切片，不包含终止端
print(df.iloc[0:2])
# 行和列切片
print(df.iloc[0:2,0:2])
# 列切片
print(df.iloc[:,0:2])
# 获取标量
print(df.iloc[0,0])
# 获取多行多列
print(df.iloc[[0,1],[0,1]])
"""
A 1
B 5
C 9
Name: a, dtype: int64
A B C
a 1 5 9
b 2 6 10
A B
a 1 5
b 2 6
A B
a 1 5
b 2 6
c 3 7
d 4 8
1
A B
a 1 5
b 2 6
"""
5.3.3 切片多行选取
通过切片的方式进行多行数据的选取
案例：
# DataFrame切片操作，默认按行进行切片，操作结果和iloc一致
df1 = df[0:2]
print(df1)
"""
A B C
a 1 5 9
b 2 6 10
"""切片获取行和通过iloc方法获取行从结果上没有区别，切片是基于位置的切片操作，iloc是基于位置的索引操作。
5.3.4 添加数据行
loc方法添加数据行：
案例：
# 1.loc添加
data = {
'A':[1,2,3,4],
'B':[5,6,7,8]
}
df = pd.DataFrame(data,index=['a','b','c','d'])
# 通过loc添加一个新的行标签，赋值即可，赋值的列表中的元素和列数一致
df.loc['e']=[9,10]
print(df)
"""
A B
a 1 5
b 2 6
c 3 7
d 4 8
e 9 10
"""
# iloc添加数据报错：IndexError: iloc cannot enlarge its target object
# data = {
# 'A':[1,2,3,4],
# 'B':[5,6,7,8]
# }
# df = pd.DataFrame(data)
# print(df)
# df.iloc[4] = [9,10]
# print(df)concat拼接：
语法：
pd.concat(objs, axis=0, join='outer', ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, sort=False, copy=True)参数：
| 参数名 | 说明 |
|---|---|
| objs | 要连接的 DataFrame 或 Series 对象的列表或字典。 |
| axis | 指定连接的轴，0 或 'index' 表示按行连接，1 或 'columns' 表示按列连接。 |
| join | 指定连接方式，'outer' 表示并集（默认），'inner' 表示交集。 |
| ignore_index | 如果为 True，则忽略原始索引并生成新的索引。 |
| keys | 用于在连接结果中创建层次化索引。 |
| levels | 指定层次化索引的级别。 |
| names | 指定层次化索引的名称。 |
| verify_integrity | 如果为 True，则在连接时检查是否有重复索引。 |
| sort | 如果为 True，则在连接时对列进行排序。 |
| copy | 如果为 True，则复制数据。 |
案例1，按行连接(垂直堆叠)：
df1 = pd.DataFrame({
'A':[1,2,3],
'B':[4,5,6]
})
df2 = pd.DataFrame({
'A':[7,8,9],
'B':[10,11,12]
})
# 按行拼接
# ignore_index：如果为True,则忽略原来的行标签，重新生成
df3 = pd.concat([df1,df2],axis=0,ignore_index=True)
print(df3)
"""
A B
0 1 4
1 2 5
2 3 6
3 7 10
4 8 11
5 9 12
"""案例2，按列连接：
# 按列拼接
df1 = pd.DataFrame({
'A':[1,2,3],
'B':[4,5,6]
})
df2 = pd.DataFrame({
'C':[9,10,11],
'D':[12,13,14],
})
# 默认按照join=outer进行拼接
df3 = pd.concat([df1,df2],axis=0)
print(df3)
"""
A B C D
0 1.0 4.0 NaN NaN
1 2.0 5.0 NaN NaN
2 3.0 6.0 NaN NaN
0 NaN NaN 9.0 12.0
1 NaN NaN 10.0 13.0
2 NaN NaN 11.0 14.0
"""案例3，使用ignore_index:
# 创建两个示例 DataFrame
df1 = pd.DataFrame({
'A': [1, 2, 3],
'B': [4, 5, 6]
})
df2 = pd.DataFrame({
'A': [7, 8, 9],
'B': [10, 11, 12]
})
# 按行连接 df1 和 df2，并忽略原始索引
result = pd.concat([df1, df2], axis=0, ignore_index=True)
print(result)案例4，使用join='inner'，按行合并：
# join：拼接方式：outer-并集（默认），inner-交集
df1 = pd.DataFrame({
'A':[1,2,3],
'B':[4,5,6]
})
df2 = pd.DataFrame({
'A':[7,8,9],
'B':[10,11,12],
'C':[13,14,15]
})
# 默认按照join=outer进行拼接
df3 = pd.concat([df1,df2],axis=0)
print(df3)
"""
A B C
0 1 4 NaN
1 2 5 NaN
2 3 6 NaN
0 7 10 13.0
1 8 11 14.0
2 9 12 15.0
"""
# 按照交集拼接，取df1和df2共同的列，多余的丢弃
df4 = pd.concat([df1,df2],axis=0,join='inner')
print(df4)案例5，DataFrame和Series连接：
# DataFrame和Series拼接、
df = pd.DataFrame({
'A':[1,2,3],
'B':[4,5,6]
})
s = pd.Series([7,8,9],name='C')
df1 = pd.concat([df,s],axis=0)
print(df1)
"""
A B C
0 1.0 4.0 NaN
1 2.0 5.0 NaN
2 3.0 6.0 NaN
0 NaN NaN 7.0
1 NaN NaN 8.0
2 NaN NaN 9.0
"""
df2 = pd.concat([df,s],axis=1)
print(df2)
"""
A B C
0 1 4 7
1 2 5 8
2 3 6 9
"""5.3.5 删除数据行
同删除数据列一样，省略。
6 函数
6.1 常用的统计学函数
| 函数名称 | 描述说明 |
|---|---|
| count() | 统计某个非空值的数量 |
| sum() | 求和 |
| mean() | 求平均值 |
| median() | 求中位数 |
| std() | 求标准差 |
| min() | 求最小值 |
| max() | 求最大值 |
| abs() | 求绝对值 |
| prod() | 求所有数值的乘积 |
案例：
# 统计函数
# 方差:pandas默认是样本方差
data = {
'A':[1,2,3,4,5],
'B':[10,20,30,40,50],
'C':[100,200,300,400,500]
}
df = pd.DataFrame(data)
print(df.var())
"""
A 2.5
B 250.0
C 25000.0
dtype: float64
"""
# 平均值
print(df.mean())
"""
dtype: float64
A 3.0
B 30.0
C 300.0
"""
# 求和
print(df.sum())
"""
dtype: float64
A 15
B 150
C 1500
dtype: int64
"""6.2 重置索引
重置索引（reindex）可以更改原 DataFrame 的行标签或列标签，并使更改后的行、列标签与 DataFrame 中的数据逐一匹配。通过重置索引操作，您可以完成对现有数据的重新排序。如果重置的索引标签在原 DataFrame 中不存在，那么该标签对应的元素值将全部填充为 NaN。
案例：
# 重置索引
# reindex():重置索引的位置，也可以添加新的索引标签，元素值默认填充NaN
data = {
'A':[1,2,3],
'B':[4,5,6],
'C':[7,8,9]
}
df = pd.DataFrame(data,index=['a','b','c'])
# 重置行索引
new_index = ['b','a','c','d']
df1 = df.reindex(index=new_index)
print(df1)
"""
A B C
b 2.0 5.0 8.0
a 1.0 4.0 7.0
c 3.0 6.0 9.0
d NaN NaN NaN
"""
# 重置列索引
new_col = ['A','B','C','D']
df2 = df.reindex(columns=new_col)
print(df2)
"""
A B C D
a 1 4 7 NaN
b 2 5 8 NaN
c 3 6 9 NaN
"""
# method:填充方式,ffill-前向填充，bfill-后向填充
df3 = df.reindex(columns=new_col,method='ffill')
print(df3)
"""
A B C D
a 1 4 7 7
b 2 5 8 8
c 3 6 9 9
"""
# fill_value:使用指定值填充
df4 = df.reindex(columns=new_col,fill_value=0)
print(df4)
"""
A B C D
a 1 4 7 0
b 2 5 8 0
c 3 6 9 0
"""6.3 遍历
DataFrame 这种二维数据表结构，遍历会获取列标签
案例1：
import pandas as pd
series_data = pd.Series(['a','b','c','d','e','f',None])
print('Series：')
for item in series_data:
print(item, end=' ')
#输出：
a b c d e f None 案例2：
import pandas as pd
series_data = pd.Series(['a','b','c','d','e','f',None])
print('Series：')
for item in series_data:
print(item, end=' ')
#输出：
a b c d e f None 6.3.1 遍历行
itertuples() 方法用于遍历 DataFrame 的行，返回一个包含行数据的命名元组。它 是遍历 DataFrame 的推荐方法，因为它在速度和内存使用上都更高效。
案例：
import pandas as pd
# 创建一个示例 DataFrame
data = {
'A': [1, 2, 3],
'B': [4, 5, 6],
'C': [7, 8, 9]
}
df = pd.DataFrame(data, index=['a', 'b', 'c'])
# 使用 itertuples() 遍历行
for row in df.itertuples():
print(row)
for i in row:
print(i)
#输出：
Pandas(Index='a', A=1, B=4, C=7)
a
1
4
7
Pandas(Index='b', A=2, B=5, C=8)
b
2
5
8
Pandas(Index='c', A=3, B=6, C=9)
c
3
6
9
# 忽略索引
for row in df.itertuples(index=False):
print(row)
for i in row:
print(i)6.3.2 遍历列
items() 方法用于遍历 DataFrame 的列，返回一个包含列名和列数据的迭代器。
案例：
import pandas as pd
# 创建一个示例 DataFrame
data = {
'A': [1, 2, 3],
'B': [4, 5, 6],
'C': [7, 8, 9]
}
df = pd.DataFrame(data, index=['a', 'b', 'c'])
# 使用 items() 遍历列
for column_name, column_data in df.items():
print(f"Column Name: {column_name}, Column Data: {column_data}")
#输出：
Column Name: A, Column Data: a 1
b 2
c 3
Name: A, dtype: int64
Column Name: B, Column Data: a 4
b 5
c 6
Name: B, dtype: int64
Column Name: C, Column Data: a 7
b 8
c 9
Name: C, dtype: int646.3.3 使用属性遍历
loc 和 iloc 方法可以用于按索引或位置遍历 DataFrame 的行和列。
案例：
import pandas as pd
# 创建一个示例 DataFrame
data = {
'A': [1, 2, 3],
'B': [4, 5, 6],
'C': [7, 8, 9]
}
df = pd.DataFrame(data, index=['a', 'b', 'c'])
# 使用 loc 遍历行和列
for index in df.index:
for column in df.columns:
print(f"Index: {index}, Column: {column}, Value: {df.loc[index, column]}")
# 输出：
Index: a, Column: A, Value: 1
Index: a, Column: B, Value: 4
Index: a, Column: C, Value: 7
Index: b, Column: A, Value: 2
Index: b, Column: B, Value: 5
Index: b, Column: C, Value: 8
Index: c, Column: A, Value: 3
Index: c, Column: B, Value: 6
Index: c, Column: C, Value: 96.4 排序
6.4.1 sort_index
sort_index 方法用于对 DataFrame 或 Series 的索引进行排序。
语法：
DataFrame.sort_index(axis=0, ascending=True, inplace=False)
Series.sort_index(axis=0, ascending=True, inplace=False)参数：
| 参数名 | 说明 |
|---|---|
| axis | 指定要排序的轴。默认为 0，表示按行索引排序。如果设置为 1，将按列索引排序。 |
| ascending | 布尔值，指定是升序排序（True）还是降序排序（False）。 |
| inplace | 布尔值，指定是否在原地修改数据。如果为 True，则会修改原始数据；如果为 False，则返回一个新的排序后的对象。 |
案例：
import pandas as pd
# 创建一个示例 DataFrame
data = {
'A': [1, 2, 3],
'B': [4, 5, 6],
'C': [7, 8, 9]
}
df = pd.DataFrame(data, index=['b', 'c', 'a'])
# 按行索引标签排序，不对对应的值排序
df_sorted = df.sort_index()
#输出：
A B C
a 3 6 9
b 1 4 7
c 2 5 8
#按列索引标签降序排序
df_sorted = df.sort_index(axis=1,ascending=False)
print(df_sorted)
# 输出：
C B A
b 7 4 1
c 8 5 2
a 9 6 36.4.2 sort_values
sort_values 方法用于根据一个或多个列的值对 DataFrame 进行排序。
语法：
DataFrame.sort_values(by, axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last')参数：
| 参数名 | 说明 |
|---|---|
| by | 列的标签或列的标签列表。指定要排序的列。 |
| axis | 指定沿着哪个轴排序。默认为 0，表示按行排序。如果设置为 1，将按列排序。 |
| ascending | 布尔值或布尔值列表，指定是升序排序（True）还是降序排序（False）。可以为每个列指定不同的排序方向。 |
| inplace | 布尔值，指定是否在原地修改数据。如果为 True，则会修改原始数据；如果为 False，则返回一个新的排序后的对象。 |
| kind | 排序算法。默认为 'quicksort'，也可以选择 'mergesort'(归并排序) 或 'heapsort'(堆排序)。 |
| na_position | 指定缺失值（NaN）的位置。可以是 'first' 或 'last'。 |
案例：
import pandas as pd
# 创建一个示例 DataFrame
data = {
'A': [3, 2, 1],
'B': [6, 5, 4],
'C': [9, 8, 7]
}
df = pd.DataFrame(data, index=['b', 'c', 'a'])
# 按列 'A' 排序
df_sorted = df.sort_values(by='A')
print(df_sorted)
# 按列 'A' 和 'B' 排序
df_sorted = df.sort_values(by=['A', 'B'])
print(df_sorted)
# 按列 'A' 降序排序
df_sorted = df.sort_values(by='A', ascending=False)
print(df_sorted)
# 按列 'A' 和 'B' 排序，先按A列降序排序，如果A列中值相同则按B列升序排序
df = pd.DataFrame({
'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
'Age': [25, 30, 25, 35, 30],
'Score': [85, 90, 80, 95, 88]
})
df_sorted = df.sort_values(by=['Age', 'Score'], ascending=[False, True])
print(df_sorted)6.5 去重
drop_duplicates 方法用于删除 DataFrame 或 Series 中的重复行或元素。
语法：
drop_duplicates(by=None, subset=None, keep='first', inplace=False)
Series.drop_duplicates(keep='first', inplace=False)参数:
| 参数名 | 说明 |
|---|---|
| by | 用于标识重复项的列名或列名列表。如果未指定，则使用所有列。 |
| subset | 与 by 类似，但用于指定列的子集。 |
| keep | 指定如何处理重复项。可以是： 'first'：保留第一个出现的重复项（默认值）。 'last'：保留最后一个出现的重复项。 False：删除所有重复项。 |
| inplace | 布尔值，指定是否在原地修改数据。如果为 True，则会修改原始数据；如果为 False，则返回一个新的删除重复项后的对象。 |
案例：
import pandas as pd
# 创建一个示例 DataFrame
data = {
'A': [1, 2, 2, 3],
'B': [4, 5, 5, 6],
'C': [7, 8, 8, 9]
}
df = pd.DataFrame(data)
# 删除所有列的重复行，默认保留第一个出现的重复项
df_unique = df.drop_duplicates()
print(df_unique)
# 删除重复行，保留最后一个出现的重复项
df_unique = df.drop_duplicates(keep='last')
print(df_unique)6.6 分组
6.6.1 groupby
通过 groupby，你可以将数据集按照某个列（或多个列）的值分组，然后对每个组应用聚合函数，比如求和、平均值、最大值等。
语法：
DataFrame.groupby(by, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=False, observed=False, **kwargs)参数：
| 参数名 | 说明 |
|---|---|
| by | 用于分组的列名或列名列表。 |
| axis | 指定沿着哪个轴进行分组。默认为 0，表示按行分组。 |
| level | 用于分组的 MultiIndex 的级别。 |
| as_index | 布尔值，指定分组后索引是否保留。如果为 True，则分组列将成为结果的索引；如果为 False，则返回一个列包含分组信息的 DataFrame。 |
| sort | 布尔值，指定在分组操作中是否对数据进行排序。默认为 True。 |
| group_keys | 布尔值，指定是否在结果中添加组键。 |
| squeeze | 布尔值，如果为 True，并且分组结果返回一个元素，则返回该元素而不是单列 DataFrame。 |
| observed | 布尔值，如果为 True，则只考虑数据中出现的标签。 |
案例：
import pandas as pd
# 创建一个示例 DataFrame
data = {
'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'],
'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],
'C': [1, 2, 3, 4, 5, 6, 7, 8],
'D': [10, 20, 30, 40, 50, 60, 70, 80]
}
df = pd.DataFrame(data)
# 按列 'A' 分组
grouped = df.groupby('A')
# 查看分组结果
for name, group in grouped:
print(f"Group: {name}")
print(group)
print()
mean = df.groupby(['A']).mean()
print(mean)
#输出：
C D
A
bar 4.0 40.0
foo 4.8 48.0
mean = grouped['C'].mean()
print(mean)
#输出：
A
bar 4.0
foo 4.8
# 在分组内根据C列求平均值
# transform用于在分组操作中对每个组内的数据进行转换，并将结果合并回原始 DataFrame。
mean = grouped['C'].transform(lambda x: x.mean())
df['C_mean'] = mean
print(df)
#输出：
A B C D C_mean
0 foo one 1 10 4.8
1 bar one 2 20 4.0
2 foo two 3 30 4.8
3 bar three 4 40 4.0
4 foo two 5 50 4.8
5 bar two 6 60 4.0
6 foo one 7 70 4.8
7 foo three 8 80 4.8
# 在分组内根据C列求标准差
std = grouped['C'].transform(np.std)
df['C_std'] = std
print(df)
# 在分组内根据C列进行正太分布标准化
norm = grouped['C'].transform(lambda x: (x - x.mean()) / x.std())
df['C_normal'] = norm
print(df)6.6.2 filter
通过 filter() 函数可以实现数据的筛选，该函数根据定义的条件过滤数据并返回一个新的数据集。
案例：
import pandas as pd
# 创建一个示例 DataFrame
data = {
'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'],
'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],
'C': [1, 2, 3, 4, 5, 6, 7, 8],
'D': [10, 20, 30, 40, 50, 60, 70, 80]
}
df = pd.DataFrame(data)
# 按列 'A' 分组，并过滤掉列 'C' 的平均值小于 4 的组
filtered = df.groupby('A').filter(lambda x: x['C'].mean() >= 4)
print(filtered)6.7 合并
merge 函数用于将两个 DataFrame 对象根据一个或多个键进行合并，类似于 SQL 中的 JOIN 操作。这个方法非常适合用来基于某些共同字段将不同数据源的数据组合在一起，最后拼接成一个新的 DataFrame 数据表。
语法：
pandas.merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=True, indicator=False, validate=None)参数：
| 参数名 | 说明 |
|---|---|
| left | 左侧的 DataFrame 对象。 |
| right | 右侧的 DataFrame 对象。 |
| how | 合并方式，可以是 'inner'、'outer'、'left' 或 'right'。默认为 'inner'。
|
| on | 用于连接的列名。如果未指定，则使用两个 DataFrame 中相同的列名。 |
| left_on和right_on | 分别指定左侧和右侧 DataFrame 的连接列名。 |
| left_index和right_index | 布尔值，指定是否使用索引作为连接键。 |
| sort | 布尔值，指定是否在合并后对结果进行排序。 |
| suffixes | 一个元组，指定当列名冲突时，右侧和左侧 DataFrame 的后缀。 |
| copy | 布尔值，指定是否返回一个新的 DataFrame。如果为 False，则可能修改原始 DataFrame。 |
| indicator | 布尔值，如果为 True，则在结果中添加一个名为 __merge 的列，指示每行是如何合并的。 |
| validate | 验证合并是否符合特定的模式。 |
案例1，内连接：
import pandas as pd
# 创建两个示例 DataFrame
left = pd.DataFrame({
'key': ['K0', 'K1', 'K2', 'K3'],
'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3']
})
right = pd.DataFrame({
'key': ['K0', 'K1', 'K2', 'K4'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']
})
# 内连接
result = pd.merge(left, right, on='key')
print(result)
#输出：K3、K4被忽略
key A B C D
0 K0 A0 B0 C0 D0
1 K1 A1 B1 C1 D1
2 K2 A2 B2 C2 D2案例2，左连接：
import pandas as pd
# 创建两个示例 DataFrame
left = pd.DataFrame({
'key': ['K0', 'K1', 'K2', 'K3'],
'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3']
})
right = pd.DataFrame({
'key': ['K0', 'K1', 'K2', 'K4'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']
})
# 内连接
result = pd.merge(left, right, on='key')
print(result)
#输出：K3、K4被忽略
key A B C D
0 K0 A0 B0 C0 D0
1 K1 A1 B1 C1 D1
2 K2 A2 B2 C2 D26.8 随机抽样
语法：
DataFrame.sample(n=None, frac=None, replace=False, weights=None, random_state=None, axis=None)参数：
| 参数名 | 说明 |
|---|---|
| n | 要抽取的行数 |
| frac | 抽取的比例，比如 frac=0.5，代表抽取总体数据的50% |
| replace | 布尔值参数，表示是否以有放回抽样的方式进行选择，默认为 False，取出数据后不再放回 |
| weights | 可选参数，代表每个样本的权重值，参数值是字符串或者数组 |
| random_state | 可选参数，控制随机状态，默认为 None，表示随机数据不会重复；若为 1 表示会取得重复数据 |
| axis | 表示在哪个方向上抽取数据(axis=1 表示列/axis=0 表示行) |
案例：
import pandas as pd
def sample_test():
df = pd.DataFrame({
"company": ['百度', '阿里', '腾讯'],
"salary": [43000, 24000, 40000],
"age": [25, 35, 49]
})
print('随机选择两行：')
print(df.sample(n=2, axis=0))
print('随机选择一列：')
print(df.sample(n=1, axis=1))
print('总体的50%：')
print(df.sample(axis=0, frac=0.5))6.9 空值处理
6.9.1 检测空值
isnull()用于检测 DataFrame 或 Series 中的空值，返回一个布尔值的 DataFrame 或 Series。
notnull()用于检测 DataFrame 或 Series 中的非空值，返回一个布尔值的 DataFrame 或 Series。
案例：
import pandas as pd
import numpy as np
# 创建一个包含空值的示例 DataFrame
data = {
'A': [1, 2, np.nan, 4],
'B': [5, np.nan, np.nan, 8],
'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data)
# 检测空值
is_null = df.isnull()
print(is_null)
# 检测非空值
not_null = df.notnull()
print(not_null)6.9.2 填充空值
fillna() 方法用于填充 DataFrame 或 Series 中的空值。
案例：
# 创建一个包含空值的示例 DataFrame
data = {
'A': [1, 2, np.nan, 4],
'B': [5, np.nan, np.nan, 8],
'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data)
# 用 0 填充空值
df_filled = df.fillna(0)
print(df_filled)6.9.3 删除空值
dropna() 方法用于删除 DataFrame 或 Series 中的空值。
案例：
# 创建一个包含空值的示例 DataFrame
data = {
'A': [1, 2, np.nan, 4],
'B': [5, np.nan, np.nan, 8],
'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data)
# 删除包含空值的行
df_dropped = df.dropna()
print(df_dropped)
#输出：
A B C
0 1.0 5.0 9
3 4.0 8.0 12
# 删除包含空值的列
df_dropped = df.dropna(axis=1)
print(df_dropped)
#输出：
C
0 9
1 10
2 11
3 127 读取CSV文件
CSV（Comma-Separated Values，逗号分隔值，有时也称为字符分隔值，因为分隔字符也可以不是逗号），其文件以纯文本形式存储表格数据（数字和文本）；
7.1 to_csv()
to_csv() 方法将 DataFrame 存储为 csv 文件
案例：
import pandas as pd
# 创建一个简单的 DataFrame
data = {
'Name': ['Alice', 'Bob', 'Charlie'],
'Age': [25, 30, 35],
'City': ['New York', 'Los Angeles', 'Chicago']
}
df = pd.DataFrame(data)
# 将 DataFrame 导出为 CSV 文件
df.to_csv('output.csv', index=False)7.2 read_csv()
read_csv() 表示从 CSV 文件中读取数据，并创建 DataFrame 对象。
案例：
import pandas as pd
df = pd.read_csv('output.csv')
print(df)8 绘图
Pandas 在数据分析、数据可视化方面有着较为广泛的应用，Pandas 对 Matplotlib 绘图软件包的基础上单独封装了一个plot()接口，通过调用该接口可以实现常用的绘图操作；
Pandas 之所以能够实现了数据可视化，主要利用了 Matplotlib 库的 plot() 方法，它对 plot() 方法做了简单的封装，因此您可以直接调用该接口；
只用 pandas 绘制图片可能可以编译，但是不会显示图片，需要使用 matplotlib 库，调用 show() 方法显示图形。
案例1：
import pandas as pd
import matplotlib.pyplot as plt
# 创建一个示例 DataFrame
data = {
'A': [1, 2, 3, 4, 5],
'B': [10, 20, 25, 30, 40]
}
df = pd.DataFrame(data)
# 绘制折线图
df.plot(kind='line')
# 显示图表
plt.show()
# 绘制柱状图
df.plot(kind='bar')
# 显示图表
plt.show()
# 绘制直方图
df['A'].plot(kind='hist')
# 显示图表
plt.show()
# 绘制散点图
df.plot(kind='scatter', x='A', y='B')
# 显示图表
plt.show()案例2，饼图：
# 创建一个示例 Series
data = {
'A': 10,
'B': 20,
'C': 30,
'D': 40
}
series = pd.Series(data)
# 绘制饼图
series.plot(kind='pie', autopct='%1.1f%%')
# 显示图表
plt.show()