本文围绕Pandas中Timedelta展开，介绍了其解析方法，如通过多种参数构造、使用to_timedelta函数转换；说明了运算、减少、频率转换等操作；还提及了属性访问、TimedeltaIndex的生成与使用等内容，最后给出Pandas 2使用指南导读。
文章目录
时间差是指时间之间的差异，以不同的单位表示，例如天、小时、分钟、秒。它们可以是正数也可以是负数。
Timedelta 是 datetime.timedelta 的子类，行为类似，但允许与 np.timedelta64 类型兼容，以及一系列自定义的表示、解析和属性。
解析
您可以通过各种参数构造 Timedelta 标量，包括 ISO 8601 时长 字符串。
import datetime
# 字符串
pd.Timedelta("1 days")
Out[2]: Timedelta('1 days 00:00:00')
pd.Timedelta("1 days 00:00:00")
Out[3]: Timedelta('1 days 00:00:00')
pd.Timedelta("1 days 2 hours")
Out[4]: Timedelta('1 days 02:00:00')
pd.Timedelta("-1 days 2 min 3us")
Out[5]: Timedelta('-2 days +23:57:59.999997')
# 类似于 datetime.timedelta
# 注意：这些必须指定为关键字参数
pd.Timedelta(days=1, seconds=1)
Out[6]: Timedelta('1 days 00:00:01')
# 带单位的整数
pd.Timedelta(1, unit="d")
Out[7]: Timedelta('1 days 00:00:00')
# 从 datetime.timedelta/np.timedelta64
pd.Timedelta(datetime.timedelta(days=1, seconds=1))
Out[8]: Timedelta('1 days 00:00:01')
pd.Timedelta(np.timedelta64(1, "ms"))
Out[9]: Timedelta('0 days 00:00:00.001000')
# 负的 Timedelta 的字符串表示
# 为了与 datetime.timedelta 的约定更加一致
pd.Timedelta("-1us")
Out[10]: Timedelta('-1 days +23:59:59.999999')
# NaT
pd.Timedelta("nan")
Out[11]: NaT
pd.Timedelta("nat")
Out[12]: NaT
# ISO 8601 时长字符串
pd.Timedelta("P0DT0H1M0S")
Out[13]: Timedelta('0 days 00:01:00')
pd.Timedelta("P0DT0H0M0.000000123S")
Out[14]: Timedelta('0 days 00:00:00.000000123')
DateOffsets（Day, Hour, Minute, Second, Milli, Micro, Nano）也可以用于构造。
pd.Timedelta(pd.offsets.Second(2))
Out[15]: Timedelta('0 days 00:00:02')
此外，标量之间的运算会产生另一个标量 Timedelta。
pd.Timedelta(pd.offsets.Day(2)) + pd.Timedelta(pd.offsets.Second(2)) + pd.Timedelta(
"00:00:00.000123"
)
Out[16]: Timedelta('2 days 00:00:02.000123')
to_timedelta
使用顶级函数 pd.to_timedelta，您可以将识别的时间差格式/值转换为 Timedelta 类型的标量、数组、列表或 Series。如果输入是 Series，则会构造 Series；如果输入是标量类似物，则会构造标量；否则，将输出 TimedeltaIndex。
您可以将单个字符串解析为 Timedelta：
pd.to_timedelta("1 days 06:05:01.00003")
Out[17]: Timedelta('1 days 06:05:01.000030')
pd.to_timedelta("15.5us")
Out[18]: Timedelta('0 days 00:00:00.000015500')
或者字符串的列表/数组：
pd.to_timedelta(["1 days 06:05:01.00003", "15.5us", "nan"])
Out[19]: TimedeltaIndex(['1 days 06:05:01.000030', '0 days 00:00:00.000015500', NaT], dtype='timedelta64[ns]', freq=None)
如果输入是数字，则 unit 关键字参数指定 Timedelta 的单位：
pd.to_timedelta(np.arange(5), unit="s")
Out[20]:
TimedeltaIndex(['0 days 00:00:00', '0 days 00:00:01', '0 days 00:00:02',
'0 days 00:00:03', '0 days 00:00:04'],
dtype='timedelta64[ns]', freq=None)
pd.to_timedelta(np.arange(5), unit="d")
Out[21]: TimedeltaIndex(['0 days', '1 days', '2 days', '3 days', '4 days'], dtype='timedelta64[ns]', freq=None)
警告
如果将字符串或字符串数组作为输入，则将忽略 unit 关键字参数。如果传递的是没有单位的字符串，则默认单位为纳秒。
Timedelta 的限制
pandas 使用 64 位整数以纳秒分辨率表示 Timedeltas。因此，64 位整数的限制决定了 Timedelta 的限制。
pd.Timedelta.min
Out[22]: Timedelta('-106752 days +00:12:43.145224193')
pd.Timedelta.max
Out[23]: Timedelta('106751 days 23:47:16.854775807')
运算
您可以对 Series/DataFrames 进行运算，并通过对 datetime64[ns] Series 或 Timestamps 进行减法运算构造 timedelta64[ns] Series。
s = pd.Series(pd.date_range("2012-1-1", periods=3, freq="D"))
td = pd.Series([pd.Timedelta(days=i) for i in range(3)])
df = pd.DataFrame({"A": s, "B": td})
df
Out[27]:
A B
0 2012-01-01 0 days
1 2012-01-02 1 days
2 2012-01-03 2 days
df["C"] = df["A"] + df["B"]
df
Out[29]:
A B C
0 2012-01-01 0 days 2012-01-01
1 2012-01-02 1 days 2012-01-03
2 2012-01-03 2 days 2012-01-05
df.dtypes
Out[30]:
A datetime64[ns]
B timedelta64[ns]
C datetime64[ns]
dtype: object
s - s.max()
Out[31]:
0 -2 days
1 -1 days
2 0 days
dtype: timedelta64[ns]
s - datetime.datetime(2011, 1, 1, 3, 5)
Out[32]:
0 364 days 20:55:00
1 365 days 20:55:00
2 366 days 20:55:00
dtype: timedelta64[ns]
s + datetime.timedelta(minutes=5)
Out[33]:
0 2012-01-01 00:05:00
1 2012-01-02 00:05:00
2 2012-01-03 00:05:00
dtype: datetime64[ns]
s + pd.offsets.Minute(5)
Out[34]:
0 2012-01-01 00:05:00
1 2012-01-02 00:05:00
2 2012-01-03 00:05:00
dtype: datetime64[ns]
s + pd.offsets.Minute(5) + pd.offsets.Milli(5)
Out[35]:
0 2012-01-01 00:05:00.005
1 2012-01-02 00:05:00.005
2 2012-01-03 00:05:00.005
dtype: datetime64[ns]
与 timedelta64[ns] Series 进行运算的标量：
y = s - s[0]
y
Out[37]:
0 0 days
1 1 days
2 2 days
dtype: timedelta64[ns]
支持带有 NaT 值的时间差 Series：
y = s - s.shift()
y
Out[39]:
0 NaT
1 1 days
2 1 days
dtype: timedelta64[ns]
元素可以使用 np.nan 设置为 NaT，类似于日期时间：
y[1] = np.nan
y
Out[41]:
0 NaT
1 NaT
2 1 days
dtype: timedelta64[ns]
操作数也可以以相反的顺序出现（一个对象与 Series 进行运算）：
s.max() - s
Out[42]:
0 2 days
1 1 days
2 0 days
dtype: timedelta64[ns]
datetime.datetime(2011, 1, 1, 3, 5) - s
Out[43]:
0 -365 days +03:05:00
1 -366 days +03:05:00
2 -367 days +03:05:00
dtype: timedelta64[ns]
datetime.timedelta(minutes=5) + s
Out[44]:
0 2012-01-01 00:05:00
1 2012-01-02 00:05:00
2 2012-01-03 00:05:00
dtype: datetime64[ns]
在框架上支持 min, max 和相应的 idxmin, idxmax 操作：
A = s - pd.Timestamp("20120101") - pd.Timedelta("00:05:05")
B = s - pd.Series(pd.date_range("2012-1-2", periods=3, freq="D"))
df = pd.DataFrame({"A": A, "B": B})
df
Out[48]:
A B
0 -1 days +23:54:55 -1 days
1 0 days 23:54:55 -1 days
2 1 days 23:54:55 -1 days
df.min()
Out[49]:
A -1 days +23:54:55
B -1 days +00:00:00
dtype: timedelta64[ns]
df.min(axis=1)
Out[50]:
0 -1 days
1 -1 days
2 -1 days
dtype: timedelta64[ns]
df.idxmin()
Out[51]:
A 0
B 0
dtype: int64
df.idxmax()
Out[52]:
A 2
B 0
dtype: int64
在 Series 上也支持 min, max, idxmin, idxmax 操作。标量结果将是 Timedelta。
df.min().max()
Out[53]: Timedelta('-1 days +23:54:55')
df.min(axis=1).min()
Out[54]: Timedelta('-1 days +00:00:00')
df.min().idxmax()
Out[55]: 'A'
df.min(axis=1).idxmin()
Out[56]: 0
您可以使用 fillna 在时间差上填充值，传递一个时间差以获取特定的值。
y.fillna(pd.Timedelta(0))
Out[57]:
0 0 days
1 0 days
2 1 days
dtype: timedelta64[ns]
y.fillna(pd.Timedelta(10, unit="s"))
Out[58]:
0 0 days 00:00:10
1 0 days 00:00:10
2 1 days 00:00:00
dtype: timedelta64[ns]
y.fillna(pd.Timedelta("-1 days, 00:00:05"))
Out[59]:
0 -1 days +00:00:05
1 -1 days +00:00:05
2 1 days 00:00:00
dtype: timedelta64[ns]
您还可以对 Timedeltas 进行取反、乘法和使用 abs：
td1 = pd.Timedelta("-1 days 2 hours 3 seconds")
td1
Out[61]: Timedelta('-2 days +21:59:57')
-1 * td1
Out[62]: Timedelta('1 days 02:00:03')
-td1
Out[63]: Timedelta('1 days 02:00:03')
abs(td1)
Out[64]: Timedelta('1 days 02:00:03')
减少
对 timedelta64[ns] 的数值减少操作将返回 Timedelta 对象。通常情况下，NaT 在计算过程中会被跳过。
y2 = pd.Series(
pd.to_timedelta(["-1 days +00:00:05", "nat", "-1 days +00:00:05", "1 days"])
)
y2
Out[66]:
0 -1 days +00:00:05
1 NaT
2 -1 days +00:00:05
3 1 days 00:00:00
dtype: timedelta64[ns]
y2.mean()
Out[67]: Timedelta('-1 days +16:00:03.333333334')
y2.median()
Out[68]: Timedelta('-1 days +00:00:05')
y2.quantile(0.1)
Out[69]: Timedelta('-1 days +00:00:05')
y2.sum()
Out[70]: Timedelta('-1 days +00:00:10')
频率转换
可以通过将其转换为特定的 timedelta dtype 来将 Timedelta Series、TimedeltaIndex 和 Timedelta 转换为其他频率。
december = pd.Series(pd.date_range("20121201", periods=4))
january = pd.Series(pd.date_range("20130101", periods=4))
td = january - december
td[2] += datetime.timedelta(minutes=5, seconds=3)
td[3] = np.nan
td
Out[76]:
0 31 days 00:00:00
1 31 days 00:00:00
2 31 days 00:05:03
3 NaT
dtype: timedelta64[ns]
# 转换为秒
td.astype("timedelta64[s]")
Out[77]:
0 31 days 00:00:00
1 31 days 00:00:00
2 31 days 00:05:03
3 NaT
dtype: timedelta64[s]
对于除了支持的“s”、“ms”、“us”、“ns”之外的 timedelta64 分辨率，可以通过除以另一个 timedelta 对象来实现。注意，除以 NumPy 标量是真除法，而 astyping 相当于地板除法。
# 转换为天
td / np.timedelta64(1, "D")
Out[78]:
0 31.000000
1 31.000000
2 31.003507
3 NaN
dtype: float64
将 timedelta64[ns] Series 除以整数或整数 Series，将得到另一个 timedelta64[ns] dtypes Series。
td * -1
Out[79]:
0 -31 days +00:00:00
1 -31 days +00:00:00
2 -32 days +23:54:57
3 NaT
dtype: timedelta64[ns]
td * pd.Series([1, 2, 3, 4])
Out[80]:
0 31 days 00:00:00
1 62 days 00:00:00
2 93 days 00:15:09
3 NaT
dtype: timedelta64[ns]
timedelta64[ns] 类型的 Series 除以一个标量 Timedelta 会得到一个整数的 Series。
td // pd.Timedelta(days=3, hours=4)
Out[81]:
0 9.0
1 9.0
2 9.0
3 NaN
dtype: float64
pd.Timedelta(days=3, hours=4) // td
Out[82]:
0 0.0
1 0.0
2 0.0
3 NaN
dtype: float64
当 Timedelta 与另一个 timedelta-like 或数字参数进行运算时，可以使用 mod(%) 和 divmod 操作。
pd.Timedelta(hours=37) % datetime.timedelta(hours=2)
Out[83]: Timedelta('0 days 01:00:00')
# 对 timedelta-like 进行 divmod 运算会返回一对 (int, Timedelta)
divmod(datetime.timedelta(hours=2), pd.Timedelta(minutes=11))
Out[84]: (10, Timedelta('0 days 00:10:00'))
# 对数字进行 divmod 运算会返回一对 (Timedelta, Timedelta)
divmod(pd.Timedelta(hours=25), 86400000000000)
Out[85]: (Timedelta('0 days 00:00:00.000000001'), Timedelta('0 days 01:00:00'))
属性
您可以使用属性 days, seconds, microseconds, nanoseconds 直接访问 Timedelta 或 TimedeltaIndex 的各个组成部分。这些属性与 datetime.timedelta 返回的值相同，例如，.seconds 属性表示大于等于 0 且小于 1 天的秒数。这些属性的符号取决于 Timedelta 是否有符号。
这些操作也可以通过 Series 的 .dt 属性直接访问。
注意
请注意，属性不是 Timedelta 的显示值。使用 .components 获取显示值。
对于 Series：
td.dt.days
Out[86]:
0 31.0
1 31.0
2 31.0
3 NaN
dtype: float64
td.dt.seconds
Out[87]:
0 0.0
1 0.0
2 303.0
3 NaN
dtype: float64
您可以直接访问标量 Timedelta 的字段值。
tds = pd.Timedelta("31 days 5 min 3 sec")
tds.days
Out[89]: 31
tds.seconds
Out[90]: 303
(-tds).seconds
Out[91]: 86097
您可以使用 .components 属性访问 Timedelta 的简化形式。它返回一个与 Series 类似索引的 DataFrame。这些是 Timedelta 的显示值。
td.dt.components
Out[92]:
days hours minutes seconds milliseconds microseconds nanoseconds
0 31.0 0.0 0.0 0.0 0.0 0.0 0.0
1 31.0 0.0 0.0 0.0 0.0 0.0 0.0
2 31.0 0.0 5.0 3.0 0.0 0.0 0.0
3 NaN NaN NaN NaN NaN NaN NaN
td.dt.components.seconds
Out[93]:
0 0.0
1 0.0
2 3.0
3 NaN
Name: seconds, dtype: float64
您可以使用 .isoformat 方法将 Timedelta 转换为 ISO 8601 Duration 字符串。
pd.Timedelta(
days=6, minutes=50, seconds=3, milliseconds=10, microseconds=10, nanoseconds=12
).isoformat()
Out[94]: 'P6DT0H50M3.010010012S'
TimedeltaIndex
要生成一个带有时间差的索引，可以使用 TimedeltaIndex 或 timedelta_range() 构造函数。
使用 TimedeltaIndex，您可以传递类似字符串、Timedelta、timedelta 或 np.timedelta64 的对象。传递 np.nan/pd.NaT/nat 将表示缺失值。
pd.TimedeltaIndex(
[
"1 days",
"1 days, 00:00:05",
np.timedelta64(2, "D"),
datetime.timedelta(days=2, seconds=2),
]
)
Out[95]:
TimedeltaIndex(['1 days 00:00:00', '1 days 00:00:05', '2 days 00:00:00',
'2 days 00:00:02'],
dtype='timedelta64[ns]', freq=None)
可以传递字符串 “infer” 以将索引的频率设置为创建时的推断频率：
pd.TimedeltaIndex(["0 days", "10 days", "20 days"], freq="infer")
Out[96]: TimedeltaIndex(['0 days', '10 days', '20 days'], dtype='timedelta64[ns]', freq='10D')
生成时间差范围
与 date_range() 类似，您可以使用 timedelta_range() 构造函数构造 TimedeltaIndex 的常规范围。timedelta_range 的默认频率是日历天：
pd.timedelta_range(start="1 days", periods=5)
Out[97]: TimedeltaIndex(['1 days', '2 days', '3 days', '4 days', '5 days'], dtype='timedelta64[ns]', freq='D')
timedelta_range 可以与 start、end 和 periods 的各种组合一起使用：
pd.timedelta_range(start="1 days", end="5 days")
Out[98]: TimedeltaIndex(['1 days', '2 days', '3 days', '4 days', '5 days'], dtype='timedelta64[ns]', freq='D')
pd.timedelta_range(end="10 days", periods=4)
Out[99]: TimedeltaIndex(['7 days', '8 days', '9 days', '10 days'], dtype='timedelta64[ns]', freq='D')
freq 参数可以传递各种 频率别名：
pd.timedelta_range(start="1 days", end="2 days", freq="30min")
Out[100]:
TimedeltaIndex(['1 days 00:00:00', '1 days 00:30:00', '1 days 01:00:00',
'1 days 01:30:00', '1 days 02:00:00', '1 days 02:30:00',
'1 days 03:00:00', '1 days 03:30:00', '1 days 04:00:00',
'1 days 04:30:00', '1 days 05:00:00', '1 days 05:30:00',
'1 days 06:00:00', '1 days 06:30:00', '1 days 07:00:00',
'1 days 07:30:00', '1 days 08:00:00', '1 days 08:30:00',
'1 days 09:00:00', '1 days 09:30:00', '1 days 10:00:00',
'1 days 10:30:00', '1 days 11:00:00', '1 days 11:30:00',
'1 days 12:00:00', '1 days 12:30:00', '1 days 13:00:00',
'1 days 13:30:00', '1 days 14:00:00', '1 days 14:30:00',
'1 days 15:00:00', '1 days 15:30:00', '1 days 16:00:00',
'1 days 16:30:00', '1 days 17:00:00', '1 days 17:30:00',
'1 days 18:00:00', '1 days 18:30:00', '1 days 19:00:00',
'1 days 19:30:00', '1 days 20:00:00', '1 days 20:30:00',
'1 days 21:00:00', '1 days 21:30:00', '1 days 22:00:00',
'1 days 22:30:00', '1 days 23:00:00', '1 days 23:30:00',
'2 days 00:00:00'],
dtype='timedelta64[ns]', freq='30min')
pd.timedelta_range(start="1 days", periods=5, freq="2D5h")
Out[101]:
TimedeltaIndex(['1 days 00:00:00', '3 days 05:00:00', '5 days 10:00:00',
'7 days 15:00:00', '9 days 20:00:00'],
dtype='timedelta64[ns]', freq='53h')
指定 start、end 和 periods 将从 start 到 end（包括 end）生成一系列均匀间隔的时间差，结果为 TimedeltaIndex 中的 periods 个元素：
pd.timedelta_range("0 days", "4 days", periods=5)
Out[102]: TimedeltaIndex(['0 days', '1 days', '2 days', '3 days', '4 days'], dtype='timedelta64[ns]', freq=None)
pd.timedelta_range("0 days", "4 days", periods=10)
Out[103]:
TimedeltaIndex(['0 days 00:00:00', '0 days 10:40:00', '0 days 21:20:00',
'1 days 08:00:00', '1 days 18:40:00', '2 days 05:20:00',
'2 days 16:00:00', '3 days 02:40:00', '3 days 13:20:00',
'4 days 00:00:00'],
dtype='timedelta64[ns]', freq=None)
使用 TimedeltaIndex
与其他类似日期时间的索引（DatetimeIndex 和 PeriodIndex）一样，您可以将 TimedeltaIndex 用作 pandas 对象的索引。
s = pd.Series(
np.arange(100),
index=pd.timedelta_range("1 days", periods=100, freq="h"),
)
s
Out[105]:
1 days 00:00:00 0
1 days 01:00:00 1
1 days 02:00:00 2
1 days 03:00:00 3
1 days 04:00:00 4
..
4 days 23:00:00 95
5 days 00:00:00 96
5 days 01:00:00 97
5 days 02:00:00 98
5 days 03:00:00 99
Freq: h, Length: 100, dtype: int64
选择操作类似，字符串类的选择会进行强制转换：
s["1 day":"2 day"]
Out[106]:
1 days 00:00:00 0
1 days 01:00:00 1
1 days 02:00:00 2
1 days 03:00:00 3
1 days 04:00:00 4
..
2 days 19:00:00 43
2 days 20:00:00 44
2 days 21:00:00 45
2 days 22:00:00 46
2 days 23:00:00 47
Freq: h, Length: 48, dtype: int64
s["1 day 01:00:00"]
Out[107]: 1
s[pd.Timedelta("1 day 1h")]
Out[108]: 1
此外，您可以使用部分字符串选择，范围将被推断：
s["1 day":"1 day 5 hours"]
Out[109]:
1 days 00:00:00 0
1 days 01:00:00 1
1 days 02:00:00 2
1 days 03:00:00 3
1 days 04:00:00 4
1 days 05:00:00 5
Freq: h, dtype: int64
操作
最后，TimedeltaIndex 与 DatetimeIndex 的组合允许某些保留 NaT 的组合操作：
tdi = pd.TimedeltaIndex(["1 days", pd.NaT, "2 days"])
tdi.to_list()
Out[111]: [Timedelta('1 days 00:00:00'), NaT, Timedelta('2 days 00:00:00')]
dti = pd.date_range("20130101", periods=3)
dti.to_list()
Out[113]:
[Timestamp('2013-01-01 00:00:00'),
Timestamp('2013-01-02 00:00:00'),
Timestamp('2013-01-03 00:00:00')]
(dti + tdi).to_list()
Out[114]: [Timestamp('2013-01-02 00:00:00'), NaT, Timestamp('2013-01-05 00:00:00')]
(dti - tdi).to_list()
Out[115]: [Timestamp('2012-12-31 00:00:00'), NaT, Timestamp('2013-01-01 00:00:00')]
转换
与上面的 Series 上的频率转换类似，您可以将这些索引转换为另一个索引。
tdi / np.timedelta64(1, "s")
Out[116]: Index([86400.0, nan, 172800.0], dtype='float64')
tdi.astype("timedelta64[s]")
Out[117]: TimedeltaIndex(['1 days', NaT, '2 days'], dtype='timedelta64[s]', freq=None)
标量类型的操作也可以使用。这些可能会返回一个不同类型的索引。
# 将 timedelta 和 date 相加 -> datelike
tdi + pd.Timestamp("20130101")
Out[118]: DatetimeIndex(['2013-01-02', 'NaT', '2013-01-03'], dtype='datetime64[ns]', freq=None)
# 将日期减去 timedelta -> datelike
# 请注意，尝试从 Timedelta 减去日期会引发异常
(pd.Timestamp("20130101") - tdi).to_list()
Out[119]: [Timestamp('2012-12-31 00:00:00'), NaT, Timestamp('2012-12-30 00:00:00')]
# timedelta + timedelta -> timedelta
tdi + pd.Timedelta("10 days")
Out[120]: TimedeltaIndex(['11 days', NaT, '12 days'], dtype='timedelta64[ns]', freq=None)
# 除法可能会得到一个 Timedelta，如果除数是整数
tdi / 2
Out[121]: TimedeltaIndex(['0 days 12:00:00', NaT, '1 days 00:00:00'], dtype='timedelta64[ns]', freq=None)
# 或者如果除数是 Timedelta，则可能会得到一个 float64 索引
tdi / tdi[0]
Out[122]: Index([1.0, nan, 2.0], dtype='float64')
## 重采样
类似于时间序列重采样，我们可以使用TimedeltaIndex进行重采样。
s.resample("D").mean()
Out[123]:
1 天 11.5
2 天 35.5
3 天 59.5
4 天 83.5
5 天 97.5
Freq: D, dtype: float64
Pandas 2 使用指南导读
Pandas 2 使用指南：4、IO工具（文本、CSV、HDF5等）
Pandas 2 使用指南：8、写时复制（Copy-on-Write，CoW）
Pandas 2 使用指南：10、重塑和透视表ReShapingand Pivot Tables
Pandas 2 使用指南：11、处理文本数据 Working with text data
Pandas 2 使用指南：12、处理缺失数据Working with missing data
Pandas 2 使用指南： 13、重复标签 Duplicate Labels
Pandas 2 使用指南：14、分类数据 Categorical data
Pandas 2 使用指南：15、可空整数数据类型、可空布尔数据类型
Pandas 2 使用指南：18、Groupby：拆分-应用-合并 split-apply-combine
Pandas 2 使用指南：19、窗口操作 Windowing operations
Pandas 2 使用指南：20、时间序列/日期功能
Pandas 2 使用指南：21、时间差 Timedelta
Pandas 2 使用指南：23、提升性能 Enhancing performance
扫一扫
801
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
