【Python】Pandas详解

Pandas安装：在终端处输入以下命令

pip install pandas

Pandas导入：导入库格式如下：

import pandas as pd

pd.Series(data=None, index=None, dtype=None, name=None, copy=False, fastpath=False)

此处，主要介绍两个常用的参数：

data：表示要创建Series的数据，其类型有以下几种：

列表【data = [10, 20]】

根据索引读取数据：

import pandas as pd

data = ["Google", "Runoob", "Wiki"]
my_series = pd.Series(data) # 索引默认从0开始
# 读取索引为2的数据
print(my_series[2])
----------------------
Wiki
----------------------

Series对象访问：

iloc[]：通过位置索引来选择数据

loc[]：通过标签索引来选择数据

import pandas as pd

data = ["Google", "Runoob", "Wiki"]
my_series = pd.Series(data,index=['a','b','c'])

# 输出Series数据
print(my_series)
print("================================")

# Series对象访问
print(my_series.iloc[0]) # 位置索引
print("================================")
print(my_series.loc['b']) # 标签索引
-------------------------------
a    Google
b    Runoob
c      Wiki
dtype: object
================================
Google
================================
Runoob
-------------------------------

获取index与value：

index ：获取 Series 的索引

index.values：获取 Series 的索引（返回 NumPy 数组）

values：获取 Series 的数据部分（返回 NumPy 数组）

import pandas as pd

data = ["Google", "Runoob", "Wiki"]
my_series = pd.Series(data,index=['a','b','c'])

# 输出Series数据
print(my_series)
print("================================")

# 获取index与value
# 1、获取索引
print(my_series.index)
print("================================")
print(my_series.index.values) # 以list形式输出
print("================================")
# 2、获取值
print(my_series.values)
-----------------------------------------
a    Google
b    Runoob
c      Wiki
dtype: object
================================
Index(['a', 'b', 'c'], dtype='object')
================================
['a' 'b' 'c']
================================
['Google' 'Runoob' 'Wiki']
-----------------------------------------

Series的转换：

to_list()：将 Series 转换为 Python 列表

to_frame()：将 Series 转换为 DataFrame

import pandas as pd

data = ["Google", "Runoob", "Wiki"]
my_series = pd.Series(data,index=['a','b','c'])

# 将Series转换为Python列表
print(my_series.to_list())

print("================================")

# 将Series转换为DataFrame
print(my_series.to_frame())
--------------------------------
['Google', 'Runoob', 'Wiki']
================================
        0
a  Google
b  Runoob
c    Wiki
--------------------------------

df = pd.DataFrame(data=None, index=None, columns=None, dtype=None, copy=False)

此处，主要介绍三个常用的参数：

data参数：表示要创建DataFrame的数据，其类型有以下几种：

二维数组【data = np.array([[1, 2], [3, 4], [5, 6]])】

字典【data = {‘数值列1’: [1, 2, 3], ‘数值列2’: [‘a’, ‘b’, ‘c’]}】

Series对象【data=pd.Series([1,2,3],name=‘数值列’)】

index参数：用于指定DataFrame的索引【行标签】，必须是可迭代对象，其长度应与data的长度一致。若未指定，默认会使用从 0 开始的整数序列作为索引，即：默认索引为0, 1, 2, 3，…，n。【自定义基本写法】：**index=[‘a’, ‘b’, ‘c’] 或 index=[1, 2, 3]**等。

columns参数：【列标签】，即：每列的名称。

获取指定列和指定列：

1、【独有写法】：获取列

df[ '列名' ] ：获取单列

df[[ '列名1' , '列名2' , .... ]] ：获取多列

2、【通用写法】：既可以获取行，也能获取列

iloc[row_indexer, column_indexer] ：按位置索引选择数据

选择单个元素：选择第一行第二列的元素（位置索引从 0 开始），可以使用df.iloc[0, 1]。

选择一行数据：要选择第三行的数据，可使用df.iloc[2, :]，:表示选择所有列。

选择一列数据：若要选择第二列的数据，可通过df.iloc[:, 1]，其中:表示选择所有行。

选择多行多列数据：若要选择第二行到第四行（不包括第四行）、第三列到第五列（不包括第五列）的数据，可使用df.iloc[1:3, 2:4]。

选择不连续的行和列数据：要选择第一行、第三行和第五行，以及第二列和第四列的数据，可通过df.iloc[[0, 2, 4], [1, 3]]来实现。

loc[row_label, column_label] ：按标签索引选择数据

背景：假设df的行索引是['a', 'b', 'c', 'd']，列索引是['col1', 'col2', 'col3']

选择单个元素：选择行标签为'b'、列标签为'col2'的元素，可使用df.loc['b', 'col2']。

选择一行数据：要选择行标签为'c'的一行数据，可使用df.loc['c', :]。

选择一列数据：要选择列标签为'col3'的一列数据，可通过df.loc[:, 'col3']。

选择多行多列数据：若要选择行标签从'a'到'c'（包括'c'）、列标签从'col1'到'col2'（包括'col2'）的数据，可以使用df.loc['a':'c', 'col1':'col2']。

选择不连续的行和列数据：要选择行标签为['a', 'd']、列标签为['col1', 'col3']的数据，可使用df.loc[['a', 'd'], ['col1', 'col3']]。

import pandas as pd

names = list('ABCD')
chinese = [87, 94, 36, 71] # 语文成绩
math = [91, 100, 56, 86] # 数学成绩
english = [48,95,100,76] # 英语成绩
df = pd.DataFrame({'name': names, 'math': math, 'chinese': chinese,'english':english})

# 输出DataFrame数据
print(df)
print("================================")
# 获取多列数据
print(df[['name','english']]) 
print("================================")
# 获取第三行的数据
print(df.iloc[2,:]) 
print("================================")
# 获取行标签从0到2，列标签从math到english的数据
print(df.loc[0:2,'math':'english'])
------------------------------------
  name  math  chinese  english
0    A    91       87       48
1    B   100       94       95
2    C    56       36      100
3    D    86       71       76
================================
  name  english
0    A       48
1    B       95
2    C      100
3    D       76
================================
name         C
math        56
chinese     36
english    100
Name: 2, dtype: object
================================
   math  chinese  english
0    91       87       48
1   100       94       95
2    56       36      100
------------------------------------

DataFrame的遍历：

1、按行遍历：

iterrows () 方法：返回每行的索引和对应的行数据。

import pandas as pd

data = {
    '姓名': ['张三', '李四', '王五'],
    '年龄': [25, 30, 35],
    '城市': ['北京', '上海', '广州']
}
df = pd.DataFrame(data)

for index, row in df.iterrows():
    print(f"索引: {index}, 姓名: {row['姓名']}, 年龄: {row['年龄']}, 城市: {row['城市']}")
--------------------------------------
索引: 0, 姓名: 张三, 年龄: 25, 城市: 北京
索引: 1, 姓名: 李四, 年龄: 30, 城市: 上海
索引: 2, 姓名: 王五, 年龄: 35, 城市: 广州
--------------------------------------

2、按列遍历：

通过直接遍历列名方式

import pandas as pd

data = {
    '姓名': ['张三', '李四', '王五'],
    '年龄': [25, 30, 35],
    '城市': ['北京', '上海', '广州']
}
df = pd.DataFrame(data)

for column in df.columns:
    print(f"列名: {column}, 数据: {df[column].tolist()}")
------------------------------------------
列名: 姓名, 数据: ['张三', '李四', '王五']
列名: 年龄, 数据: [25, 30, 35]
列名: 城市, 数据: ['北京', '上海', '广州']
------------------------------------------

3、按单元格遍历【遍历每一个元素】：

import pandas as pd

data = {
    '姓名': ['张三', '李四', '王五'],
    '年龄': [25, 30, 35],
    '城市': ['北京', '上海', '广州']
}
df = pd.DataFrame(data)

print(df)

for index, row in df.iterrows():
    for column in df.columns:
        print(f"单元格数据: {row[column]}")
-------------------------------------------
单元格数据: 张三
单元格数据: 25
单元格数据: 北京
单元格数据: 李四
单元格数据: 30
单元格数据: 上海
单元格数据: 王五
单元格数据: 35
单元格数据: 广州
-------------------------------------------

DataFrame数据修改：

**1、修改列数据：**直接对列进行赋值。

import numpy as np
import pandas as pd

data = np.array([[1, 2], [3, 4], [5, 6]]) # 数据内容
my_columns=['数值列1','数值列2'] # 列名称【列标签】
my_index=['a','b','c'] # 行名称【行标签】
df=pd.DataFrame(data,index=my_index,columns=my_columns)

# 直接修改原来列
df['数值列1'] = 0

print(df)
------------------------
   数值列1  数值列2
a     0     2
b     0     4
c     0     6
------------------------

2、添加新列：给新列赋值。

import numpy as np
import pandas as pd

data = np.array([[1, 2], [3, 4], [5, 6]]) # 数据内容
my_columns=['数值列1','数值列2'] # 列名称【列标签】
my_index=['a','b','c'] # 行名称【行标签】
df=pd.DataFrame(data,index=my_index,columns=my_columns)

# 给新的列直接赋值
df['数值列3'] = 0

print(df)
-----------------------------
   数值列1  数值列2  数值列3
a     1     2     0
b     3     4     0
c     5     6     0
-----------------------------

3、添加新行：使用 loc、append 或 concat 方法。

import numpy as np
import pandas as pd

data = np.array([[1, 2], [3, 4], [5, 6]]) # 数据内容
my_columns=['数值列1','数值列2'] # 列名称【列标签】
my_index=['a','b','c'] # 行名称【行标签】
df=pd.DataFrame(data,index=my_index,columns=my_columns)

# 通过loc方法添加新行
df.loc[4]=[-1,-1]

print(df)
------------------------------
   数值列1  数值列2
a     1     2
b     3     4
c     5     6
4    -1    -1
------------------------------

DataFrame元素删除：

**1、删除列：**使用 drop 方法【axis=1】。

import numpy as np
import pandas as pd

data = np.array([[1, 2], [3, 4], [5, 6]]) # 数据内容
my_columns=['数值列1','数值列2'] # 列名称【列标签】
my_index=['a','b','c'] # 行名称【行标签】
df=pd.DataFrame(data,index=my_index,columns=my_columns)

# 删除“数值列1”这一列数据
new=df.drop('数值列1',axis=1)

print(new)
------------------------------
   数值列2
a     2
b     4
c     6
------------------------------

**2、删除行：**同样使用 drop 方法【axis=0，默认，可不写】。

import numpy as np
import pandas as pd

data = np.array([[1, 2], [3, 4], [5, 6]]) # 数据内容
my_columns=['数值列1','数值列2'] # 列名称【列标签】
my_index=['a','b','c'] # 行名称【行标签】
df=pd.DataFrame(data,index=my_index,columns=my_columns)

# 删除“a”这一行数据
new=df.drop('a')

print(new)
---------------------------------
   数值列1  数值列2
b     3     4
c     5     6
---------------------------------

通过df.duplicated()函数来检查是否有重复的数据。

通过df.drop_duplicates()函数来删除重复的数据。

日期格式错误：使用 pd.to_datetime 结合 errors='coerce'【无法解析日期会转化为NAN进行处理】与format='mixed'【自动推测日期格式】使用。

import pandas as pd

# 数据：第三个日期格式错误
data = {
    "Date": ['2020/12/01', '2020-12-02', '20201226', 'Invalid Date'],
    "duration": [50, 40, 45, 56]
}

# 创建 DataFrame
df = pd.DataFrame(data, index=["day1", "day2", "day3", "day4"])
# 通过to_datetime对时间数据进行格式处理
df['Date'] = pd.to_datetime(df['Date'], format='mixed',errors='coerce')

# 输出结果
print(df)
-------------------------------------
           Date  duration
day1 2020-12-01        50
day2 2020-12-02        40
day3 2020-12-26        45
day4        NaT        56
-------------------------------------

数值格式错误：若数值列中包含非数字字符（如字符串、符号等），使用 pd.to_numeric 结合 errors='coerce'。

import pandas as pd

# 数据：数值格式错误
data = {
    "Value": ['10', '20', '30.5', '40%', 'NaN', '100']
}

# 创建 DataFrame
df = pd.DataFrame(data)
# 将 'Value' 列转换为数值类型，无法转换的值设为 NaN
df['Value'] = pd.to_numeric(df['Value'], errors='coerce')

# 输出结果
print(df)
---------------------------
   Value
0   10.0
1   20.0
2   30.5
3    NaN
4    NaN
5  100.0
---------------------------

字符串格式错误：若字符串数据中包含多余的空格或特殊字符，使用 str.strip()【去左右空格】、str.replace()【替换】 等方法清理。

import pandas as pd

# 数据：字符串格式错误
data = {
    "Text": ['  Hello  ', 'World!  ', '  Pandas  ', ' 123 ']
}

# 创建 DataFrame
df = pd.DataFrame(data)
df['Text'] = df['Text'].str.strip() # 去除字符串两端的空格
df['Text'] = df['Text'].str.replace('!', '') # 替换特殊字符（如感叹号）

# 输出结果
print(df)
-------------------------------
     Text
0   Hello
1   World
2  Pandas
3     123
-------------------------------

分类数据不一致：数据中包含不一致的值（如大小写不一致、拼写错误等），使用 str.lower() 或 replace() 标准化。

import pandas as pd

# 数据：分类数据不一致
data = {
    "Category": ['apple', 'Apple', 'banana', 'BANANA', 'orange']
}

# 创建 DataFrame
df = pd.DataFrame(data)
# 将分类数据统一为小写
df['Category'] = df['Category'].str.lower()

# 输出结果
print(df)
----------------------------
  Category
0    apple
1    apple
2   banana
3   banana
4   orange
----------------------------

按 Department 列分组，并计算每组的平均工资。

import pandas as pd

# 数据
data = {
    "Department": ["HR", "IT", "HR", "IT", "Finance", "Finance"],
    "Employee": ["Alice", "Bob", "Charlie", "David", "Eva", "Frank"],
    "Age": [25, 30, 20, 35, 28, 40],
    "Salary": [50000, 60000, 45000, 70000, 55000, 80000]
}
# 创建 DataFrame
df = pd.DataFrame(data)

# 分组聚合操作：按照‘Department’分组，并计算每组的平均工资
avg_df=df.groupby('Department')['Salary'].mean()

print(avg_df)
------------------------------------------
Department
Finance    67500.0
HR         47500.0
IT         65000.0
Name: Salary, dtype: float64
------------------------------------------

按 Department 和 Age 列分组，并计算每组的工资总和。

import pandas as pd

# 数据
data = {
    "Department": ["HR", "IT", "HR", "IT", "Finance", "Finance"],
    "Employee": ["Alice", "Bob", "Charlie", "David", "Eva", "Frank"],
    "Age": [25, 30, 25, 35, 28, 28],
    "Salary": [50000, 60000, 45000, 70000, 55000, 80000]
}

# 创建 DataFrame
df = pd.DataFrame(data)

print(df)

# 分组聚合操作：按照‘Department’和'Age'分组，并计算每组的总工资
sum_df=df.groupby(['Department','Age'])['Salary'].sum()

print(sum_df)
-------------------------------------
Department  Age
Finance     28     135000
HR          25      95000
IT          30      60000
            35      70000
Name: Salary, dtype: int64
-------------------------------------

按 Department 列分组，并对 Age 和 Salary 列应用不同的聚合函数。

import pandas as pd

# 数据
data = {
    "Department": ["HR", "IT", "HR", "IT", "Finance", "Finance"],
    "Employee": ["Alice", "Bob", "Charlie", "David", "Eva", "Frank"],
    "Age": [25, 30, 25, 35, 28, 28],
    "Salary": [50000, 60000, 45000, 70000, 55000, 80000]
}

# 创建 DataFrame
df = pd.DataFrame(data)

# 分组聚合操作：按照‘Department’分组，并对 'Age' 和 'Salary' 列应用不同的聚合函数
agg_df=df.groupby('Department').agg({
    'Age' : 'mean', # 计算平均年龄
    'Salary' : ['min','max','sum'] # 计算工资的最小值、最大值和总和
}) 

print(agg_df)
-----------------------------------------------
            mean    min    max     sum
Department                            
Finance     28.0  55000  80000  135000
HR          25.0  45000  50000   95000
IT          32.5  60000  70000  130000
-----------------------------------------------

按 Department 列分组，并应用自定义聚合函数。

import pandas as pd

# 示例数据
data = {
    "Department": ["HR", "IT", "HR", "IT", "Finance", "Finance"],
    "Employee": ["Alice", "Bob", "Charlie", "David", "Eva", "Frank"],
    "Age": [25, 30, 25, 35, 28, 28],
    "Salary": [50000, 60000, 45000, 70000, 55000, 80000]
}

# 创建 DataFrame
df = pd.DataFrame(data)

# 自定义聚合函数：计算工资范围（最大值 - 最小值）
def salary_range(x):
    return x.max() - x.min()

# 按 'Department' 列分组，并应用自定义聚合函数
grouped_df = df.groupby('Department')['Salary'].agg(salary_range)

print(grouped_df)

创建时间序列和时间范围：使用 pd.to_datetime()。

import pandas as pd

# 将字符串转换为时间戳
dates = pd.to_datetime(['2025-01-01', '2025-02-01'])
print(dates)
---------------------------------------------------------------------------
DatetimeIndex(['2025-01-01', '2025-02-01'], dtype='datetime64[ns]', freq=None)
---------------------------------------------------------------------------

创建时间范围：使用pd.date_range()。

基本格式：pd.date_range(start=None, end=None, periods=None, freq='D', ...)

start：起始日期（字符串或 datetime 对象）。

end：结束日期（字符串或 datetime 对象）。

periods：生成的日期数量。

freq：日期频率（如 'D' 表示每日，'M' 表示每月）。

import pandas as pd

# 将字符串转换为时间戳
date_range = pd.date_range(start='2025-01-01',end='2025-01-27',freq='D')
print(date_range)
------------------------------------------------------------------
DatetimeIndex(['2025-01-01', '2025-01-02', '2025-01-03', '2025-01-04',
               '2025-01-05', '2025-01-06', '2025-01-07', '2025-01-08',
               '2025-01-09', '2025-01-10', '2025-01-11', '2025-01-12',
               '2025-01-13', '2025-01-14', '2025-01-15', '2025-01-16',
               '2025-01-17', '2025-01-18', '2025-01-19', '2025-01-20',
               '2025-01-21', '2025-01-22', '2025-01-23', '2025-01-24',
               '2025-01-25', '2025-01-26', '2025-01-27'],
              dtype='datetime64[ns]', freq='D')
------------------------------------------------------------------

设置时间索引：将时间列设置为索引。

import pandas as pd

# 数据
data = {
    "Date": ['2025-01-01', '2025-01-02', '2025-01-03'],
    "Value": [10, 20, 30]
}
# 创建 DataFrame
df = pd.DataFrame(data)

# 将 'Date' 列转换为时间戳并设置为索引
df['Date'] = pd.to_datetime(df['Date']) # 转化为时间错
df.set_index('Date', inplace=True) # 设置为索引

print(df)
-----------------------------------
            Value
Date             
2025-01-01     10
2025-01-02     20
2025-01-03     30
-----------------------------------

时间序列的索引和切片：按时间索引选择数据或按时间范围切片。

1、按时间索引选择数据

import pandas as pd

# 示例数据
data = {
    "Date": ['2025-01-01', '2025-01-02', '2025-01-03'],
    "Value": [10, 20, 30]
}
# 创建 DataFrame
df = pd.DataFrame(data)

# 将 'Date' 列转换为时间戳并设置为索引
df['Date'] = pd.to_datetime(df['Date']) # 转化为时间错
df.set_index('Date', inplace=True) # 设置为索引

# 选择 2023 年 1 月 2 日的数据
selected_data = df.loc['2025-01-02']
print(selected_data)
------------------------------------------
Value    20
Name: 2025-01-02 00:00:00, dtype: int64
------------------------------------------

2、 按时间范围切片

import pandas as pd

# 示例数据
data = {
    "Date": ['2025-01-01', '2025-01-02', '2025-01-03'],
    "Value": [10, 20, 30]
}
# 创建 DataFrame
df = pd.DataFrame(data)

# 将 'Date' 列转换为时间戳并设置为索引
df['Date'] = pd.to_datetime(df['Date']) # 转化为时间错
df.set_index('Date', inplace=True) # 设置为索引

# 选择 2025 年 1 月 1 日到 2025 年 1 月 2 日的数据
range_data = df['2025-01-01':'2025-01-02']
print(range_data)
-------------------------------------
            Value
Date             
2025-01-01     10
2025-01-02     20
-------------------------------------

重采样：使用 resample() 进行降采样或升采样。

1）基本含义：它可以将时间序列数据从一个频率转换为另一个频率，并允许在重采样过程中应用聚合函数（如求和、均值等）。

2）基本格式：df.resample(rule, axis=0, closed=None, label=None, ...)

rule：重采样的频率规则。

规则	描述
'D'	每日
'W'	每周
'M'	每月
'Q'	每季度
'A' 或 'Y'	每年
'H'	每小时
'T' 或 'min'	每分钟
'S'	每秒

axis：重采样的轴，默认为 0（按行重采样）。

closed：指定区间的闭合方式（'left' 或 'right'）。

label：指定区间的标签位置（'left' 或 'right'）。

3）实际应用：

(1) 降采样（Downsampling）

将高频数据转换为低频数据（如每日数据 → 每月数据）。

具体案例：

import pandas as pd

# 数据
# 日期从2025-1-1开始，生成10个
# 值从0到9，共10个
data = {
    "Date": pd.date_range(start='2025-01-01', periods=10, freq='D'),
    "Value": range(10)
}

# 创建 DataFrame,并将 'Date' 列转换为时间戳并设置为索引
df = pd.DataFrame(data)
df.set_index('Date', inplace=True)

# 降采样: 按周重采样并计算每周的和（每日的日期 -> 每周的日期）
downsampling_df = df.resample('W').sum()

print(downsampling_df)
---------------------------------
            Value
Date             
2025-01-01      0
2025-01-08     28
2025-01-15     17
---------------------------------

(2) 升采样（Upsampling）

将低频数据转换为高频数据（如每月数据 → 每日数据）。

填充方法汇总：

方法	具体操作	适用场景	优点	缺点
前向填充	df.resample('h').ffill()	数据变化平滑	简单快速	可能引入偏差
后向填充	df.resample('h').bfill()	数据变化平滑	简单快速	可能引入偏差
插值填充	df.resample('h').interpolate()	数据连续且平滑	填充结果较为准确	计算复杂度较高
固定值填充	df.resample('h').fillna(0)	缺失值有明确含义	简单直接	可能不符合实际数据分布
均值/中位数/众数填充	df.resample('h').fillna(df.sum())	数据分布均匀	简单快速	可能不符合实际数据变化
最近邻填充	df.resample('h').fillna(method='nearest')	数据变化离散	简单快速	可能引入噪声
不填充	df.resample('h').asfreq()	需要后续处理缺失值	保留原始信息	需要额外处理缺失值
混合填充	df.resample('h').ffill().interpolate()	数据变化复杂	结合多种方法优势	实现复杂
基于模型的填充	机器学习模型（如回归模型、时间序列模型）预测缺失值	数据变化复杂且需要高精度填充	填充结果较为准确	实现复杂，计算成本高

具体案例：

import pandas as pd

# 数据
# 日期从2025-1-1开始，生成3个
data = {
    "Date": pd.date_range(start='2025-01-01', periods=3, freq='D'),
    "Value": [10,20,30]
}

# 创建 DataFrame,并将 'Date' 列转换为时间戳并设置为索引
df = pd.DataFrame(data)
df.set_index('Date', inplace=True)

# 降采样: 按小时重采样并插值填充缺失值（每日的日期 -> 每小时的日期）
# interpolate()：插值填充
resampled = df.resample('h').interpolate()

print(resampled)
-------------------------------------------
                         Value
Date                          
2025-01-01 00:00:00  10.000000
2025-01-01 01:00:00  10.416667
2025-01-01 02:00:00  10.833333
2025-01-01 03:00:00  11.250000
2025-01-01 04:00:00  11.666667
2025-01-01 05:00:00  12.083333
2025-01-01 06:00:00  12.500000
2025-01-01 07:00:00  12.916667
2025-01-01 08:00:00  13.333333
2025-01-01 09:00:00  13.750000
2025-01-01 10:00:00  14.166667
2025-01-01 11:00:00  14.583333
2025-01-01 12:00:00  15.000000
2025-01-01 13:00:00  15.416667
2025-01-01 14:00:00  15.833333
2025-01-01 15:00:00  16.250000
2025-01-01 16:00:00  16.666667
2025-01-01 17:00:00  17.083333
2025-01-01 18:00:00  17.500000
2025-01-01 19:00:00  17.916667
2025-01-01 20:00:00  18.333333
2025-01-01 21:00:00  18.750000
2025-01-01 22:00:00  19.166667
2025-01-01 23:00:00  19.583333
2025-01-02 00:00:00  20.000000
2025-01-02 01:00:00  20.416667
2025-01-02 02:00:00  20.833333
2025-01-02 03:00:00  21.250000
2025-01-02 04:00:00  21.666667
2025-01-02 05:00:00  22.083333
2025-01-02 06:00:00  22.500000
2025-01-02 07:00:00  22.916667
2025-01-02 08:00:00  23.333333
2025-01-02 09:00:00  23.750000
2025-01-02 10:00:00  24.166667
2025-01-02 11:00:00  24.583333
2025-01-02 12:00:00  25.000000
2025-01-02 13:00:00  25.416667
2025-01-02 14:00:00  25.833333
2025-01-02 15:00:00  26.250000
2025-01-02 16:00:00  26.666667
2025-01-02 17:00:00  27.083333
2025-01-02 18:00:00  27.500000
2025-01-02 19:00:00  27.916667
2025-01-02 20:00:00  28.333333
2025-01-02 21:00:00  28.750000
2025-01-02 22:00:00  29.166667
2025-01-02 23:00:00  29.583333
2025-01-03 00:00:00  30.000000
-------------------------------------------

滑动窗口操作：使用 rolling() 和 expanding() 进行滚动或扩展窗口计算。

1）滚动窗口（滑动窗口）

基本格式：df['column_name'].rolling(window=window_size)

import pandas as pd

# 创建示例数据框
data = {'value': [1, 2, 3, 4, 5]}
df = pd.DataFrame(data)

# 创建rolling对象 并 计算滚动的平均【窗口长度为3】
rolling_mean = df['value'].rolling(window=3).mean()
print(rolling_mean)
---------------------------------
0    NaN
1    NaN
2    2.0	# 1,2,3 => (1+2+3)/3
3    3.0	# 2,3,4 => (2+3+4)/3
4    4.0	# 3,4,5 => (3+4+5)/3
Name: value, dtype: float64
---------------------------------

2）扩展窗口

基本格式：

import pandas as pd

# 创建示例数据框
data = {'value': [1, 2, 3, 4, 5]}
df = pd.DataFrame(data)

# 创建expanding对象 并 计算扩展平均
expanding_mean = df['value'].expanding().mean()
print(expanding_mean)
-----------------------------------
0    1.0	# 1 => 1/1
1    1.5	# 1,2 => (1+2)/2
2    2.0	# 1,2,3 => (1+2+3)/3
3    2.5	# 1,2,3,4 => (1+2+3+4)/4
4    3.0	# 1,2,3,4,5 => (1+2+3+4+5)/5
Name: value, dtype: float64
-----------------------------------

时间偏移：使用 pd.DateOffset 进行时间偏移。

import pandas as pd

date = pd.to_datetime('2025-01-01')
# 偏移 2 小时
new_date = date + pd.DateOffset(hour=2)

print(new_date)
--------------------------
2023-01-01 02:00:00
--------------------------