文章目录
- 前言
- 1 loc和iloc注意事项。（后面这些都会在笔记中提到）
- 2 DataFrame的维度
- 一、 DataFrame的创建 --- (data，index=None，columns=None)
- 1 字典创建DataFrame(字典转Dataframe很常用)
- 2 用numpy数组或者嵌套list创建DataFrame
- 二、DataFrame的访问、索引、切片、布尔索引、修改等操作
- 1 行切片访问 df[ : ] ---- 不能用单个数字索引，只能用切片索引（后面会用loc和iloc替代这个很呆的功能）--- 默认位置索引和自定义索引都支持
- 2 按列选择
- df['column_name']：选择单列，返回 Series。
- df[['column_name']] ：选择单列，返回 DataFrame。
- df[['col1', 'col2']]：选择多列，返回 DataFrame。
- 3 按布尔条件选择
- df[df['column_name'] > value]：选择满足条件的行。
- df[(df['Age'] > 25) & (df['Score'] > 85)] ：and 注意里面布尔条件都要分别用小括号括起来，不然会报错
- df[(df['Age'] > 25) | (df['Score'] > 85)] ： or
- 4 loc[ ] 与 iloc[ ]进行操作
- （1）loc[ ]
- 基于行标签的选择 --- ['Alice'] ，[['Alice']]
- ['Alice'] --- 返回 Series
- [['Alice']] --- 返回 DataFrame
- [['Bob', 'David']] --- 返回 DataFrame ，这种数组的索引方式都可以用
- 基于行和列标签的选择 --- ['Alice', 'Age'] , ['Alice', ['Age', 'City']], [['Alice'], ['Age', 'City']]
- ['Alice', ['Age', 'City']] --- 返回Series
- [['Alice'], ['Age', 'City']] --- 返回Dataframe
- 基于行和列范围的选择（切片） --- ['Alice':'Charlie', 'Age':'City']
- 基于布尔条件的选择 ---- [df['Age'] > 25] , [df['Age'] > 25, ['City']]
- 更新操作
- （2）iloc[ ] 的使用方法
- 基于行位置的选择
- [0]
- [[0]]
- [[0,2]]
- 基于行和列位置的选择
- [0,1] ---- 返回一个标量
- [0,[0,1]] --- 返回series
- [[0],[0,1]] ---- 返回一个dataframe
- 基于行和列位置范围的选择（切片）
- [0:2, 0:2]
- 基于布尔条件的选择
- [df['Age'].values > 25] ---- 布尔索引不能直接用于 iloc，但可以通过 DataFrame 的 values 属性获取布尔条件
- 更新操作
- 综合示例（各种筛选是可以混合应用的所有要灵活应用，不能死板）
- 三、DataFrame的常用属性和方法
- 1 常用属性
- ---- 返回行索引对象，可以遍历；可以用 .to_list(), .to_numpy()方法转成list和numpy数组
- .to_list() ---- 将对象转换成列表
- .to_numpy() ---- 将对象转换成numpy数组
- --- 返回列索引对象，可以遍历；可以用 .to_list(), .to_numpy()方法转成list和numpy数组
- .to_list() ---- 将对象转换成列表
- .to_numpy() ---- 将对象转换成numpy数组
- --- 返回values 的numpy数组（注意是一个二维的numpy数组）
- --- 返回形状数组，dataframe一定是二维
- --- 返回维度，dataframe一定是 2
- --- 这里加了复数，表明返回的是每一列都会返回一个 数据类型（一个series）
- --- 返回values数组里面元素个数
- 2 基本信息查看方法
- (n)：查看前 n 行（默认 5 行）。
- (n)：查看后 n 行（默认 5 行）。
- ()：查看 DataFrame 概览信息，包括数据类型和非空值计数。
- ()：查看数值型数据的统计信息。
- 3 DataFrame与Series互转（特别常用）
- .squeeze() ---- DataFrame转Series
- .to_frame(name='col_name') --- 将 Series 转换为 DataFrame。name='col_name'指定列名；如果是dataframe筛选出来的Series，index和列名信息都有，我们都不用指定name='col_name'
- 4 DataFrame常用数据操作方法（新增修改列、改列名、删除及各种常用方法）
- （1）新增和修改列
- df['new_column'] = values：添加新列或修改现有列。
- (1, 'NewColumn', new_column)：在dataframe指定位置添加一列（机器学习训练集哪里会用到）
- （2）给列重命名 ---- (columns={'Name': 'Full Name'})
- （3）设置和重置索引
- df.set_index('column_name')：将某表设置为索引。
- df.reset_index()： 重置索引为整数索引，方法用于重置 DataFrame 的索引，将其转换为默认的整数索引.或者将索引变成dataframe新的一列（drop=False）
- （4）删除行或列
- (columns=['col1', 'col2'])：删除指定列。
- (index=[0, 1])：删除指定行。
- （5）排序操作
- df.sort_values(by=['column1','column2'], ascending=[True,False])：按列排序。
- df.sort_index()：按索引排序。
- （6）数据清洗
- 处理缺失值
- ()：删除含有缺失值的行。
- (value)：用指定值填充缺失值。
- df.drop_duplicates()：删除重复行。
- （7）数据类型转换处理
- 数据类型转换
- ---- df['column'].astype(new_type)：转换列的数据类型。
- 字符串操作
- ---- df['column'].()：对字符串列进行操作。
- 日期时间处理
- ---- pd.to_datetime(df['column'])：将列转换为日期时间类型。
- ---- df['column'].：对日期时间列进行操作。
- （8）数据统计
- 基本统计
- .max()和.min()
- .sum() --- 求和
- df['column'].mean()：计算平均值。
- df['column'].median()：计算中位数。
- df['column'].std()：计算标准差。
- .var() --- 方差
- .quantile([0,0.25,0.5,0.75,1.0]) --- 查看四分位数
- () --- 直接这样用就可以看到各列变量直接的 （协方差矩阵了）
- 分组聚合（*） ('column').agg_func() ---- 返回的是一个可能有多级索引的series
- ---- ('City')['Age'].mean()
- 数据透视表（*）
- ---- df.pivot_table(values='value', index='index', columns='column', aggfunc='mean')
- （8）其他一些常用操作
- 索引和列交换
- ：转置 DataFrame。
- 应用函数
- .apply(func)：对 DataFrame 应用函数。
- 四、DataFrame的拼接（常用 -- 力扣上还有这样的题）
- 1 ([df1,df2,.....],axis = 0) ----- 函数用于沿指定轴拼接多个 DataFrame 或 Series 对象。
- 2 (left, right, how='inner', on=None, left_on=None, right_on=None) 表连接的使用----有点复杂（最近在做一个项目在进行time对齐用到了这个）
- （1）左，右连接
- 左连接：(left, right, how='left')
- 右连接：(left, right, how='right')
- （2）外连接和内连接
- 内连接（理解成交集）：(left, right, how='inner')
- 外连接（理解成并集）：(left, right, how='outer')
- （3）以两个表的index为连接的on怎么处理
- (df1, df2, left_index=True, right_index=True, how='inner')
- 五、pandas的导入和导出
- df.to_csv('')：导出为 CSV 文件。
- pd.read_csv('')：从 CSV 文件导入 DataFrame。
- 六、DatetimeIndex 时间序列索引index对象
- 1 创建DatetimeIndex 时间索引index对象
- 从时间序列直接创建
- pd.date_range(start='2024-01-01', end='2024-01-10', freq='D')
- 从现有数据转换
- (dates)
- pd.to_datetime(dates)
- 2 DatetimeIndex 的基本属性
- --- 访问年份,返回Index对象
- --- 访问月份,返回Index对象
- --- 访问日期,返回Index对象
- --- 访问小时,返回Index对象
- --- 访问分钟,返回Index对象
- --- 访问星期几,返回Index对象
- --- 访问季度,返回Index对象
- 3 DatetimeIndex 的切片
- 4 DatetimeIndex在Dataframe和Series上的应用(不断转换来转换区)
- 通过df.reset_index和df.set_index和pd.to_datetime将DatetimeIndex不断变成索引和列
- 5 .resample('2D').mean() ---- 重采样技术
- 6 .rolling(window=3).mean() --- 时间窗口功能
- 7 .align(ts2, join='inner') ---- 时间对齐高级用法
- 8 () ---- 时间戳偏移（Shifting）功能：偏移时间序列数据，即向前或向后移动数据点
- 总结
前言
本部分主要介绍一些注意事项。另外，series是基础，好多用法都是series扩展一下，很类似的。
1 loc和iloc注意事项。（后面这些都会在笔记中提到）
（1）返回的是Series还是dataframe取决于你有没有加中括号
【注】：如果你对数组索引单个也加上中括号，那么返回的将是 DataFrame 而不是 Series这个规则是普遍适用的，下面也有，这个规则要记住
【注】：单个的一般大家都习惯不加中括号，大不了最后用 .squeeze() ---- DataFrame转Series或者 .to_frame()转一下
（2）loc可以直接布尔索引，iloc布尔索引后还有.values一下转成numpy数组才能布尔索引
2 DataFrame的维度
一、 DataFrame的创建 — (data，index=None，columns=None)
— data：可以是字典、列表、NumPy 数组、Pandas Series 或 DataFrame 等。
— index：指定行索引，可以是列表、NumPy 数组或 Pandas Index 对象。
— columns：指定列名，可以是列表、NumPy 数组或 Pandas Index 对象。
没有指定就生成默认的位置索引。
1 字典创建DataFrame(字典转Dataframe很常用)
## 利用字典创建DataFrame
dict = {'数学':[93,89,80,77],'英语':[90,80,70,75],'语文':[87,79,67,92]}
df1 = pd.DataFrame(dict)
print(df1) # 数学 英语 语文
# 0 93 90 87
# 1 89 80 79
# 2 80 70 67
# 3 77 75 92
df2 =pd.DataFrame(dict,index=['张三','李四','王五','赵六'])
print(df2) # 数学 英语 语文
# 张三 93 90 87
# 李四 89 80 79
# 王五 80 70 67
# 赵六 77 75 92
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
2 用numpy数组或者嵌套list创建DataFrame
# 从列表创建
data = [['Alice', 25],
['Bob', 30],
['Charlie', 35]]
df1 = pd.DataFrame(data,index=['a','b','c'] ,columns=['Name', 'Age'])
print(df1) # Name Age
# a Alice 25
# b Bob 30
# c Charlie 35
# 从 NumPy 数组创建
data = np.array([[1, 2],
[3, 4],
[5, 6]])
df2 = pd.DataFrame(data, index=['a','b','c'], columns=['A', 'B'])
print(df2) # A B
# a 1 2
# b 3 4
# c 5 6
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
二、DataFrame的访问、索引、切片、布尔索引、修改等操作
1 行切片访问 df[ : ] ---- 不能用单个数字索引，只能用切片索引（后面会用loc和iloc替代这个很呆的功能）— 默认位置索引和自定义索引都支持
【注1】：这里切片就是真要切片了，不支持 df[0] , df[1]这种
【注2】：所以就很呆，所以我们后面都会用loc和iloc来替代这个垃圾功能
【注3】：切片无论是有没有设置自定义index都可以用默认位置索引（左闭右开），用自定义（符号）index也可以，但是是（左闭右闭）
# 创建一个示例 DataFrame
data = {
'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
'Age': [24, 27, 22, 32, 29],
'Score': [85.5, 88.0, 95.0, 70.5, 80.0]
}
df = pd.DataFrame(data) # Name Age Score
print(df) # 0 Alice 24 85.5
# 1 Bob 27 88.0
# 2 Charlie 22 95.0
# 3 David 32 70.5
# 4 Eve 29 80.0
print(df[0:3]) # Name Age Score
# 0 Alice 24 85.5
# 1 Bob 27 88.0
# 2 Charlie 22 95.0
df2 = pd.DataFrame(data, index=['a', 'b', 'c', 'd', 'e']) # 自定义一下索引
print(df2) # Name Age Score
# a Alice 24 85.5
# b Bob 27 88.0
# c Charlie 22 95.0
# d David 32 70.5
# e Eve 29 80.0
print(df2[0:3]) # Name Age Score
# a Alice 24 85.5
# b Bob 27 88.0
# c Charlie 22 95.0
print(df2['a':'c']) # Name Age Score
# a Alice 24 85.5
# b Bob 27 88.0
# c Charlie 22 95.0
print(df2[0]) # KeyError: 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
- 35
- 36
- 37
2 按列选择
df[‘column_name’]：选择单列，返回 Series。
df[[‘column_name’]] ：选择单列，返回 DataFrame。
【注】：如果你对数组索引单个也加上中括号，那么返回的将是 DataFrame 而不是 Series这个规则是普遍适用的，下面也有，这个规则要记住
【注】：单个的一般大家都习惯不加中括号，大不了最后用 .squeeze() ---- DataFrame转Series或者 .to_frame()转一下
# 创建示例 DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie', 'David'],
'Age': [24, 27, 22, 32],
'City': ['New York', 'Los Angeles', 'Chicago', 'Houston']}
df = pd.DataFrame(data)
print(df) # Name Age City
# 0 Alice 24 New York
# 1 Bob 27 Los Angeles
# 2 Charlie 22 Chicago
# 3 David 32 Houston
print(df['Name']) # 0 Alice
# 1 Bob
# 2 Charlie
# 3 David
# Name: Name, dtype: object Series
print(df[['Name']]) # Name
# 0 Alice
# 1 Bob
# 2 Charlie
# 3 David
# DataFrame 两个中括号返回的是 DataFrame
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
df[[‘col1’, ‘col2’]]：选择多列，返回 DataFrame。
3 按布尔条件选择
df[df[‘column_name’] > value]：选择满足条件的行。
df[(df[‘Age’] > 25) & (df[‘Score’] > 85)] ：and 注意里面布尔条件都要分别用小括号括起来，不然会报错
df[(df[‘Age’] > 25) | (df[‘Score’] > 85)] ： or
# 创建一个示例 DataFrame
data = {
'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
'Age': [24, 27, 22, 32, 29],
'Score': [85.5, 88.0, 95.0, 70.5, 80.0]
}
df = pd.DataFrame(data) # Name Age Score
print(df) # 0 Alice 24 85.5
# 1 Bob 27 88.0
# 2 Charlie 22 95.0
# 3 David 32 70.5
# 4 Eve 29 80.0
print(df[(df['Age'] > 25) & (df['Score'] > 85)]) # Name Age Score
# 1 Bob 27 88.0
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
4 loc[ ] 与 iloc[ ]进行操作
- [注]：关于你筛选出来的数据是DataFrame还是Series关键在于你整数数组访问单个时有没有加中括号，没有加就有可能是Series，有就是DataFrame，看下面例子就懂了
- [注]：其实这个用法记住各种筛选条件可以混合用就是了
（1）loc[ ]
loc：基于标签（名称）的索引，用于按行和列的标签来访问数据。适合于按行/列标签精确选择数据。
初始要筛选的DataFrame
# 创建示例 DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie', 'David'],
'Age': [24, 27, 22, 32],
'City': ['New York', 'Los Angeles', 'Chicago', 'Houston']}
df = pd.DataFrame(data)
df.set_index('Name', inplace=True)
print(df) # Age City
# Name
# Alice 24 New York
# Bob 27 Los Angeles
# Charlie 22 Chicago
# David 32 Houston
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
基于行标签的选择 — [‘Alice’] ，[[‘Alice’]]
[‘Alice’] — 返回 Series
[[‘Alice’]] — 返回 DataFrame
[[‘Bob’, ‘David’]] — 返回 DataFrame ，这种数组的索引方式都可以用
如果你对数组索引单个也加上中括号，那么返回的将是 DataFrame 而不是 Series这个规则是普遍适用的，下面也有
# 按行标签选择
row = df.loc['Alice']
print(row) # Age 24
# City New York
# Name: Alice, dtype: object # 单行返回 Series
row2 = df.loc[['Alice']] # 加上中括号，返回的是 DataFrame了·
print(row2) # Age City
# Name
# Alice 24 New York
df2 = df.loc[['Bob', 'David']]
print(df2) # Age City
# Name
# Bob 27 Los Angeles
# David 32 Houston
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 选择标签为 ‘Alice’ 的行。
基于行和列标签的选择 — [‘Alice’, ‘Age’] , [‘Alice’, [‘Age’, ‘City’]], [[‘Alice’], [‘Age’, ‘City’]]
[‘Alice’, [‘Age’, ‘City’]] — 返回Series
[[‘Alice’], [‘Age’, ‘City’]] — 返回Dataframe
如果你对数组索引单个也加上中括号，那么返回的将是 DataFrame 而不是 Series这个规则是普遍适用的，下面也有
-
选择标签为 ‘Alice’ 的行和 ‘Age’ 列对应的单元格数据。
-
选择标签为 ‘Alice’ 的行以及 ‘Age’ 和 ‘City’ 列。
# 选择特定行和列
value = df.loc['Alice', 'Age']
print(value) # 24 # 如果只选择一行一列，返回的是标量
# 选择特定行的多列 --- 返回 Series
subset = df.loc['Alice', ['Age', 'City']]
print(subset) # Age 24
# City New York
# Name: Alice, dtype: object # 注意：返回的是 Series
# 选择特定行的多列 --- 返回 DataFrame
subset2 = df.loc[['Alice'], ['Age', 'City']]
print(subset2) # Age City
# Name
# Alice 24 New York
# 如果你对数组索引单个也加上中括号，那么返回的将是 DataFrame 而不是 Series
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
基于行和列范围的选择（切片） — [‘Alice’:‘Charlie’, ‘Age’:‘City’]
# 选择行标签在一定范围内的多行和多列
subset = df.loc['Alice':'Charlie', 'Age':'City']
print(subset) # Age City
# Name
# Alice 24 New York
# Bob 27 Los Angeles
# Charlie 22 Chicago
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 选择行标签从 ‘Alice’ 到 ‘Charlie’（包括）的行，以及从 ‘Age’ 到 ‘City’ 的列。
基于布尔条件的选择 ---- [df[‘Age’] > 25] , [df[‘Age’] > 25, [‘City’]]
- 选择 ‘Age’ 列大于 25 的所有行。
- 选择 ‘Age’ 列大于 25 的行，并只保留 ‘City’ 列。
subset = df.loc[df['Age'] > 25]
print(subset) # Age City
# Name
# Bob 27 Los Angeles
# David 32 Houston
subset2 = df.loc[df['Age'] > 25, ['City']]
print(subset2) # City
# Name
# Bob Los Angeles
# David Houston
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
更新操作
# 更新特定单元格的值
df.loc['Alice', 'Age'] = 30
# 更新满足条件的行的特定列
df.loc[df['Age'] > 25, 'City'] = 'San Francisco'
- 1
- 2
- 3
- 4
- 5
- 更新 ‘Alice’ 行的 ‘Age’ 列值为 30。
- 将 ‘Age’ 列大于 25 的所有行的 ‘City’ 列值更新为 ‘San Francisco’。
（2）iloc[ ] 的使用方法
iloc 用于通过整数位置来选择数据，类似于 NumPy 的数组索引，支持按行、按列或行列组合进行选择。iloc 方法通常有以下几种用法：
创建示例 dataframe
# 创建示例 DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie', 'David'],
'Age': [24, 27, 22, 32],
'City': ['New York', 'Los Angeles', 'Chicago', 'Houston']}
df = pd.DataFrame(data)
df.set_index('Name', inplace=True)
print(df) # Age City
# Name
# Alice 24 New York
# Bob 27 Los Angeles
# Charlie 22 Chicago
# David 32 Houston
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
基于行位置的选择
[0]
[[0]]
[[0,2]]
# 按行位置选择
print(df.iloc[0]) # Age 24
# City New York
# Name: Alice, dtype: object # Series
print(df.iloc[[0]]) # Age City
# Name
# Alice 24 New York # DataFrame
print(df.iloc[[0,2]]) # Age City
# Name
# Alice 24 New York
# Charlie 22 Chicago
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
基于行和列位置的选择
[0,1] ---- 返回一个标量
[0,[0,1]] — 返回series
[[0],[0,1]] ---- 返回一个dataframe
print(df.iloc[0,1]) # New York
print(df.iloc[0,0]) # 24
print(df.iloc[0,[0,1]]) # Age 24
# City New York
# Name: Alice, dtype: object # 返回的是 Series
print(df.iloc[[0],[0,1]]) # Age City
# Name
# Alice 24 New York # 返回的是 DataFrame
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
基于行和列位置范围的选择（切片）
[0:2, 0:2]
# 选择行和列位置在一定范围内的多行和多列
subset = df.iloc[0:2, 0:2]
print(subset) # Age City
# Name
# Alice 24 New York
# Bob 27 Los Angeles
- 1
- 2
- 3
- 4
- 5
- 6
基于布尔条件的选择
[df[‘Age’].values > 25] ---- 布尔索引不能直接用于 iloc，但可以通过 DataFrame 的 values 属性获取布尔条件
# 布尔索引不能直接用于 iloc，但可以通过 DataFrame 的 values 属性获取布尔条件
subset = df.iloc[df['Age'].values > 25]
print(subset) # Age City
# Name
# Bob 27 Los Angeles
# David 32 Houston
- 1
- 2
- 3
- 4
- 5
- 6
- 选择 ‘Age’ 列大于 25 的所有行。
更新操作
# 更新特定位置的单元格值
df.iloc[0, 1] = 28
# 更新满足条件的行的特定列
df.iloc[df['Age'].values > 25, 1] = 'San Francisco'
- 1
- 2
- 3
- 4
- 5
- 更新第一行的第二列的值为 28。
- 将 ‘Age’ 列大于 25 的所有行的第二列值更新为 ‘San Francisco’。
loc 和 iloc 的区别与选择
-
标签 vs 整数位置：
loc使用行和列的标签（名字），iloc使用整数位置。 -
切片行为：
loc的切片是闭区间的，包含结束标签，而iloc的切片是半开区间的，不包含结束位置。 -
速度：在大多数情况下，
iloc会比loc快一些，因为它是基于整数位置的直接索引。
综合示例（各种筛选是可以混合应用的所有要灵活应用，不能死板）
import pandas as pd
# 创建示例 DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie', 'David'],
'Age': [24, 27, 22, 32],
'City': ['New York', 'Los Angeles', 'Chicago', 'Houston']}
df = pd.DataFrame(data)
df.set_index('Name', inplace=True)
# loc 使用示例
print("loc 示例：")
print(df.loc['Alice']) # 通过行标签选择
print(df.loc['Alice', 'Age']) # 通过行和列标签选择
print(df.loc['Alice':'Charlie', 'Age':'City']) # 通过行和列的范围选择
print(df.loc[df['Age'] > 25]) # 基于布尔条件选择
# iloc 使用示例
print("\niloc 示例：")
print(df.iloc[0]) # 通过行位置选择
print(df.iloc[0, 1]) # 通过行和列位置选择
print(df.iloc[0:2, 1:3]) # 通过行和列位置范围选择
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
运行
三、DataFrame的常用属性和方法
1 常用属性
---- 返回行索引对象，可以遍历；可以用 .to_list(), .to_numpy()方法转成list和numpy数组
.to_list() ---- 将对象转换成列表
.to_numpy() ---- 将对象转换成numpy数组
— 返回列索引对象，可以遍历；可以用 .to_list(), .to_numpy()方法转成list和numpy数组
.to_list() ---- 将对象转换成列表
.to_numpy() ---- 将对象转换成numpy数组
— 返回values 的numpy数组（注意是一个二维的numpy数组）
— 返回形状数组，dataframe一定是二维
— 返回维度，dataframe一定是 2
— 这里加了复数，表明返回的是每一列都会返回一个 数据类型（一个series）
— 返回values数组里面元素个数
# 从 NumPy 数组创建
data = np.array([[1, 2],
[3, 4],
[5, 6]])
df2 = pd.DataFrame(data, index=['a','b','c'], columns=['A', 'B'])
print(df2) # A B
# a 1 2
# b 3 4
# c 5 6
print(df2.index) # Index(['a', 'b', 'c'], dtype='object')
print(df2.columns.to_list()) # ['A', 'B']
print(df2.values) # [[1 2]
# [3 4]
# [5 6]]
print(df2.shape) # (3, 2)
print(df2.dtypes) # A int64
# B int64
# dtype: object 这是一个 Series 对象
print(df2.size) # 6
print(df2.ndim) # 2
- 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
2 基本信息查看方法
(n)：查看前 n 行（默认 5 行）。
(n)：查看后 n 行（默认 5 行）。
()：查看 DataFrame 概览信息，包括数据类型和非空值计数。
()：查看数值型数据的统计信息。
# 创建一个示例 DataFrame
data = {
'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
'Age': [24, 27, 22, 32, 29],
'Score': [85.5, 88.0, 95.0, 70.5, 80.0]
}
df = pd.DataFrame(data) # Name Age Score
print(df) # 0 Alice 24 85.5
# 1 Bob 27 88.0
# 2 Charlie 22 95.0
# 3 David 32 70.5
# 4 Eve 29 80.0
# 查看 DataFrame 的前 n 行
print(df.head(3)) # Name Age Score
# 0 Alice 24 85.5
# 1 Bob 27 88.0
# 2 Charlie 22 95.0
# 查看 DataFrame 的后 n 行
print(df.tail(2)) # Name Age Score
# 3 David 32 70.5
# 4 Eve 29 80.0
# 查看 DataFrame 的概览信息
print(df.info()) # <class ''>
# RangeIndex: 5 entries, 0 to 4
# Data columns (total 3 columns):
# Name 5 non-null object
# Age 5 non-null int64
# Score 5 non-null float64
# dtypes: float64(1), int64(1), object(1)
# memory usage: 248.0+ bytes
# 查看数值型数据的统计信息
print(df.describe()) # Age Score
# count 5.000000 5.000000
# mean 26.800000 83.800000
# std 3.701351 8.326663
# min 22.000000 70.500000
# 25% 24.000000 80.000000
# 50% 27.000000 85.500000
# 75% 29.000000 88.000000
# max 32.000000 95.000000
- 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
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
3 DataFrame与Series互转（特别常用）
.squeeze() ---- DataFrame转Series
.to_frame(name=‘col_name’) — 将 Series 转换为 DataFrame。name='col_name’指定列名；如果是dataframe筛选出来的Series，index和列名信息都有，我们都不用指定name=‘col_name’
# 原始 DataFrame 示例
data = {
'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
'Age': [24, 27, 22, 32, 29],
'City': ['New York', 'Los Angeles', 'Chicago', 'Houston', 'Phoenix']
}
df = pd.DataFrame(data)
df.set_index('Name', inplace=True)
# 选择 Age 大于 25 的行，并且只选择 City 列
subset2_df = df.loc[df['Age'] > 25, ['City']]
print(subset2_df) # City
# Name
# Bob Los Angeles
# David Houston
# Eve Phoenix
# 将 DataFrame 转换为 Series
subset2_series = subset2_df.squeeze()
print(subset2_series) # Name
# Bob Los Angeles
# David Houston
# Eve Phoenix
# Name: City, dtype: object
# 将 Series 转换为 DataFrame
subset2_dataframe = subset2_series.to_frame()
print(subset2_dataframe) # City
# Name
# Bob Los Angeles
# David Houston
# Eve Phoenix
- 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
# 通过字典创建 Series
data = {'f': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'a': 1}
s = pd.Series(data)
# 将 Series 转换为 DataFrame，并指定新的列名
df = s.to_frame(name='col_name')
print(df) # col_name
# f 1
# b 2
# c 3
# d 4
# e 5
# a 1
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
4 DataFrame常用数据操作方法（新增修改列、改列名、删除及各种常用方法）
示例dataframe：
# 创建示例 DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie', 'David'],
'Age': [24, 27, 22, 32],
'City': ['New York', 'Los Angeles', 'Chicago', 'Houston']}
df = pd.DataFrame(data)
df.set_index('Name', inplace=True)
print(df) # Age City
# Name
# Alice 24 New York
# Bob 27 Los Angeles
# Charlie 22 Chicago
# David 32 Houston
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
（1）新增和修改列
df[‘new_column’] = values：添加新列或修改现有列。
# 添加新列
df['Salary'] = [50000, 60000, 70000,100000]
print(df) # Age City Salary
# Name
# Alice 24 New York 50000
# Bob 27 Los Angeles 60000
# Charlie 22 Chicago 70000
# David 32 Houston 100000
df['Age'] = df['Age'] + 5
print(df) # Age City Salary
# Name
# Alice 29 New York 50000
# Bob 32 Los Angeles 60000
# Charlie 27 Chicago 70000
# David 37 Houston 100000
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
(1, ‘NewColumn’, new_column)：在dataframe指定位置添加一列（机器学习训练集哪里会用到）
# 创建一个示例DataFrame
data = {'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]}
df = pd.DataFrame(data)
print(df) # A B C
# 0 1 4 7
# 1 2 5 8
# 2 3 6 9
# 在索引位置1插入一列新数据
new_column = [10, 11, 12]
# 这里可以是列表，num数组，或者是dataframe的value等都是可以的
df.insert(1, 'NewColumn', new_column)
print(df) # A NewColumn B C
# 0 1 10 4 7
# 1 2 11 5 8
# 2 3 12 6 9
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
（2）给列重命名 ---- (columns={‘Name’: ‘Full Name’})
# 重命名列
df = df.rename(columns={'Age': 'Full Age', 'City': 'Current City'})
print(df) # Full Age Current City
# Name
# Alice 24 New York
# Bob 27 Los Angeles
# Charlie 22 Chicago
# David 32 Houston
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
（3）设置和重置索引
df.set_index(‘column_name’)：将某表设置为索引。
df.reset_index()： 重置索引为整数索引，方法用于重置 DataFrame 的索引，将其转换为默认的整数索引.或者将索引变成dataframe新的一列（drop=False）
参数：
----- drop=True表面丢弃原来的索引，重置为整数索引
----- drop=False会将原来的索引变成dataframe新的一列，索引重置为默认的整数索引。
# 创建示例 DataFrame
data = {
'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
'Age': [24, 27, 22, 32, 29],
'City': ['New York', 'Los Angeles', 'Chicago', 'Houston', 'Phoenix']
}
df = pd.DataFrame(data)
df.set_index('Name', inplace=True) # 将 'Name' 列设置为索引
print(df) # Age City
# Name
# Alice 24 New York
# Bob 27 Los Angeles
# Charlie 22 Chicago
# David 32 Houston
# Eve 29 Phoenix
# 重置索引
df_reset = df.reset_index(drop=True,inplace=False) # drop=True 丢弃原索引，会将原来的索引变成dataframe新的一列
print(df_reset) # Age City
# 0 24 New York
# 1 27 Los Angeles
# 2 22 Chicago
# 3 32 Houston
# 4 29 Phoenix
- 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
----- 如果没有drop=True会发生：
# 重置索引
df_reset = df.reset_index() # 沒有drop=True，原本的index变成dataframe新的一列
print(df_reset) # Name Age City
# 0 Alice 24 New York
# 1 Bob 27 Los Angeles
# 2 Charlie 22 Chicago
# 3 David 32 Houston
# 4 Eve 29 Phoenix
print(df_reset['Name']) # 0 Alice
# 1 Bob
# 2 Charlie
# 3 David
# 4 Eve
# Name: Name, dtype: object
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
（4）删除行或列
(columns=[‘col1’, ‘col2’])：删除指定列。
(index=[0, 1])：删除指定行。
# 创建示例 DataFrame
data = {
'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
'Age': [24, 27, 22, 32, 29],
'City': ['New York', 'Los Angeles', 'Chicago', 'Houston', 'Phoenix']
}
df = pd.DataFrame(data)
df.set_index('Name', inplace=True) # 将 'Name' 列设置为索引
print(df) # Age City
# Name
# Alice 24 New York
# Bob 27 Los Angeles
# Charlie 22 Chicago
# David 32 Houston
# Eve 29 Phoenix
df.drop(index=['Eve'],inplace=True)
print(df) # Age City
# Name
# Alice 24 New York
# Bob 27 Los Angeles
# Charlie 22 Chicago
# David 32 Houston
df.drop(columns=['City'],inplace=True)
print(df) # Age
# Name
# Alice 24
# Bob 27
# Charlie 22
# David 32
- 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
【注】：其实布尔条件筛选重另一个角度来说不也是一种删除操作。
（5）排序操作
df.sort_values(by=[‘column1’,‘column2’], ascending=[True,False])：按列排序。
df.sort_index()：按索引排序。
data = {
'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
'Math': [85, 92, 85, 88, 85],
'English': [90, 85, 88, 95, 80]
}
df = pd.DataFrame(data)
print(df) # Name Math English
# 0 Alice 85 90
# 1 Bob 92 85
# 2 Charlie 85 88
# 3 David 88 95
# 4 Eve 85 80
# 按 'Math' 列升序，按 'English' 列降序排序。先按 'Math' 列升序排序，math排不了再按 'English' 列降序排序
df_sorted = df.sort_values(by=['Math', 'English'], ascending=[True, False])
print("\n按 'Math' 列升序，按 'English' 列降序排序后:")
print(df_sorted) # Name Math English
# 0 Alice 85 90
# 2 Charlie 85 88
# 4 Eve 85 80
# 3 David 88 95
# 1 Bob 92 85
df_sort_index = df_sorted.sort_index() # 按索引升序排序
print(df_sort_index) # Name Math English
# 0 Alice 85 90
# 1 Bob 92 85
# 2 Charlie 85 88
# 3 David 88 95
# 4 Eve 85 80
- 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
（6）数据清洗
处理缺失值
()：删除含有缺失值的行。
(value)：用指定值填充缺失值。
# 创建包含缺失值的 DataFrame
data = {
'Name': ['Alice', 'Bob', 'Charlie', 'David'],
'Math': [85, None, 78, 88],
'English': [90, 85, None, 95]
}
df = pd.DataFrame(data)
print(df) # Name Math English
# 0 Alice 85.0 90.0
# 1 Bob NaN 85.0
# 2 Charlie 78.0 NaN
# 3 David 88.0 95.0
df['Math'].fillna(df['Math'].mean(), inplace=True)
print(df) # Name Math English
# 0 Alice 85.0 90.0
# 1 Bob 83.6 85.0
# 2 Charlie 78.0 NaN
# 3 David 88.0 95.0
df['English'].fillna(df['English'].mean(), inplace=True)
print(df) # Name Math English
# 0 Alice 85.0 90.0
# 1 Bob 83.6 85.0
# 2 Charlie 78.0 90.0
# 3 David 88.0 95.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
df.drop_duplicates()：删除重复行。
（7）数据类型转换处理
数据类型转换
---- df[‘column’].astype(new_type)：转换列的数据类型。
字符串操作
---- df[‘column’].()：对字符串列进行操作。
# 创建示例 DataFrame
data = {
'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
'Age': [24, 27, 22, 32, 29],
'City': ['New York', 'Los Angeles', 'Chicago', 'Houston', 'Phoenix']
}
df = pd.DataFrame(data)
print(df) # Name Age City
# 0 Alice 24 New York
# 1 Bob 27 Los Angeles
# 2 Charlie 22 Chicago
# 3 David 32 Houston
# 4 Eve 29 Phoenix
df['Name'] = df['Name'].str.upper() # 调用字符串方法将 'Name' 列的值转换为大写
df['City'] = df['City'].str.replace(' ', '_') # 调用字符串方法将 'City' 列的空格替换为下划线
print(df) # Age City
# Name
# ALICE 24 New_York
# BOB 27 Los_Angeles
# CHARLIE 22 Chicago
# DAVID 32 Houston
# EVE 29 Phoenix
- 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
日期时间处理
---- pd.to_datetime(df[‘column’])：将列转换为日期时间类型。
---- df[‘column’].：对日期时间列进行操作。
# 创建包含日期的 DataFrame
data = {
'Name': ['Alice', 'Bob', 'Charlie', 'David'],
'Date': ['2022/01/15', '2021/07/20', '2023/03/10', '2020/11/05']
}
df = pd.DataFrame(data)
print(df) # Name Date
# 0 Alice 2022/01/15
# 1 Bob 2021/07/20
# 2 Charlie 2023/03/10
# 3 David 2020/11/05
# 将字符串形式的日期转换为日期时间格式
df['Date'] = pd.to_datetime(df['Date'])
print(df) # Name Date
# 0 Alice 2022-01-15
# 1 Bob 2021-07-20
# 2 Charlie 2023-03-10
# 3 David 2020-11-05
# 从日期中提取年份
df['Year'] = df['Date'].dt.year
# 打印最终的 DataFrame
print("最终的 DataFrame:")
print(df) # Name Date Year
# 0 Alice 2022-01-15 2022
# 1 Bob 2021-07-20 2021
# 2 Charlie 2023-03-10 2023
# 3 David 2020-11-05 2020
- 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
（8）数据统计
基本统计
.max()和.min()
.sum() — 求和
df[‘column’].mean()：计算平均值。
df[‘column’].median()：计算中位数。
df[‘column’].std()：计算标准差。
.var() — 方差
.quantile([0,0.25,0.5,0.75,1.0]) — 查看四分位数
() — 直接这样用就可以看到各列变量直接的 （协方差矩阵了）
等等
分组聚合（*） (‘column’).agg_func() ---- 返回的是一个可能有多级索引的series
---- (‘City’)[‘Age’].mean()
# 创建包含城市和年龄的 DataFrame
data = {
'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Frank'],
'City': ['New York', 'Los Angeles', 'New York', 'Los Angeles', 'New York', 'Chicago'],
'Age': [25, 30, 35, 40, 28, 33]
}
df = pd.DataFrame(data)
print(df) # Name City Age
# 0 Alice New York 25
# 1 Bob Los Angeles 30
# 2 Charlie New York 35
# 3 David Los Angeles 40
# 4 Eve New York 28
# 5 Frank Chicago 33
# 按城市分组并计算每个城市的平均年龄
city_age_mean = df.groupby('City')['Age'].mean()
# 打印结果
print("按城市计算的平均年龄:")
print(city_age_mean) # City
# Chicago 33.0
# Los Angeles 35.0
# New York 29.3
# Name: Age, dtype: float64
- 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
【注】：这个函数还有一些较为复杂的用法，可以分两个组聚合
# 创建包含城市和年龄的 DataFrame
data = {
'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Frank'],
'City': ['New York', 'Los Angeles', 'New York', 'Los Angeles', 'New York', 'Chicago'],
'Age': [25, 30, 35, 40, 28, 33]
}
df = pd.DataFrame(data)
# 添加名字的首字母列
df['Initial'] = df['Name'].str[0]
print(df) # Name City Age Initial
# 0 Alice New York 25 A
# 1 Bob Los Angeles 30 B
# 2 Charlie New York 35 C
# 3 David Los Angeles 40 D
# 4 Eve New York 28 E
# 5 Frank Chicago 33 F
# 按城市和名字的首字母分组并计算每个组的平均年龄
grouped = df.groupby(['City', 'Initial'])['Age'].mean()
# 打印结果
print("按城市和名字首字母计算的平均年龄:")
print(grouped) # City Initial
# Chicago F 33
# Los Angeles B 30
# D 40
# New York A 25
# C 35
# E 28
# Name: Age, dtype: int64 # 说明：这里的结果是一个 Series，其中的索引是一个多级索引，包含城市和名字的首字母。
- 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
数据透视表（*）
---- df.pivot_table(values=‘value’, index=‘index’, columns=‘column’, aggfunc=‘mean’)
pivot_table 是 Pandas 中的一个非常强大的函数，用于创建数据透视表。它可以对数据进行分组汇总，并支持多种聚合函数（如 mean、sum 等）。下面是 pivot_table 函数的基本用法：
----- values：要聚合的列。
----- index：行索引。
----- columns：列索引。
----- aggfunc：聚合函数，默认为 mean。
假设我们有一个包含销售数据的 DataFrame，示例如下：
data = {
'Date': ['2024-01-01', '2024-01-01', '2024-01-02', '2024-01-02', '2024-01-03'],
'Store': ['Store A', 'Store B', 'Store A', 'Store B', 'Store A'],
'Product': ['Product 1', 'Product 1', 'Product 2', 'Product 2', 'Product 1'],
'Sales': [100, 150, 200, 250, 300]
}
df = pd.DataFrame(data)
print(df) # Date Store Product Sales
# 0 2024-01-01 Store A Product 1 100
# 1 2024-01-01 Store B Product 1 150
# 2 2024-01-02 Store A Product 2 200
# 3 2024-01-02 Store B Product 2 250
# 4 2024-01-03 Store A Product 1 300
pivot_table = df.pivot_table(values='Sales', index='Date', columns='Store', aggfunc='mean')
print("数据透视表:")
print(pivot_table) # Store Store A Store B
# Date
# 2024-01-01 100 150
# 2024-01-02 200 250
# 2024-01-03 300 NaN # NaN表示缺失值 这个返回的是一个DataFrame
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
在这个示例中：
----- values=‘Sales’ 指定了我们要聚合的列是 Sales。
----- index=‘Date’ 指定了行索引是 Date。
----- columns=‘Store’ 指定了列索引是 Store。
----- aggfunc=‘mean’ 指定了我们要使用的聚合函数是 mean。
结果是一个数据透视表，它展示了每个日期、每个商店的平均销售额。
【注】：同样的这个函数好像也可以分多组，多级索引的更加复杂用法；目前很少用的到。
（8）其他一些常用操作
索引和列交换
：转置 DataFrame。
# 创建第一个数据表 df1
df = pd.DataFrame({
'name': ['Alice', 'Bob', 'Charlie', 'David']
}, index=[1, 2, 3, 4])
print(df) # name
# 1 Alice
# 2 Bob
# 3 Charlie
# 4 David
print(df.T) # 1 2 3 4
# name Alice Bob Charlie David
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
应用函数
.apply(func)：对 DataFrame 应用函数。
# 创建示例 DataFrame
data = {
'A': [1, 2, 3],
'B': [4, 5, 6],
'C': [7, 8, 9]
}
df = pd.DataFrame(data) # A B C
# 0 1 4 7
# 1 2 5 8
# 2 3 6 9
df['A'] = df['A'].apply(lambda x: x + 1)
print(df)
# A B C
# 0 2 4 7
# 1 3 5 8
# 2 4 6 9
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
四、DataFrame的拼接（常用 – 力扣上还有这样的题）
1 ([df1,df2,…],axis = 0) ----- 函数用于沿指定轴拼接多个 DataFrame 或 Series 对象。
--------- 唯一需要注意的就是要使用 用ignore_index=True，index会自动重置，不会重复。这样就好了
df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2'], 'B': ['B0', 'B1', 'B2']})
df2 = pd.DataFrame({'A': ['A3', 'A4', 'A5'], 'B': ['B3', 'B4', 'B5']})
result1 = pd.concat([df1, df2],axis=1)
print(result1) # A B A B
# 0 A0 B0 A3 B3
# 1 A1 B1 A4 B4
# 2 A2 B2 A5 B5
result2 = pd.concat([df1, df2],axis=0)
print(result2) # A B
# 0 A0 B0
# 1 A1 B1
# 2 A2 B2
# 0 A3 B3
# 1 A4 B4
# 2 A5 B5 # 注意index的变化，这里是直接拼接，所以index会重复，需要用reset_index()重置index,并且drop=True。
# 或者用ignore_index=True
result3 = pd.concat([df1, df2],axis=0,ignore_index=True)
print(result3) # A B
# 0 A0 B0
# 1 A1 B1
# 2 A2 B2
# 3 A3 B3
# 4 A4 B4
# 5 A5 B5 #用ignore_index=True，index会自动重置，不会重复。这样就好了
- 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
2 (left, right, how=‘inner’, on=None, left_on=None, right_on=None) 表连接的使用----有点复杂（最近在做一个项目在进行time对齐用到了这个）
【注】：merge函数默认是内连接
【注】：理解好了发现几种连接都是同一套规则，很好理解。并不难
pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None)
- 1
【注】：这个函数的关键在于理解on指定的那一列，选择连接方式判断留下哪些行。
先了解表的四种连接方式：
如果一个索引在一个表里有，在另一个表里没有，根据合并的方式不同，会有不同的结果：
（1） 左连接（left join）：保留左边表（即第一个表）中所有的索引（on指定的那一列的所有行索引），右边表中不存在的索引对应的列将填充为缺失值（NaN）。
（2） 右连接（right join）：保留右边表（即第二个表）中所有的索引，左边表中不存在的索引对应的列将填充为缺失值（NaN）。
（3） 外连接（outer join）：保留两个表中所有的索引，如果某个索引只存在于一个表中，则另一个表中对应的列将填充为缺失值（NaN）（并集）。
（4） 内连接（inner join）：只保留两个表中都存在的索引，即只保留交集部分。在这种情况下，只会保留两个表中都存在的索引对应的数据行，其他索引对应的行将被丢弃（交集）。
具体来说：
- 左连接将保留左边表中所有的索引，右边表中不存在的索引对应的列将填充为缺失值。
- 右连接将保留右边表中所有的索引，左边表中不存在的索引对应的列将填充为缺失值。
- 外连接将保留两个表中所有的索引，并且将缺失的值填充为缺失值。
- 内连接将丢弃在一个表中出现但在另一个表中不存在的索引对应的数据行。
你可以根据具体需求选择合适的连接方式。
() 函数是 pandas 中用于合并（或连接）数据集的函数之一。它主要用于将两个或多个 pandas 数据帧按照指定的一列或多列进行连接。
这是 () 函数的一些主要参数及其解释：
- left: 左侧的数据帧。
- right: 右侧的数据帧。
-
how: 指定连接方式，可选值包括 ‘left’, ‘right’, ‘outer’, ‘inner’。默认为 ‘inner’。具体含义如下：
- ‘left’: 左连接
- ‘right’: 右连接
- ‘outer’: 外连接
- ‘inner’: 内连接
- on: 指定连接的列名，如果左右两个数据帧中的列名相同，可以简单指定列名；如果列名不同，则需要使用 left_on 和 right_on 参数分别指定左右两个数据帧的列名（然后比较值是否相同）。
- left_on: 指定左侧数据帧的连接列名。
- right_on: 指定右侧数据帧的连接列名。
（1）左，右连接
左连接和右连接是一样的规则，所以放在一起介绍。
左连接：(left, right, how=‘left’)
右连接：(left, right, how=‘right’)
# 创建第一个数据表 df1
df1 = pd.DataFrame({
'id': [1, 2, 3, 4],
'name': ['Alice', 'Bob', 'Charlie', 'David']
})
# 创建第二个数据表 df2
df2 = pd.DataFrame({
'id': [3, 4, 5],
'score': [85, 90, 95]
})
print(df1) # id name
# 0 1 Alice
# 1 2 Bob
# 2 3 Charlie
# 3 4 David
print(df2) # id score
# 0 3 85
# 1 4 90
# 2 5 95
# 左连接
left = pd.merge(df1, df2, on='id', how='left') # 以左表为基础（只留下了左表所有行），右表为补充，合并两个数据表; on='id'表示以id为键合并
# 可以看到，左表所有的数据都会被保留，右表中没有的数据会用NaN填充
print(left) # id name score
# 0 1 Alice NaN
# 1 2 Bob NaN
# 2 3 Charlie 85.0
# 3 4 David 90.0
# 右连接
right = pd.merge(df1, df2, on='id', how='right') # 以右表为基础（（只留下了右表所有行）），左表为补充，合并两个数据表
# 可以看到，右表所有的数据都会被保留，左表中没有的数据会用NaN填充
print(right) # id name score
# 0 3 Charlie 85
# 1 4 David 90
# 2 5 NaN 95
- 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
- 35
- 36
- 37
- 38
对左连接结果进行一个解释：
左连接保留了 df1 中所有的 id，即 1, 2, 3, 4。
对于 id 为 1 和 2 的行，由于在 df2 中找不到对应的 id，所以这些行的 score 列填充为 NaN。
对于 id 为 3 和 4 的行，找到了 df2 中对应的 id，因此这些行的 score 列填充为 85 和 90。
这样，我们就完成了一个具体的左连接示例，详细解释了左连接的含义及其操作方式。
（2）外连接和内连接
内连接（理解成交集）：(left, right, how=‘inner’)
【注】：内连接由于是交集，都会有的索引，所以不会存在NaN补充缺失的情况
外连接（理解成并集）：(left, right, how=‘outer’)
# 创建第一个数据表 df1
df1 = pd.DataFrame({
'id': [1, 2, 3, 4],
'name': ['Alice', 'Bob', 'Charlie', 'David']
})
# 创建第二个数据表 df2
df2 = pd.DataFrame({
'id': [3, 4, 5],
'score': [85, 90, 95]
})
print(df1) # id name
# 0 1 Alice
# 1 2 Bob
# 2 3 Charlie
# 3 4 David
print(df2) # id score
# 0 3 85
# 1 4 90
# 2 5 95
# 内连接
inner = pd.merge(df1, df2, on='id', how='inner')
print(inner) # id name score
# 0 3 Charlie 85
# 1 4 David 90 # 两个表中都有的数据，即交集由于是交集，所以内连接不会出现NaN值补充的情况
# 外连接
outer = pd.merge(df1, df2, on='id', how='outer')
print(outer) # id name score
# 0 1 Alice NaN
# 1 2 Bob NaN
# 2 3 Charlie 85.0
# 3 4 David 90.0
# 4 5 NaN 95.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
- 35
对内连接结果解释一下：
id 为 3 和 4 的行在两个表中都存在，因此这些行出现在结果中，并且所有列都有相应的值。
id 为 1、2 和 5 的行在其中一个表中不存在，因此这些行被丢弃，不会出现在结果中。
因此，内连接结果中不会出现 NaN 值，因为只有在两个表中都存在的索引和对应的行才会被保留下来，所有数据都是完整的。
（3）以两个表的index为连接的on怎么处理
(df1, df2, left_index=True, right_index=True, how=‘inner’)
如果你要以索引为连接，可以使用 函数的 left_index 和 right_index 参数。下面是一个示例，展示如何以索引为连接进行内连接。
# 创建第一个数据表 df1
df1 = pd.DataFrame({
'name': ['Alice', 'Bob', 'Charlie', 'David']
}, index=[1, 2, 3, 4])
# 创建第二个数据表 df2
df2 = pd.DataFrame({
'score': [85, 90, 95]
}, index=[3, 4, 5])
print(df1) # name
# 1 Alice
# 2 Bob
# 3 Charlie
# 4 David
print(df2) # score
# 3 85
# 4 90
# 5 95
# 利用index进行内连接合并
res = pd.merge(df1, df2, left_index=True, right_index=True, how='inner')
print(res) # name score
# 3 Charlie 85
# 4 David 90
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
五、pandas的导入和导出
df.to_csv(‘’)：导出为 CSV 文件。
pd.read_csv(‘’)：从 CSV 文件导入 DataFrame。
六、DatetimeIndex 时间序列索引index对象
pandas 中的 DatetimeIndex 是一种专门用于时间序列数据的索引类型，它使得处理时间数据变得更加高效和便捷。DatetimeIndex 继承自 pandas 的 Index 类，并且拥有许多独特的方法和属性来处理时间数据。
什么是 DatetimeIndex？
DatetimeIndex 是 pandas 中的一个索引对象，专门用于索引 datetime 类型的数据。这种索引类型允许我们以时间作为数据的索引，使得对时间序列数据的操作如切片、对齐、重采样和滚动窗口等变得更加直观和高效。
【注】： DatetimeIndex时间序列里面数据类型是 datetime64[ns]
把DatetimeIndex看成一列时间序列数据就可以了，可以通过set_index()变成Series和DataFrame里面的索引或者一列就行了
1 创建DatetimeIndex 时间索引index对象
先介绍时间参数
----- ‘D’: 每天
----- ‘W’: 每周
----- ‘M’: 每月末
----- ‘Q’: 每季度末
----- ‘A’: 每年末
‘2D’ ：每两天
从时间序列直接创建
pd.date_range(start=‘2024-01-01’, end=‘2024-01-10’, freq=‘D’)
# 通过 pandas 的 date_range 生成时间序列
date_range = pd.date_range(start='2024-01-01', end='2024-01-10', freq='D')
print(date_range)
# DatetimeIndex(['2024-01-01', '2024-01-02', '2024-01-03', '2024-01-04',
# '2024-01-05', '2024-01-06', '2024-01-07', '2024-01-08',
# '2024-01-09', '2024-01-10'],
# dtype='datetime64[ns]', freq='D') # 可以看到时间序列里面的数据类型是 datetime64[ns]
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
从现有数据转换
下面两种方法都是相同效果。最基本用法就是你的元素Excel有一列数据是时间，就可以调用pd.to_datetime(dates)将其变成DatetimeIndex的datetime64[ns]数据类型。
dates = [‘2024 01 01’, ‘2024 01 02’, ‘2024 01 03’]
dates = [‘2024/01/01’, ‘2024/01/02’, ‘2024/01/03’]
dates = [‘2024-01-01’, ‘2024-01-02’, ‘2024-01-03’]
都是可以被这里的函数识别，但至少要包含年月日才行 比如说dates = [‘01-01’, ‘01-02’, ‘01-03’]是不行的
如果要有小时分钟秒就要像下面这样：
dates = [‘2024-01-01 12:00:00’, ‘2024-01-02 15:30:00’, ‘2024-01-03 09:45:00’]
(dates)
pd.to_datetime(dates)
# 从一系列的日期字符串或 datetime 对象创建
dates = ['2024-01-01', '2024-01-02', '2024-01-03']
datetime_index = pd.DatetimeIndex(dates)
print(datetime_index)
# DatetimeIndex(['2024-01-01', '2024-01-02', '2024-01-03'], dtype='datetime64[ns]', freq=None)
datetime_index2 = pd.to_datetime(dates)
print(datetime_index2)
# DatetimeIndex(['2024-01-01', '2024-01-02', '2024-01-03'], dtype='datetime64[ns]', freq=None)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
# 从一系列的日期字符串或 datetime 对象创建
dates = ['2024-01-01 12:00:00', '2024-01-02 15:30:07', '2024-01-03 09:45:00']
datetime_index = pd.to_datetime(dates)
print(datetime_index)
# DatetimeIndex(['2024-01-01 12:00:00', '2024-01-02 15:30:07',
# '2024-01-03 09:45:00'],
# dtype='datetime64[ns]', freq=None)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
2 DatetimeIndex 的基本属性
— 访问年份,返回Index对象
— 访问月份,返回Index对象
— 访问日期,返回Index对象
— 访问小时,返回Index对象
— 访问分钟,返回Index对象
— 访问星期几,返回Index对象
— 访问季度,返回Index对象
# 创建示例 DatetimeIndex
date_range = pd.date_range(start='2024-01-01', end='2024-01-10', freq='D')
print(date_range)
# Index(['2024-01-01', '2024-01-02', '2024-01-03', '2024-01-04', '2024-01-05',
# '2024-01-06', '2024-01-07', '2024-01-08', '2024-01-09', '2024-01-10'],
# dtype='datetime64[ns]', freq='D')
# 访问年份
print(date_range.year)
# Index([2024,2024,2024,2024,2024,2024,2024,2024,2024,2024],dtype='int32')
# 访问月份
print(date_range.month)
# Index([1,1,1,1,1,1,1,1,1,1],dtype='int32')
# 访问日期
print(date_range.day)
# Index([1,2,3,4,5,6,7,8,9,10],dtype='int32')
# 访问小时
print(date_range.hour)
# Index([0,0,0,0,0,0,0,0,0,0],dtype='int32')
# 访问分钟
print(date_range.minute)
# Index([0,0,0,0,0,0,0,0,0,0],dtype='int32')
# 访问星期几 (0 = Monday, ..., 6 = Sunday)
print(date_range.weekday)
# Index([0,1,2,3,4,5,6,0,1,2],dtype='int32')
# 访问季度
print(date_range.quarter)
# Index([1,1,1,1,1,1,1,1,1,1],dtype='int32')
- 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
- 35
3 DatetimeIndex 的切片
【注】：其实就是dataframe或者series的切片
# 创建一个带有 DatetimeIndex 的 DataFrame
data = {'value': range(10)}
df = pd.DataFrame(data, index=pd.date_range('2024-01-01', periods=10))
print(df) # value
# 2024-01-01 0
# 2024-01-02 1
# 2024-01-03 2
# 2024-01-04 3
# 2024-01-05 4
# 2024-01-06 5
# 2024-01-07 6
# 2024-01-08 7
# 2024-01-09 8
# 2024-01-10 9
# 按日期范围切片
print(df['2024-01-03':'2024-01-05']) # value
# 2024-01-03 2
# 2024-01-04 3
# 2024-01-05 4
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
4 DatetimeIndex在Dataframe和Series上的应用(不断转换来转换区)
通过df.reset_index和df.set_index和pd.to_datetime将DatetimeIndex不断变成索引和列
---- 设置为dataframe的索引index时，就是DatetimeIndex
---- 设置为dataframe的一个列就是一个series，不过数据类型是datetime64[ns]
# 创建一个带有 DatetimeIndex 的 DataFrame
data = {'value': range(10)}
df = pd.DataFrame(data, index=pd.date_range('2024-01-01', periods=10))
print(df) # value
# 2024-01-01 0
# 2024-01-02 1
# 2024-01-03 2
# 2024-01-04 3
# 2024-01-05 4
# 2024-01-06 5
# 2024-01-07 6
# 2024-01-08 7
# 2024-01-09 8
# 2024-01-10 9
print(df.index)
# DatetimeIndex(['2024-01-01', '2024-01-02', '2024-01-03', '2024-01-04', '2024-01-05', '2024-01-06', '2024-01-07', '2024-01-08', '2024-01-09', '2024-01-10'], dtype='datetime64[ns]', freq='D')
df = df.reset_index(inplace=False)
print(df) # index value
# 0 2024-01-01 0
# 1 2024-01-02 1
# 2 2024-01-03 2
# 3 2024-01-04 3
# 4 2024-01-05 4
# 5 2024-01-06 5
# 6 2024-01-07 6
# 7 2024-01-08 7
# 8 2024-01-09 8
# 9 2024-01-10 9
print(df['index']) # 0 2024-01-01
# 1 2024-01-02
# 2 2024-01-03
# 3 2024-01-04
# 4 2024-01-05
# 5 2024-01-06
# 6 2024-01-07
# 7 2024-01-08
# 8 2024-01-09
# 9 2024-01-10
# Name: index, dtype: datetime64[ns] # 可以看到 index 列的数据类型是 datetime64[ns]
df['index'] = pd.to_datetime(df['index'])
df = df.set_index('index')
print(df) # value
# index
# 2024-01-01 0
# 2024-01-02 1
# 2024-01-03 2
# 2024-01-04 3
# 2024-01-05 4
# 2024-01-06 5
# 2024-01-07 6
# 2024-01-08 7
# 2024-01-09 8
# 2024-01-10 9
print(df.index)
# DatetimeIndex(['2024-01-01', '2024-01-02', '2024-01-03', '2024-01-04', '2024-01-05', '2024-01-06', '2024-01-07', '2024-01-08', '2024-01-09', '2024-01-10'], dtype='datetime64[ns]', name='index', freq=None)
- 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
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
5 .resample(‘2D’).mean() ---- 重采样技术
【注1】：在 pandas 中进行重采样操作时，确实需要将DataFrame或Series的索引设置为DatetimeIndex，这样才能使用 resample() 方法进行有效的时间序列重采样。如果索引不是DatetimeIndex，则需要先将其转换为DatetimeIndex。
【注2】：该方法必须要和聚合函数一起使用，不然只能返回一个Resampler 对象
# 创建带有日期时间索引的 DataFrame
date_rng = pd.date_range(start='2024-01-01', end='2024-01-10', freq='D')
df = pd.DataFrame({'value': range(len(date_rng))}, index=date_rng)
print(df) # value
# 2024-01-01 0
# 2024-01-02 1
# 2024-01-03 2
# 2024-01-04 3
# 2024-01-05 4
# 2024-01-06 5
# 2024-01-07 6
# 2024-01-08 7
# 2024-01-09 8
# 2024-01-10 9
# 重采样，将数据按照 2 天的频率进行重采样
resample = df.resample('2D').mean()
print(resample) # value
# 2024-01-01 0.5
# 2024-01-03 2.5
# 2024-01-05 4.5
# 2024-01-07 6.5
# 2024-01-09 8.5
# 重采样后的数据是每 2 天的平均值，因此 2024-01-01 的值是 (0+1)/2=0.5，2024-01-03 的值是 (2+3)/2=2.5，以此类推。
# 另外这个('2D')函数需要结合 mean()、sum()、count() 等函数使用，不然只会得到一个 Resampler 对象。
- 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
6 .rolling(window=3).mean() — 时间窗口功能
rolling() 方法在 pandas 中确实需要在时间序列数据上使用，通常这意味着数据帧（DataFrame）或系列（Series）的索引应该是时间戳（Timestamp）或时间序列索引（DatetimeIndex）。
# 创建带有日期时间索引的 DataFrame
date_rng = pd.date_range(start='2024-01-01', end='2024-01-10', freq='D')
df = pd.DataFrame({'value': range(len(date_rng))}, index=date_rng)
print(df) # value
# 2024-01-01 0
# 2024-01-02 1
# 2024-01-03 2
# 2024-01-04 3
# 2024-01-05 4
# 2024-01-06 5
# 2024-01-07 6
# 2024-01-08 7
# 2024-01-09 8
# 2024-01-10 9
# 滚动窗口计算（窗口大小为3）
rolling_mean = df.rolling(window=3).mean()
print(rolling_mean) # value
# 2024-01-01 NaN # 因为需要前两个时间点才能计算窗口内的平均值
# 2024-01-02 NaN # 因为需要前两个时间点才能计算窗口内的平均值
# 2024-01-03 1.0 # (0 + 1 + 2) / 3 = 1.0
# 2024-01-04 2.0 # (1 + 2 + 3) / 3 = 2.0
# 2024-01-05 3.0 # (2 + 3 + 4) / 3 = 3.0
# 2024-01-06 4.0 # (3 + 4 + 5) / 3 = 4.0
# 2024-01-07 5.0 # (4 + 5 + 6) / 3 = 5.0
# 2024-01-08 6.0 # (5 + 6 + 7) / 3 = 6.0
# 2024-01-09 7.0 # (6 + 7 + 8) / 3 = 7.0
# 2024-01-10 8.0 # (7 + 8 + 9) / 3 = 8.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
和卷积平滑有点像：
是的，rolling() 方法和卷积平滑操作在某种程度上是相似的，尤其是在时间序列或者一维数据上的滑动窗口操作时。虽然它们的背景和数学原理有所不同，但在数据处理的实际应用中，它们确实有一些相似之处。
相似之处：
窗口操作： 两者都涉及定义一个窗口大小，在这个窗口内对数据进行统计或变换操作。
滑动性质： 都是在数据集上沿着一个固定的窗口大小移动，逐步处理数据。
平滑效果： 在时间序列分析中，rolling() 方法常用于计算移动平均等，这种平滑效果与一些卷积滤波器在信号处理中的作用相似，都是为了消除短期波动，突出长期趋势或关键特征。
不同之处：
数学基础： rolling() 方法主要依赖 pandas 提供的时间序列功能，通过简单的窗口统计（如平均值、总和等）来处理数据。而卷积平滑操作则更多地基于信号处理中的卷积运算，利用更复杂的卷积核进行数据变换。
应用背景： rolling() 方法通常用于时间序列数据的基本处理和分析，而卷积平滑更多地用于信号处理领域，如音频、图像处理等。
7 .align(ts2, join=‘inner’) ---- 时间对齐高级用法
【注1】：在时间序列处理中，经常需要将两个不同频率的时间序列对齐（align），以便在相同时间点上进行比较或操作。在 pandas 中，可以使用 align() 方法来实现这一对齐操作。将两个表时间对齐后就方便对比相同时间点的差距了。
【注2】：.align（）方法在 pandas 中确实需要在时间序列数据上使用，通常这意味着数据帧（DataFrame）或系列（Series）的索引应该是时间戳（Timestamp）或时间序列索引（DatetimeIndex）。
# 创建两个不同频率的时间序列
ts1 = pd.Series(range(5), index=pd.date_range('2024-01-01', periods=5, freq='D'))
ts2 = pd.Series(range(10), index=pd.date_range('2024-01-03', periods=10, freq='H'))
# print(ts1)
# 2024-01-01 0
# 2024-01-02 1
# 2024-01-03 2
# 2024-01-04 3
# 2024-01-05 4
# Freq: D, dtype: int64
# print(ts2)
# 2024-01-03 00:00:00 0
# 2024-01-03 01:00:00 1
# 2024-01-03 02:00:00 2
# 2024-01-03 03:00:00 3
# 2024-01-03 04:00:00 4
# 2024-01-03 05:00:00 5
# 2024-01-03 06:00:00 6
# 2024-01-03 07:00:00 7
# 2024-01-03 08:00:00 8
# 2024-01-03 09:00:00 9
# Freq: H, dtype: int64
# 通过日期时间索引进行对齐
aligned_ts1, aligned_ts2 = ts1.align(ts2, join='inner') # 这个时间对齐内连接，只保留两个时间序列共有的时间索引，和merge的inner一样
print(aligned_ts1)
# 2024-01-03 2
# dtype: int64
print(aligned_ts2) # 2024-01-03 2
# dtype: int64
# 两个表只有 2024-01-03这个时间点是交集，所以对齐后的结果只有这个时间点的数据
- 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
8 () ---- 时间戳偏移（Shifting）功能：偏移时间序列数据，即向前或向后移动数据点
# 创建带有日期时间索引的 DataFrame
date_rng = pd.date_range(start='2024-01-01', end='2024-01-10', freq='D')
df = pd.DataFrame({'value': range(len(date_rng))}, index=date_rng)
print(df) # value
# 2024-01-01 0
# 2024-01-02 1
# 2024-01-03 2
# 2024-01-04 3
# 2024-01-05 4
# 2024-01-06 5
# 2024-01-07 6
# 2024-01-08 7
# 2024-01-09 8
# 2024-01-10 9
# 向后偏移两天
shifted = df.shift(2)
print(shifted) # value
# 2024-01-01 NaN
# 2024-01-02 NaN
# 2024-01-03 0.0
# 2024-01-04 1.0
# 2024-01-05 2.0
# 2024-01-06 3.0
# 2024-01-07 4.0
# 2024-01-08 5.0
# 2024-01-09 6.0
# 2024-01-10 7.0
# 向前偏移两天
shifted2 = df.shift(-2)
print(shifted2) # value
# 2024-01-01 2.0
# 2024-01-02 3.0
# 2024-01-03 4.0
# 2024-01-04 5.0
# 2024-01-05 6.0
# 2024-01-06 7.0
# 2024-01-07 8.0
# 2024-01-08 9.0
# 2024-01-09 NaN
# 2024-01-10 NaN
- 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
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
总结
pandas的一些常见用法已经写的很详细了—一些不常用用法也给出来简单示例，后面还会继续慢慢完善该博客。