enumerate
enumerate 是一个内置的Python函数，用于在迭代可迭代对象（例如列表、元组、字符串等）时同时获取元素的索引和值。它返回一个枚举对象，其中包含每个元素的索引和对应的值。下面是 enumerate 函数的详细参数解释和示例，包括输出结果。
enumerate(iterable, start=0)
-
iterable：要枚举的可迭代对象，如列表、元组、字符串等。 -
start（可选）：索引的起始值。默认情况下，索引从0开始。您可以指定一个不同的起始值。
下面是一些示例和输出结果：
# 示例 1: 枚举列表元素
fruits = ['apple', 'banana', 'cherry']
enum_fruits = enumerate(fruits)
for index, fruit in enum_fruits:
print(f'Index: {index}, Fruit: {fruit}')
# 输出结果:
# Index: 0, Fruit: apple
# Index: 1, Fruit: banana
# Index: 2, Fruit: cherry
# 示例 2: 指定起始索引值
fruits = ['apple', 'banana', 'cherry']
enum_fruits = enumerate(fruits, start=1)
for index, fruit in enum_fruits:
print(f'Index: {index}, Fruit: {fruit}')
# 输出结果:
# Index: 1, Fruit: apple
# Index: 2, Fruit: banana
# Index: 3, Fruit: cherry
# 示例 3: 枚举字符串中的字符
text = "Hello"
enum_text = enumerate(text)
for index, char in enum_text:
print(f'Index: {index}, Character: {char}')
# 输出结果:
# Index: 0, Character: H
# Index: 1, Character: e
# Index: 2, Character: l
# Index: 3, Character: l
# Index: 4, Character: o
在示例1中，enumerate 用于枚举列表中的元素，并且默认从索引0开始。在示例2中，我们指定了起始索引值为1。在示例3中，enumerate 用于枚举字符串中的字符。在每个示例中，它返回一个枚举对象，其中包含索引和对应的值，允许您在迭代过程中访问这些信息。
Pandas 中的时间相关数据类型
Pandas 中的时间相关数据类型包括 datetime64、timedelta64 和 period，它们都用于处理时间数据，具体如下：
-
datetime64：datetime64是 Pandas 中表示日期和时间的主要数据类型。它可以精确到纳秒级别，通常用于==存储时间戳（timestamp）==和日期时间信息。datetime64类型的数据可以包括日期和时间，例如：“2023-09-26 15:30:00”。你可以进行日期时间的运算、分组和分析等操作。示例：
import pandas as pd # 创建一个 datetime64 对象 datetime_obj = pd.to_datetime('2023-09-26 15:30:00') print(datetime_obj)
输出结果：
Timestamp('2023-09-26 15:30:00')
-
timedelta64：timedelta64用于表示时间差或持续时间，例如，两个时间点之间的时间间隔。它也可以精确到纳秒级别。timedelta64类型的数据通常用于进行时间差的计算。示例：
import pandas as pd # 创建一个 timedelta64 对象 timedelta_obj = pd.to_timedelta('2 days 5 hours 30 minutes') -
period：period类型用于表示一段时间，通常以固定的频率出现，如月、季度或年。period对象包括起始日期和结束日期。它用于处理时间段数据，而不是具体的日期和时间。示例：
import pandas as pd # 创建一个 period 对象 period_obj = pd.Period('2023-09', freq='M')
这些时间相关的数据类型使得 Pandas 成为了处理时间序列数据和日期时间数据的强大工具。你可以使用它们进行时间计算、分析、分组、绘图等操作，以满足各种时间相关的数据处理需求。在处理时间数据时，通常需要考虑时区（timezone）、日期时间格式化、时间戳（timestamp）的转换等问题，Pandas 提供了丰富的方法和函数来处理这些问题。
datetime64[D]/timedelta64[Y]
下面是使用 datetime64[D] 和 timedelta64[D] 的示例：
import numpy as np
# 创建一个 np.datetime64[Y] 对象
date = np.datetime64('2023-01-01', 'Y')
print(type(date), date)
# 输出：<class 'numpy.datetime64'> 2023
# 创建一个 np.timedelta64[Y] 对象
delta = np.timedelta64(5, 'Y')
print(type(delta), delta)
# 输出：<class 'numpy.timedelta64'> 5 years
- 使用
datetime64[D]表示日期：
import numpy as np
# 创建一个 datetime64[D] 对象表示日期
date1 = np.datetime64('2023-09-27', 'D')
date2 = np.datetime64('2023-09-28', 'D')
# 计算日期之间的差异
date_diff = date2 - date1
print("日期1:", date1)
print("日期2:", date2)
print("日期差异:", date_diff)
输出结果：
日期1: 2023-09-27
日期2: 2023-09-28
日期差异: 1 days
- 使用
timedelta64[D]表示时间间隔：
import numpy as np
# 创建一个 timedelta64[D] 对象表示时间间隔
time_interval = np.timedelta64(5, 'D')
# 创建一个 datetime64[D] 对象
start_date = np.datetime64('2023-09-27', 'D')
# 计算未来的日期
future_date = start_date + time_interval
print("初始日期:", start_date)
print("未来日期:", future_date)
输出结果：
初始日期: 2023-09-27
未来日期: 2023-10-02
在第一个示例中，我们创建了两个 datetime64[D] 对象，表示两个日期，并计算了它们之间的日期差异。在第二个示例中，我们创建了一个 timedelta64[D] 对象，表示时间间隔，然后使用它来计算未来的日期。
下面是使用 datetime64[D] 和 timedelta64[D] 的示例：
- 使用
datetime64[D]表示日期：
import numpy as np
# 创建一个 datetime64[D] 对象表示日期
date1 = np.datetime64('2023-09-27', 'D')
date2 = np.datetime64('2023-09-28', 'D')
# 计算日期之间的差异
date_diff = date2 - date1
print("日期1:", date1)
print("日期2:", date2)
print("日期差异:", date_diff)
输出结果：
日期1: 2023-09-27
日期2: 2023-09-28
日期差异: 1 days
- 使用
timedelta64[D]表示时间间隔：
import numpy as np
# 创建一个 timedelta64[D] 对象表示时间间隔
time_interval = np.timedelta64(5, 'D')
# 创建一个 datetime64[D] 对象
start_date = np.datetime64('2023-09-27', 'D')
# 计算未来的日期
future_date = start_date + time_interval
print("初始日期:", start_date)
print("未来日期:", future_date)
输出结果：
初始日期: 2023-09-27
未来日期: 2023-10-02
在第一个示例中，我们创建了两个 datetime64[D] 对象，表示两个日期，并计算了它们之间的日期差异。在第二个示例中，我们创建了一个 timedelta64[D] 对象，表示时间间隔，然后使用它来计算未来的日期。这些示例演示了如何使用 datetime64[D] 和 timedelta64[D] 进行日期和时间间隔的操作。
在pandas中使用
在 Pandas 中，您可以使用 pd.to_datetime 函数来处理日期时间数据。下面是如何使用 Pandas 处理日期时间数据的示例：
- 将字符串转换为 Pandas 的
datetime64对象：
import pandas as pd
# 将字符串日期时间转换为 datetime64 对象
date_str = '2023-09-27 15:30:00'
datetime_obj = pd.to_datetime(date_str)
print(datetime_obj)
输出结果：
2023-09-27 15:30:00
- 创建日期范围：
import pandas as pd
# 创建日期范围
date_range = pd.date_range(start='2023-09-27', periods=5, freq='D')
print(date_range)
输出结果：
DatetimeIndex(['2023-09-27', '2023-09-28', '2023-09-29', '2023-09-30', '2023-10-01'], dtype='datetime64[ns]', freq='D')
- 提取日期时间的组成部分：
import pandas as pd
# 创建 datetime64 对象
datetime_obj = pd.to_datetime('2023-09-27 15:30:00')
# 提取日期、时间、年份、月份、小时等组成部分
date_part = datetime_obj.date()
time_part = datetime_obj.time()
year = datetime_obj.year
month = datetime_obj.month
hour = datetime_obj.hour
print("日期部分:", date_part)
print("时间部分:", time_part)
print("年份:", year)
print("月份:", month)
print("小时:", hour)
输出结果：
日期部分: 2023-09-27
时间部分: 15:30:00
年份: 2023
月份: 9
小时: 15
- 计算日期时间差异：
import pandas as pd
# 创建两个 datetime64 对象
date1 = pd.to_datetime('2023-09-27')
date2 = pd.to_datetime('2023-09-30')
# 计算日期之间的差异
date_diff = date2 - date1
print("日期差异:", date_diff)
输出结果：
日期差异: Timedelta('3 days 00:00:00')
这些示例展示了如何在 Pandas 中处理日期时间数据，包括字符串转换、日期范围创建、提取日期时间的组成部分以及计算日期时间差异等常见操作。 Pandas 提供了丰富的功能来处理日期时间数据，使得数据分析和操作更加方便。
datetime 模块 datetime.strptime()
datetime 模块是 Python 中用于处理日期和时间的标准库，它提供了多个类和函数来操作日期、时间、日期时间等相关的信息。下面是 datetime 模块中常用的类和函数的详细参数解释和示例：
datetime 模块的类
1. datetime.datetime 类：
这个类用于表示日期和时间的组合。它的主要参数包括：
year：年份。month：月份。day：日期。hour：小时。minute：分钟。second：秒数。microsecond：微秒（百万分之一秒）。
示例：
from datetime import datetime
# 创建一个日期时间对象
dt = datetime(2023, 9, 22, 10, 30, 0)
# 输出日期时间对象
print(type(dt),dt)
输出结果：
<class 'datetime.datetime'> 2023-09-22 10:30:00
1.1 datetime.datetime类的属性
datetime.datetime 类是 Python 中用于表示日期和时间的类，具有许多属性和方法。以下是一些常用的 datetime.datetime 类属性：
year：表示日期的年份（例如，2023）。month：表示日期的月份（1 到 12）。day：表示日期的日（1 到 31）。hour：表示时间的小时（0 到 23）。minute：表示时间的分钟（0 到 59）。second：表示时间的秒（0 到 59）。microsecond：表示时间的微秒（0 到 999999）。tzinfo：表示日期时间的时区信息（如果有的话）。
这些属性允许您访问日期时间对象的各个部分，以便进行操作和查询。例如，您可以使用 year 属性获取日期时间对象的年份，使用 hour 属性获取时间的小时部分。
以下是一个示例，演示如何使用这些属性：
from datetime import datetime
# 创建一个日期时间对象
now = datetime.now()
# 访问日期时间对象的属性
print("Year:", now.year)
print("Month:", now.month)
print("Day:", now.day)
print("Hour:", now.hour)
print("Minute:", now.minute)
print("Second:", now.second)
print("Microsecond:", now.microsecond)
print("Timezone Info:", now.tzinfo)
输出结果：
Year: 2023
Month: 9
Day: 27
Hour: 19
Minute: 53
Second: 4
Microsecond: 726601
Timezone Info: None
这将输出当前日期时间对象的各个属性值。请注意，这些属性是只读的，您不能直接更改日期时间对象的属性值。要执行日期时间的各种操作，通常需要使用方法和函数，例如 strftime 用于格式化日期时间，timedelta 用于计算时间差异，等等。
1.2 datetime.datetime类的方法
datetime.datetime 类是 Python 中用于处理日期和时间的类，它具有多个方法，用于创建、操作和格式化日期时间对象。以下是 datetime.datetime 类的一些常用方法，并进行简要的讲解：
-
datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0)：- 用于创建一个新的
datetime对象，表示特定日期和时间。 - 参数：
year：年份。month：月份（1 到 12）。day：日期（1 到 31）。hour：小时（默认为0）。minute：分钟（默认为0）。second：秒（默认为0）。microsecond：微秒（默认为0）。
- 用于创建一个新的
-
datetime.now(tz=None)：- 返回当前日期时间的
datetime对象。 - 可选参数
tz用于指定时区信息。
- 返回当前日期时间的
-
datetime.strptime(date_string, format)：- 从日期时间字符串解析并返回一个
datetime对象。 date_string：待解析的日期时间字符串。format：日期时间字符串的格式，例如 “%Y-%m-%d %H:%M:%S”。
- 从日期时间字符串解析并返回一个
-
datetime.timestamp()：- 返回日期时间对象的时间戳表示，表示自 1970 年 1 月 1 日午夜以来的秒数（包括小数部分表示毫秒）。
-
datetime.date()：- 返回日期时间对象的日期部分，即一个
date对象。
- 返回日期时间对象的日期部分，即一个
-
datetime.time()：- 返回日期时间对象的时间部分，即一个
time对象。
- 返回日期时间对象的时间部分，即一个
-
datetime.replace(year=None, month=None, day=None, hour=None, minute=None, second=None, microsecond=None, tzinfo=None)：- 创建并返回一个新的
datetime对象，其中的指定部分被替换为新值。 - 每个参数都是可选的，如果未提供，则保留原始值。
- 创建并返回一个新的
-
datetime.strftime(format)：- 将日期时间对象格式化为指定格式的字符串。
format：格式化字符串，例如 “%Y-%m-%d %H:%M:%S”。
-
datetime.weekday()：- 返回日期时间对象所代表的星期几，0 表示星期一，1 表示星期二，以此类推。
-
datetime.isoweekday()：- 返回日期时间对象所代表的星期几，1 表示星期一，2 表示星期二，以此类推。
-
datetime.toordinal()：- 返回日期时间对象所代表的日期的 Gregorian 历法序数（从公元 1 年 1 月 1 日算起）。
-
datetime.fromtimestamp(timestamp, tz=None)：- 根据给定的时间戳创建并返回一个
datetime对象。 - 参数
tz可选，用于指定时区信息。
- 根据给定的时间戳创建并返回一个
这些方法允许您在处理日期和时间数据时执行各种操作，包括创建、解析、格式化、比较和替换日期时间对象。选择适当的方法取决于您的需求和操作。
█ datetime.strptime() 函数：
这个函数用于将字符串解析为日期时间对象。它的主要参数包括：
date_string：要解析的日期时间字符串。format：日期时间字符串的格式。
示例：
from datetime import datetime
# 解析日期时间字符串
dt_str = "2023-09-22 10:30:00"
dt = datetime.strptime(dt_str, "%Y-%m-%d %H:%M:%S")
# 输出日期时间对象
print(type(dt),dt)
输出结果：
<class 'datetime.datetime'> 2023-09-22 10:30:00
timestamp 数据类型
在 Python 中，timestamp 数据类型通常不是一个独立的模块，而是与时间处理相关的模块一起使用。最常见的情况是在使用 datetime 模块时，timestamp 是一个时间表示方式，表示从某个特定的时间点（通常是1970年1月1日午夜，也称为“Unix 时间戳”）开始的秒数或微秒数。
具体来说，timestamp 通常是一个整数或浮点数，表示自1970年1月1日午夜（UTC）以来的秒数或微秒数。在 Python 的 datetime 模块中，您可以使用 datetime 类来创建、操作和表示日期和时间，而 timestamp 可以用来表示日期和时间的具体值。
以下是一个示例，演示如何使用 datetime 模块和 timestamp 来处理日期和时间数据：
import datetime
# 创建一个 datetime 对象表示当前时间
current_datetime = datetime.datetime.now()
# 获取该 datetime 对象的 timestamp 表示
timestamp = current_datetime.timestamp()
print(type(current_datetime),current_datetime)
print(type(timestamp),timestamp)
输出结果：
<class 'datetime.datetime'> 2023-09-27 19:46:12.203893
<class 'float'> 1695815172.203893
在这个示例中，我们首先创建一个 datetime 对象 current_datetime，然后使用 timestamp() 方法获取它的 timestamp 表示。
“2023-09-09 19:00:00” 是一个日期和时间的字符串，不是一个直接的 timestamp。Timestamp 是一个表示时间的数字，通常是从某个特定时间点（例如，1970年1月1日午夜，也称为 Unix 时间戳）以来的秒数或微秒数。在 Python 中，您可以使用 datetime 模块将日期时间字符串转换为 timestamp。
要将 “2023-09-09 19:00:00” 转换为 timestamp，您可以使用以下方法：
from datetime import datetime
# 日期时间字符串
date_string = "2023-09-09 19:00:00"
# 使用 datetime 解析字符串为 datetime 对象
date_time_obj = datetime.strptime(date_string, "%Y-%m-%d %H:%M:%S")
# 将 datetime 对象转换为 timestamp
timestamp = date_time_obj.timestamp()
print(timestamp)
输出结果应该如下所示：
1662777600.0
这个数字表示从1970年1月1日午夜（UTC）到 “2023-09-09 19:00:00” 这个日期时间的秒数。请注意，timestamp 的小数部分表示微秒。
在这个示例中，我们首先使用 datetime.strptime() 方法将日期时间字符串解析为 datetime 对象，然后使用 timestamp() 方法将 datetime 对象转换为 timestamp。
请注意，生成的 timestamp 表示的是从1970年1月1日午夜（UTC）以来的秒数。在不同的编程语言和环境中，timestamp 的表示方式可能会有所不同。
总之，timestamp 数据类型通常是与 datetime 模块一起使用的，用于表示日期和时间的具体值。如果您需要处理时间相关的数据，datetime 模块是一个非常有用的工具。
█ datetime.timedelta()
datetime.timedelta() 是 Python 中用于表示时间间隔（时间差）的类。它可以用于在日期和时间上执行各种算术操作，例如加法、减法、比较等。以下是 datetime.timedelta() 的详细参数解释和示例：
datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)
参数说明：
days：表示天数的整数值。seconds：表示秒数的整数值。microseconds：表示微秒（百万分之一秒）的整数值。milliseconds：表示毫秒（千分之一秒）的整数值。minutes：表示分钟数的整数值。hours：表示小时数的整数值。weeks：表示周数的整数值。
示例：
from datetime import timedelta
# 创建一个时间间隔为 2 天 3 小时 15 分钟的 timedelta 对象
time_diff = timedelta(days=2, hours=3, minutes=15)
# 输出时间间隔
print(time_diff)
输出结果：
2 days, 3:15:00
当处理日期和时间数据时，datetime.timedelta() 可以用于执行各种有用的操作。以下是一些示例：
-
计算日期间隔：
from datetime import datetime, timedelta # 创建两个日期对象 date1 = datetime(2023, 9, 1) date2 = datetime(2023, 9, 15) # 计算日期间隔 time_diff = date2 - date1 print(time_diff.days) # 输出天数输出结果将是
14，表示日期2023-09-15和2023-09-01之间相差 14 天。 -
在日期时间上进行加法或减法运算：
from datetime import datetime, timedelta # 创建一个日期时间对象 dt1 = datetime(2023, 9, 1, 12, 0, 0) # 添加一段时间 dt2 = dt1 + timedelta(days=7, hours=3) # 减去一段时间 dt3 = dt1 - timedelta(hours=2) print(dt2) # 输出结果：2023-09-08 15:00:00 print(dt3) # 输出结果：2023-09-01 10:00:00在这个示例中，我们在日期时间对象上执行了加法和减法运算，分别添加了一段时间和减去一段时间。
-
比较不同的时间间隔：
from datetime import timedelta # 创建两个时间间隔对象 time_diff1 = timedelta(days=10) time_diff2 = timedelta(weeks=2) # 比较时间间隔 if time_diff1 > time_diff2: print("time_diff1 大于 time_diff2") else: print("time_diff1 不大于 time_diff2")输出结果将是 “time_diff1 大于 time_diff2”，因为
time_diff1表示 10 天，而time_diff2表示 2 周，而 2 周大于 10 天。
datetime.timedelta() 对象在处理日期和时间操作中非常有用，可以用于执行各种日期时间的数学运算和比较操作。根据具体的需求，你可以执行更多不同的操作。
2. datetime.date 类：
这个类用于表示日期。它的主要参数包括：
year：年份。month：月份。day：日期。
示例：
from datetime import date
# 创建一个日期对象
d = date(2023, 9, 22)
# 输出日期对象
print(type(d),d)
输出结果：
<class 'datetime.date'> 2023-09-22
3. datetime.time 类：
这个类用于表示时间。它的主要参数包括：
hour：小时。minute：分钟。second：秒数。microsecond：微秒（百万分之一秒）。
示例：
from datetime import time
# 创建一个时间对象
t = time(10, 30, 0)
# 输出时间对象
print(t)
输出结果：
10:30:00
4. datetime.timedelta 类：
datetime.timedelta.days
.days 是在 Python 中用于从 timedelta 对象中获取天数部分的属性。timedelta 是表示时间间隔的一种对象，通常用于处理时间差异。.days 属性用于访问 timedelta 对象中的天数部分。以下是有关 .days 的详细解释和示例：
属性：
.days: 获取 timedelta 对象的天数部分。
示例：
from datetime import timedelta
# 创建一个 timedelta 对象，表示一个时间间隔为5天
time_difference = timedelta(days=5)
# 使用 .days 属性获取天数部分
days = time_difference.days
# 输出结果
print(days)
输出结果：
5
在上面的示例中，我们首先创建了一个 timedelta 对象 time_difference，它表示一个时间间隔为5天。然后，我们使用 .days 属性获取了这个时间间隔的天数部分，将其赋值给变量 days，最后输出 days 的值为5，表示时间间隔为5天。
.days 属性返回的是一个整数，表示时间间隔中的天数部分。这对于处理时间差异以及计算日期的间隔非常有用。请注意，.days 返回的是天数，而不包括小时、分钟、秒等更小的时间单位。
datetime.timedelta类的属性
timedelta 对象是 Python 中用于表示时间间隔的一种对象，它具有多个属性，可用于获取时间间隔的各个部分。以下是一些常用的 timedelta 对象属性：
-
.days: 获取时间间隔的天数部分，返回一个整数。 -
.seconds: 获取时间间隔的秒数部分，返回一个整数。 -
.microseconds: 获取时间间隔的微秒数部分，返回一个整数。 -
.total_seconds(): 获取时间间隔的总秒数，包括天、秒、微秒，返回一个浮点数。
这些属性允许你从 timedelta 对象中提取不同的时间单位部分，以进行各种时间操作和计算。
以下是一个示例，演示如何使用这些属性：
from datetime import timedelta
# 创建一个 timedelta 对象，表示一个时间间隔为2天、3小时、30分钟和15秒
time_difference = timedelta(days=2, hours=3, minutes=30, seconds=15)
# 使用属性获取各个时间部分
days = time_difference.days
seconds = time_difference.seconds
microseconds = time_difference.microseconds
total_seconds = time_difference.total_seconds()
# 输出结果
print("Days:", days)
print("Seconds:", seconds)
print("Microseconds:", microseconds)
print("Total Seconds:", total_seconds)
这将输出以下结果：
Days: 2
Seconds: 12615
Microseconds: 0
Total Seconds: 190815.0
如上所示，我们首先创建了一个 timedelta 对象 time_difference，表示一个时间间隔为2天、3小时、30分钟和15秒。然后，使用不同的属性来获取时间间隔的不同部分。.total_seconds() 方法返回总秒数，包括了所有时间单位的贡献。
这些属性使得 timedelta 对象非常有用，可以用于各种时间计算和操作。
df.strftime()
Return a formatted string of the Timestamp.
.strftime() 是 Pandas 和 Python 中日期时间对象的一个方法，用于将日期时间对象格式化为指定的字符串格式。它允许你将日期时间对象转换为字符串，以便于显示、输出或存储。
.strftime() 方法接受一个格式字符串作为参数，该格式字符串包含一系列格式化指令，用于定义输出字符串中日期时间各部分（年、月、日、小时、分钟、秒等）的格式。以下是一些常见的格式指令：
%Y：年份，4 位数，例如：2023%y：年份，2 位数，例如：23%m：月份，两位数，01 到 12%d：日期，两位数，01 到 31%H：小时（24 小时制），两位数，00 到 23%M：分钟，两位数，00 到 59%S：秒，两位数，00 到 59%A：星期的完整名称，例如：Sunday%a：星期的缩写名称，例如：Sun%B：月份的完整名称，例如：January%b或%h：月份的缩写名称，例如：Jan
下面是一个示例，演示如何使用 .strftime() 方法：
import pandas as pd
# 创建一个日期时间对象
date_time = pd.to_datetime('2023-09-22 15:30:45')
# 使用 strftime 格式化日期时间对象为字符串
formatted_str = date_time.strftime('%Y-%m-%d %H:%M:%S')
print(type(formatted_str),formatted_str)
输出结果：
<class 'str'> 2023-09-22 15:30:45
在上述示例中，我们首先创建了一个日期时间对象 date_time，然后使用 .strftime() 方法将其格式化为字符串。指令 %Y-%m-%d %H:%M:%S 定义了输出字符串的格式，分别包括年、月、日、小时、分钟和秒。
np.diff()
numpy.diff() 函数用于计算数组中元素之间的差异。具体来说，它计算相邻元素之间的差值，并返回一个新的数组，新数组的长度比原数组少一个元素。
以下是 numpy.diff() 函数的作用和示例：
作用：
- 计算数组中元素之间的差异，用于分析数据的变化趋势。
- 常用于时间序列分析、信号处理等领域，用于计算一阶差分、二阶差分等。
参数解释：
a（必需）：要计算导数的输入数组。n（可选，默认为1）：要计算的导数的阶数（啥玩意，是差分吧）。如果不指定，默认为1，即计算一阶导数。axis（可选，默认为-1）：指定沿哪个轴计算导数。默认值为-1，表示最后一个轴。
示例：
import numpy as np
# 创建一个示例数组
arr = np.array([1, 2, 4, 7, 11, 16])
# 计算一阶导数
first_order_diff = np.diff(arr)
print("一阶导数：", first_order_diff)
# 计算二阶导数
second_order_diff = np.diff(arr, n=2)
print("二阶导数：", second_order_diff)
# 在多维数组上计算导数
matrix = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
# 沿行计算一阶导数
row_diff = np.diff(matrix, axis=1)
print("沿行计算一阶导数：\n", row_diff)
# 沿列计算一阶导数
column_diff = np.diff(matrix, axis=0)
print("沿列计算一阶导数：\n", column_diff)
一阶导数： [1 2 3 4 5]
二阶导数： [1 1 1 1]
沿行计算一阶导数：
[[1 1]
[1 1]
[1 1]]
沿列计算一阶导数：
[[3 3 3]
[3 3 3]]
time_series.diff()
在 Pandas 中，diff() 函数用于计算时间序列或数据框（DataFrame）中的差异或导数。以下是 diff() 函数的详细参数解释以及示例使用情况：
参数解释：
periods（可选，默认为1）：要计算的差异的周期数。默认为1，表示计算相邻元素之间的差异。axis（可选，默认为0）：指定沿着哪个轴计算差异。默认为0，表示在行方向上计算差异。
示例：
首先，确保您已经导入了 Pandas 库。
import pandas as pd
# 创建一个示例的时间序列
date_rng = pd.date_range(start='2023-01-01', end='2023-01-05', freq='D')
time_series = pd.Series([10, 15, 13, 17, 20], index=date_rng)
# 计算一阶差异（相邻元素之间的差异）
first_order_diff = time_series.diff()
print("一阶差异：")
print(first_order_diff)
# 计算两阶差异
second_order_diff = time_series.diff(periods=2)
print("\n两阶差异：")
print(second_order_diff)
# 在数据框中计算差异
data = {'A': [10, 15, 20], 'B': [5, 9, 14]}
df = pd.DataFrame(data)
# 沿列计算一阶差异
column_diff = df.diff(axis=0)
print("\n沿列计算一阶差异：")
print(column_diff)
# 沿行计算一阶差异
row_diff = df.diff(axis=1)
print("\n沿行计算一阶差异：")
print(row_diff)
一阶差异：
2023-01-01 NaN
2023-01-02 5.0
2023-01-03 -2.0
2023-01-04 4.0
2023-01-05 3.0
Freq: D, dtype: float64
两阶差异：
2023-01-01 NaN
2023-01-02 NaN
2023-01-03 3.0
2023-01-04 2.0
2023-01-05 7.0
Freq: D, dtype: float64
沿列计算一阶差异：
A B
0 NaN NaN
1 5.0 4.0
2 5.0 5.0
沿行计算一阶差异：
A B
0 NaN -5
1 NaN -6
2 NaN -6
pandas 中的 diff() 函数可以用于计算 datetime64 类型的数据的差异，它会计算相邻日期时间之间的差异，以及返回一个新的 Timedelta 类型的 Series。这是非常有用的，因为它允许您计算时间序列中的时间间隔。
以下是一个示例，演示如何在 pandas 中使用 diff() 函数计算 datetime64 类型的数据的差异：
import pandas as pd
# 创建一个示例的日期时间序列
date_rng = pd.date_range(start='2023-01-01', end='2023-01-05', freq='D')
time_series = pd.Series(date_rng)
# 计算日期时间之间的差异
time_diff = time_series.diff()
print("日期时间之间的差异：")
print(time_diff)
日期时间之间的差异：
0 NaT
1 1 days
2 1 days
3 1 days
4 1 days
dtype: timedelta64[ns]
pd.Timedelta()
pd.Timedelta() 是 Pandas 中用于表示时间间隔或时间差异的类，它用于处理时间相关的数据，允许您执行时间上的操作，例如将时间间隔添加到日期时间，执行时间算术等。以下是 pd.Timedelta() 的详细参数解释以及示例用法：
参数解释：
value（必需）：表示时间间隔的值，可以是整数、浮点数或字符串。unit（可选，默认为"ns"，即纳秒）：指定时间间隔的单位。可选单位包括：“D”（天）、“h”（小时）、“m”（分钟）、“s”（秒）、“ms”（毫秒）、“us”（微秒）和"ns"（纳秒）。
示例：
import pandas as pd
# 创建 Timedelta 对象
# 使用整数值和默认单位（纳秒）
delta1 = pd.Timedelta(5)
print("delta1:", delta1)
# 使用浮点数值和指定单位（秒）
delta2 = pd.Timedelta(2.5, unit="s")
print("delta2:", delta2)
# 使用字符串表示时间间隔
delta3 = pd.Timedelta("1 days 3 hours 30 minutes")
print("delta3:", delta3)
# 进行时间间隔的算术运算
delta4 = delta1 + delta2
print("delta4:", delta4)
# 将时间间隔添加到日期时间
start_date = pd.Timestamp("2023-01-01")
end_date = start_date + delta1
print("end_date:", end_date)
# 时间间隔与整数相乘
delta5 = delta1 * 3
print("delta5:", delta5)
在上述示例中，我们首先导入了 Pandas 库，然后创建了不同类型的 Timedelta 对象，并进行了各种操作：
delta1是一个整数值，表示默认单位（纳秒）下的时间间隔。delta2是一个浮点数值，表示秒为单位的时间间隔。delta3使用字符串表示了一个复杂的时间间隔，包括天、小时和分钟。delta4展示了如何进行时间间隔的算术运算（加法）。end_date展示了如何将时间间隔添加到日期时间。delta5展示了如何将时间间隔与整数相乘。
delta1: 0 days 00:00:00.000000005
delta2: 0 days 00:00:02.500000
delta3: 1 days 03:30:00
delta4: 0 days 00:00:02.500000005
end_date: 2023-01-01 00:00:00.000000005
delta5: 0 days 00:00:00.000000015
pd.to_timedelta()
pd.to_timedelta() 是 pandas 中用于创建 Timedelta 对象的函数，Timedelta 表示一段时间的持续时间，可以用于进行时间差异的计算和操作。以下是 pd.to_timedelta() 的详细参数解释和使用示例：
参数解释：
-
value（必需参数）：表示时间差异的值。可以是一个标量（整数、浮点数等）或一个字符串。如果是一个字符串，它应该包含一个数值和时间单位，例如'5 days'或'3 hours'。 -
unit（可选参数）：表示时间单位的字符串。默认值是'ns'（纳秒），但您可以根据需要指定其他时间单位，如'D'（天）、'h'（小时）、'm'（分钟）、's'（秒）等。这个参数通常与value参数一起使用，用于解释value中的时间单位。
示例：
下面是一些示例，演示如何使用 pd.to_timedelta() 创建 Timedelta 对象：
import pandas as pd
# 使用整数创建 Timedelta 对象
delta1 = pd.to_timedelta(5, unit='D') # 表示5天
print(delta1)
输出结果：
5 days 00:00:00
在这个示例中，我们使用整数 5 和单位 ‘D’ 创建了一个表示5天的 Timedelta 对象。
# 使用字符串创建 Timedelta 对象
delta2 = pd.to_timedelta('3 hours 30 minutes') # 表示3小时30分钟
print(delta2)
输出结果：
0 days 03:30:00
在这个示例中，我们使用字符串 ‘3 hours 30 minutes’ 创建了一个 Timedelta 对象，指示了3小时30分钟的时间。
# 创建多个 Timedelta 对象并执行算术运算
delta3 = pd.to_timedelta(2, unit='h') # 2小时
delta4 = pd.to_timedelta(30, unit='m') # 30分钟
result = delta3 + delta4 # 计算两个 Timedelta 对象的和
print(result)
输出结果：
0 days 02:30:00
在这个示例中，我们创建了两个 Timedelta 对象，分别表示2小时和30分钟，并对它们执行了算术运算，得到了一个新的 Timedelta 对象。
pd.to_timedelta() 函数允许您轻松地创建 Timedelta 对象，以便进行时间差异的计算和操作。这对于处理时间数据非常有用，特别是在时间序列分析中。
Timedelta 的属性和方法
Timedelta 数据类型是 Pandas 中用于表示时间间隔的类，它具有多个属性和方法，用于处理和操作时间间隔数据。以下是一些常用的 Timedelta 属性和方法的详细说明：
属性：
days：返回时间间隔的天数部分。
注意加s, 还有一个不加s的seconds：返回时间间隔的秒数部分。microseconds：返回时间间隔的微秒数部分。nanoseconds：返回时间间隔的纳秒数部分。
方法：
timedelta.total_seconds()
-
total_seconds()：返回时间间隔的总秒数。可以用于将时间间隔转换为秒数。示例：
delta = pd.Timedelta(days=2, hours=3, minutes=30) total_seconds = delta.total_seconds() print(total_seconds) # 输出：189000.0 秒 -
to_pytimedelta()：将 Pandas Timedelta 对象转换为 Python 标准库的datetime.timedelta对象。示例：
delta = pd.Timedelta(days=2) python_timedelta = delta.to_pytimedelta() print(python_timedelta) # 输出：2 days, 0:00:00 -
floor()和ceil()：向下取整和向上取整到指定时间单位。可用于将时间间隔取整到较小的时间单位。示例：
delta = pd.Timedelta(days=2, hours=3, minutes=30) floor_delta = delta.floor('hours') ceil_delta = delta.ceil('days') print(floor_delta) # 输出：2 days 03:00:00 print(ceil_delta) # 输出：3 days 00:00:00 -
round()：将时间间隔四舍五入到指定时间单位。示例：
delta = pd.Timedelta(days=2, hours=12) rounded_delta = delta.round('hours') print(rounded_delta) # 输出：2 days 12:00:00
df.shift()
df.shift() 是 Pandas 中用于将数据框的行或列按指定数量进行移动的函数。
函数签名：
DataFrame.shift(periods=1, freq=None, axis=0, fill_value=None)
参数解释：
periods: 移动的步数，可以是正数（向下移动）或负数（向上移动）整数，默认为1。freq: 用于向时间序列数据移动的频率字符串，可以是如 “D”（天）、“M”（月）、“Y”（年）等，默认为 None。axis: 指定移动的方向，0 代表沿着行移动，1 代表沿着列移动，默认为 0。fill_value: 填充缺失值的值，默认为 None。
示例：
- 基本用法：
import pandas as pd
data = {'A': [1, 2, 3, 4, 5],
'B': [10, 20, 30, 40, 50]}
df = pd.DataFrame(data)
# 向下移动一行
shifted_df = df.shift()
print(shifted_df)
输出：
A B
0 NaN NaN
1 1.0 10.0
2 2.0 20.0
3 3.0 30.0
4 4.0 40.0
- 指定移动多个步数：
# 向上移动两行
shifted_df = df.shift(periods=-2)
print(shifted_df)
输出：
A B
0 NaN NaN
1 NaN NaN
2 3.0 30.0
3 4.0 40.0
4 5.0 50.0
- 沿着列移动：
# 沿着列向下移动一行
shifted_df = df.shift(axis=1)
print(shifted_df)
输出：
A B
0 NaN 1.0
1 NaN 2.0
2 NaN 3.0
3 NaN 4.0
4 NaN 5.0
- 填充缺失值：
# 使用 fill_value 填充缺失值
shifted_df = df.shift(fill_value=0)
print(shifted_df)
输出：
A B
0 0 0
1 1 10
2 2 20
3 3 30
4 4 40
- 结合时间序列数据：
import pandas as pd
import numpy as np
# 创建带有日期索引的数据框
date_range = pd.date_range('2023-01-01', periods=5)
data = {'A': np.arange(5)}
df = pd.DataFrame(data, index=date_range)
# 向后移动两天
shifted_df = df.shift(freq='2D')
print(shifted_df)
输出：
A
2023-01-03 0.0
2023-01-04 1.0
2023-01-05 2.0
2023-01-06 3.0
2023-01-07 4.0
shift() 函数通过移动数据来实现相对位置的变化，可根据需要在不同情况下进行灵活应用。
pd.period()
在 pandas 中，pd.period() 不是一个单独的函数，而是一个类（pd.Period）的构造方法，用于创建时间周期（period）对象。时间周期表示一段时间，通常是一段时间的固定长度，例如一个月、一天、一个季度等。以下是 pd.Period 的详细参数解释和使用示例：
参数解释：
-
value（必需参数）：表示时间周期的值。这可以是一个字符串，表示时间周期的格式（例如，‘2023-09’ 表示一个月的时间周期），或者可以是一个整数，表示时间周期的偏移量。 -
freq（可选参数）：表示时间周期的频率（即，时间周期的单位）。这可以是一个字符串，例如 ‘D’ 表示天，‘M’ 表示月，‘Q’ 表示季度等。默认值是 None，此时 pandas 会尝试从value参数中推断频率。
示例：
下面是一些示例，演示如何使用 pd.Period 创建时间周期对象：
import pandas as pd
# 使用字符串创建月份时间周期
period1 = pd.Period('2023-09')
print(period1)
输出结果：
Period('2023-09', 'M')
在这个示例中，我们使用字符串 ‘2023-09’ 创建一个月份时间周期，pandas 推断出它的频率为月（‘M’）。
# 使用整数和频率创建时间周期
period2 = pd.Period(5, freq='D') # 表示5天的时间周期
print(period2)
输出结果：
Period('1970-01-06', 'D')
在这个示例中，我们使用整数 5 和频率 ‘D’ 创建一个表示5天的时间周期。
# 时间周期的算术运算
period3 = pd.Period('2023-09') + 2 # 增加两个月
print(period3)
输出结果：
Period('2023-11', 'M')
在这个示例中，我们将一个月份时间周期 ‘2023-09’ 增加了两个月，得到 ‘2023-11’。
pd.Period 类用于处理时间周期数据，它可以在时间序列分析中非常有用，允许您执行时间周期的各种操作和计算。
pd.Timestamp 用于单个字符串
pd.Timestamp 是pandas库中用于创建时间戳（Timestamp）对象的函数。时间戳是表示日期和时间的数据类型，它可以用于处理时间序列数据。下面是 pd.Timestamp 函数的详细参数解释和示例，包括输出结果。
pd.Timestamp(ts_input, freq=None, tz=None, unit=None, year=None, month=None, day=None, hour=None, minute=None, second=None, microsecond=None, nanosecond=None, tzinfo=None, format=None, exact=None, errors='raise')
-
ts_input: 可以是日期/时间字符串、整数（以秒为单位的时间戳）或其他日期/时间对象。这是创建时间戳的输入值。 -
freq: 一个字符串，表示时间戳的频率（例如，‘D’ 表示天，‘H’ 表示小时，‘T’ 表示分钟等）。默认为None。 -
tz: 时区信息，可以是字符串或pytz.timezone对象。默认为None，表示没有指定时区。 -
unit: 时间戳的时间单位，可以是字符串（例如，‘s’ 表示秒，‘ms’ 表示毫秒，‘us’ 表示微秒等）。默认为None。 -
year,month,day,hour,minute,second,microsecond,nanosecond: 分别表示年、月、日、小时、分钟、秒、微秒和纳秒的整数值。这些参数允许您以更细粒度的方式创建时间戳。 -
tzinfo: 一个时区对象，与tz参数一样，表示时区信息。 -
format: 一个字符串，用于指定输入日期/时间字符串的格式，以便解析日期/时间。默认为None。 -
exact: 一个布尔值，指示是否要求精确的日期/时间字符串匹配。默认为None。 -
errors: 一个字符串，指定如何处理解析错误。可以是’raise’（默认，抛出异常）、‘coerce’（将错误值替换为NaT）或’ignore’（忽略错误）。
下面是一些示例和输出结果：
import pandas as pd
# 从日期字符串创建时间戳
ts1 = pd.Timestamp('2023-09-25 14:30:00')
print(ts1)
# Output: 2023-09-25 14:30:00
# 从整数时间戳创建时间戳
ts2 = pd.Timestamp(1632582600, unit='s', tz='UTC')
print(ts2)
# Output: 2023-09-25 14:30:00+00:00
# 创建带有时区信息的时间戳
ts3 = pd.Timestamp('2023-09-25 14:30:00', tz='America/New_York')
print(ts3)
# Output: 2023-09-25 14:30:00-04:00
# 使用年、月、日、小时、分钟创建时间戳
ts4 = pd.Timestamp(year=2023, month=9, day=25, hour=14, minute=30)
print(ts4)
# Output: 2023-09-25 14:30:00
# 从日期字符串解析时间戳，并指定日期格式
ts5 = pd.Timestamp('25-Sep-2023 14:30:00', format='%d-%b-%Y %H:%M:%S')
print(ts5)
# Output: 2023-09-25 14:30:00
# 处理解析错误
ts6 = pd.Timestamp('Invalid Date', errors='coerce')
print(ts6)
# Output: NaT (Not a Timestamp)
上述示例演示了如何使用不同的参数创建时间戳，并且也展示了处理解析错误的方法。
pd.Timestamp 和 pd.to_datetime 都是 pandas 中用于处理日期和时间的函数，但它们有不同的用途和行为：
pd.Timestamp：pd.Timestamp用于创建单个日期/时间对象，通常用于将特定的日期和时间转换为时间戳。- 它通常用于处理单个时间点，例如 “2023-09-25 14:30:00”。
- 如果您有一个特定的日期/时间字符串，您可以使用
pd.Timestamp将其转换为时间戳对象。 - 通常情况下，它不用于处理整个日期/时间序列，而是用于处理单个时间点。
ts = pd.Timestamp('2023-09-25 14:30:00')
pd.to_datetime：pd.to_datetime用于处理日期/时间序列，通常用于将整个日期/时间列转换为时间戳序列。- 它适用于将字符串列、整数列（以秒为单位的时间戳）或其他日期/时间对象列转换为时间戳序列。
- 它还支持更多的参数选项，例如可以指定日期格式、处理不规则数据、处理时区等。
- 通常情况下，它用于处理包含多个日期/时间值的数据。
date_strings = ['2023-09-25 14:30:00', '2023-09-26 10:15:00']
dt_series = pd.to_datetime(date_strings)
总之，pd.Timestamp 主要用于创建单个时间戳对象，而 pd.to_datetime 主要用于处理日期/时间序列，将它们转换为时间戳序列。选择使用哪个函数取决于您的需求，如果需要处理整个序列，请使用 pd.to_datetime。如果只需要处理单个时间点，请使用 pd.Timestamp。
pd.to_datetime()
pd.to_datetime()函数返回的是datetime64对象，而不是datetime.datetime对象
pd.to_datetime() 是 pandas 中的一个函数，用于将输入的数据转换为日期时间（datetime）对象 。这个函数非常灵活，可以用于解析各种不同格式的日期和时间数据，包括字符串、整数、浮点数等。
以下是 pd.to_datetime() 函数的主要参数和详细解释：
-
arg：要转换为日期时间的数据，可以是以下之一：- 字符串（日期时间字符串）
- 整数或浮点数（表示自 1970 年 1 月 1 日以来的时间戳）
- 具有日期时间组件的数据（例如元组、列表、Series 等）
-
format：可选参数，用于指定日期时间字符串的格式。如果不提供此参数，pandas 将尝试自动识别日期时间字符串的格式。如果提供了格式字符串，pandas 将使用该格式进行解析。 -
errors：可选参数，用于处理解析错误的策略。可以选择以下选项之一：'raise'（默认值）：如果有解析错误，将引发异常。'coerce'：如果有解析错误，将在出现错误的位置创建 NaT（Not-a-Time）值。'ignore'：忽略解析错误，不进行处理。
-
dayfirst：可选参数，布尔值，默认为 False。如果为 True，表示日期为前置格式（例如，“31/12/2021” 表示 2021 年 12 月 31 日）；如果为 False（默认值），表示日期为后置格式（例如，“12/31/2021” 表示 2021 年 12 月 31 日）。 -
yearfirst：可选参数，布尔值，默认为 False。如果为 True，表示年份为前置格式（例如，“2021-12-31” 表示 2021 年 12 月 31 日）；如果为 False（默认值），表示年份为后置格式（例如，“31-12-2021” 表示 2021 年 12 月 31 日）。 -
utc：可选参数，布尔值，默认为 False。如果为 True，则将解析后的日期时间对象的时区设置为 UTC。 -
unit：可选参数，仅在参数 arg 是整数或浮点数（时间戳）时使用，用于指定时间戳的单位。 -
infer_datetime_format：可选参数，如果设置为 True，则尝试自动推断日期时间字符串的格式。 -
origin：可选参数，用于确定时间戳的基准。默认为 ‘unix’，表示从1970年1月1日开始计算。
下面是一些 pd.to_datetime() 的示例用法：
-
解析日期时间字符串：
import pandas as pd date_str = '2021-09-21 10:30:00' date_obj = pd.to_datetime(date_str) date_obj
输出结果：
Timestamp('2021-09-21 10:30:00')
如果用了print()，就会直接显示'2021-09-21 10:30:00'
-
指定日期时间字符串格式：
date_str = '21-09-2021' date_format = '%d-%m-%Y' date_obj = pd.to_datetime(date_str, format=date_format) -
处理多个日期时间字符串：
date_strings = ['2021-09-21', '2021-09-22', '2021-09-23'] date_objs = pd.to_datetime(date_strings) -
处理时间戳数据：
timestamp = 1632215400 # 表示 2021-09-21 10:30:00 的时间戳 date_obj = pd.to_datetime(timestamp, unit='s')
unit=‘s’ 表示输入的时间戳 timestamp 是以秒为单位的。
-
处理带有解析错误的数据：
date_strings = ['2021-09-21', '2021-09-22', 'invalid_date'] date_objs = pd.to_datetime(date_strings, errors='coerce') -
处理日期为前置格式的数据：
date_str = '21/09/2021' date_obj = pd.to_datetime(date_str, dayfirst=True)
这些示例演示了 pd.to_datetime() 的不同用法，可以根据需要进行日期时间数据的解析和转换。
pd.to_datetime 是 pandas 中用于将输入数据转换为 datetime 类型的函数。具体来说，它将不同类型的日期时间表示形式（例如字符串、整数、浮点数等）转换为 datetime64[ns] 类型的 Datetime 对象，这是 pandas 中表示日期时间的标准数据类型。
datetime64[ns] 表示纳秒级别的日期时间，具有高精度。这种数据类型允许您进行各种日期时间操作，并在时间序列分析中非常有用。
以下是示例演示如何使用 pd.to_datetime 将不同类型的数据转换为 ：datetime 类型
import pandas as pd
# 从字符串转换
date_str = "2023-09-27"
datetime_obj = pd.to_datetime(date_str)
print(type(datetime_obj),datetime_obj)
# 从整数（时间戳）转换
timestamp = 1672243200 # 2023-01-27 00:00:00 的时间戳
datetime_obj = pd.to_datetime(timestamp, unit='s') # 指定单位为秒
print(type(datetime_obj),datetime_obj)
# 从浮点数（时间戳）转换
timestamp_float = 1672243200.12345
datetime_obj = pd.to_datetime(timestamp_float, unit='s') # 指定单位为秒
print(type(datetime_obj),datetime_obj)
输出结果：
<class 'pandas._libs.tslibs.timestamps.Timestamp'> 2023-09-27 00:00:00
<class 'pandas._libs.tslibs.timestamps.Timestamp'> 2022-12-28 16:00:00
<class 'pandas._libs.tslibs.timestamps.Timestamp'> 2022-12-28 16:00:00.123450112
在上述代码中，pd.to_datetime('2023-09-26 15:30:00') 返回的结果确实是 Timestamp 类型，而不是 datetime 类型。这是因为 pandas 中的日期时间数据类型主要使用 Timestamp 类来表示，而不是标准库中的 datetime 类。
我明白您的疑惑。事实上，pd.to_datetime() 返回的对象在内部是一个时间戳类型（Timestamp），但当您使用 print 函数打印它时，会以日期时间的形式显示。这是 pandas 中的默认行为，旨在更好地呈现日期时间信息，以便人们阅读和理解。
尽管 pd.to_datetime() 返回的对象在内部是一个时间戳，但 pandas 提供了丰富的日期时间功能，使得处理日期时间数据更加方便。因此，即使是时间戳对象，也可以轻松地进行格式化、筛选、切片、聚合等操作。
如果您希望将时间戳以数字形式显示（自1970年1月1日以来的秒数），可以使用 .timestamp() 方法，例如：
import pandas as pd
datetime_obj = pd.to_datetime('2023-09-26 15:30:00')
timestamp = datetime_obj.timestamp()
print(timestamp) # 这将打印时间戳的数字形式
这将以数字形式显示时间戳，表示自1970年1月1日以来的秒数，而不是日期时间的形式。
Timestamp 类是 pandas 的一个自定义日期时间类型，它继承自标准库的 datetime 类，并具有一些扩展功能。在 pandas 中，Timestamp 类被广泛用于表示日期时间数据，特别是在时间序列数据分析中。
尽管 Timestamp 类在内部继承了标准库的 datetime 类的功能，但为了与 pandas 的数据结构和操作方法更好地配合，通常将其称为 Timestamp 类型。所以，即使您使用 pd.to_datetime() 创建日期时间对象，返回的结果也是 pandas 的 Timestamp 类型，而不是标准库的 datetime 类型。
从使用和操作的角度来看，Timestamp 类型与 datetime 类型非常相似，但它具有一些额外的 pandas 特性和函数，使其更适合在数据分析和处理中使用。如果您需要将 Timestamp 对象转换为标准库的 datetime 对象，可以使用 .to_pydatetime() 方法，例如：
import pandas as pd
datetime_obj = pd.to_datetime('2023-09-26 15:30:00')
standard_datetime_obj = datetime_obj.to_pydatetime()
这样就可以将 Timestamp 对象转换为标准库的 datetime 对象。
pd.to_datetime() 可调用的方法
pd.to_datetime() 函数返回的对象是 pandas 的 Datetime 对象，它具有多种方法，允许您在日期时间数据上执行各种操作和计算。以下是一些常用的 Datetime 对象方法，包括示例和输出结果：
- max()：返回一组日期时间中的最大日期时间值。
import pandas as pd
date_series = pd.to_datetime(['2023-09-26', '2023-09-27', '2023-09-28'])
max_date = date_series.max()
print(max_date)
输出结果：
2023-09-28 00:00:00
- min()：返回一组日期时间中的最小日期时间值。
import pandas as pd
date_series = pd.to_datetime(['2023-09-26', '2023-09-27', '2023-09-28'])
min_date = date_series.min()
print(min_date)
输出结果：
2023-09-26 00:00:00
- day_name()：返回一组日期时间的星期几名称。
import pandas as pd
date_series = pd.to_datetime(['2023-09-26', '2023-09-27', '2023-09-28'])
day_names = date_series.dt.day_name()
print(day_names)
输出结果：
Index(['Tuesday', 'Wednesday', 'Thursday'], dtype='object')
- year：获取一组日期时间的年份。
import pandas as pd
date_series = pd.to_datetime(['2023-09-26', '2023-09-27', '2023-09-28'])
years = date_series.dt.year
print(years)
输出结果：
Int64Index([2023, 2023, 2023], dtype='int64')
- month：获取一组日期时间的月份。
import pandas as pd
date_series = pd.to_datetime(['2023-09-26', '2023-09-27', '2023-09-28'])
months = date_series.dt.month
print(months)
输出结果：
Int64Index([9, 9, 9], dtype='int64')
这些是 Datetime 对象的一些方法示例，您可以根据需要在日期时间数据上执行不同的操作和计算。这些方法允许您访问日期时间的各个组成部分，执行聚合操作，比较日期时间，以及更多其他常见的日期时间操作。
pd.to_datetime().max()
pd.to_datetime().max() 是一个 Pandas 操作，用于获取一组日期时间中的最大日期时间值。具体来说，它返回给定日期时间序列中的最大日期时间。
以下是一个示例，演示如何使用 pd.to_datetime().max()：
import pandas as pd
# 创建一个日期时间序列
dates = ['2023-09-20 08:00:00', '2023-09-21 12:30:00', '2023-09-22 16:45:00']
date_series = pd.to_datetime(dates)
# 获取最大的日期时间值
max_date = date_series.max()
print("日期时间序列:")
print(date_series)
print("\n最大日期时间值:")
print(max_date)
输出结果：
日期时间序列:
0 2023-09-20 08:00:00
1 2023-09-21 12:30:00
2 2023-09-22 16:45:00
dtype: datetime64[ns]
最大日期时间值:
2023-09-22 16:45:00
在上述示例中，我们首先创建了一个日期时间序列 date_series，然后使用 .max() 方法获取了该序列中的最大日期时间值 max_date。在这个示例中，最大日期时间值是序列中的最后一个日期时间。
pd.to_datetime() 继续调用
使用 pd.to_datetime() 函数将输入数据转换为 Pandas 的日期时间数据类型后，您可以继续使用日期时间对象上的多种属性和方法来进行各种操作和分析。以下是一些常用的 datetime64 对象上可用的属性和方法的详细说明：
属性：
尝试了一下这里的属性不能直接对series用，应该是取出某一个值来用，如果想对列直接用，要使用dt.day等等
year：返回日期时间对象的年份部分。month：返回日期时间对象的月份部分。day：返回日期时间对象的日部分。
注意这里不加s，timedelta那里要加shour：返回日期时间对象的小时部分。minute：返回日期时间对象的分钟部分。second：返回日期时间对象的秒部分。microsecond：返回日期时间对象的微秒部分。nanosecond：返回日期时间对象的纳秒部分。dayofweek：返回日期时间对象对应的星期几，其中0表示星期一，1表示星期二，以此类推。dayofyear：返回日期时间对象对应的年份中的第几天。weekofyear：返回日期时间对象对应的年份中的第几周。quarter：返回日期时间对象所在季度。
方法：
-
strftime(format)：将日期时间对象格式化为字符串，可以使用格式化字符串指定输出格式。示例：
import pandas as pd datetime_obj = pd.to_datetime('2023-09-28 14:30:00') formatted_str = datetime_obj.strftime('%Y-%m-%d %H:%M:%S') print(formatted_str) # 输出：'2023-09-28 14:30:00' -
replace()：替换日期时间对象的特定部分，如替换年、月、日等。示例：
import pandas as pd datetime_obj = pd.to_datetime('2023-09-28 14:30:00') new_datetime_obj = datetime_obj.replace(year=2024, hour=15) print(new_datetime_obj) # 输出：'2024-09-28 15:30:00' -
tz_localize()和tz_convert()：用于处理时区信息，分别用于本地化和转换日期时间。示例：
import pandas as pd datetime_obj = pd.to_datetime('2023-09-28 14:30:00') datetime_obj_localized = datetime_obj.tz_localize('US/Eastern') datetime_obj_converted = datetime_obj_localized.tz_convert('UTC') print(datetime_obj_localized) # 输出：'2023-09-28 14:30:00-04:00' print(datetime_obj_converted) # 输出：'2023-09-28 18:30:00+00:00' -
to_period(freq)：将日期时间对象转换为周期对象，其中freq是频率字符串，用于指定周期的频率。示例：
import pandas as pd datetime_obj = pd.to_datetime('2023-09-28 14:30:00') period_obj = datetime_obj.to_period('D') # 转换为每日周期 print(period_obj) # 输出：Period('2023-09-28', 'D')
这些属性和方法允许您在 Pandas 中对日期时间对象进行各种操作，包括提取日期时间的各个部分、格式化为字符串、替换特定部分、处理时区信息等。这使得 Pandas 成为处理日期时间数据的强大工具。根据您的需求，您可以选择使用这些属性和方法来分析和操作日期时间数据。
df.dt
在 Pandas 中，df.dt 是一个用于访问日期时间数据的属性，它适用于包含日期时间信息的 Pandas Series 或 DataFrame 列。以下是 df.dt 的详细参数解释、属性和方法，以及示例演示其用法和输出结果：
参数解释：
- 无参数：
df.dt不需要额外参数，直接应用于日期时间列。
属性和方法：
.year：返回年份。.quarter：返回季度。.month：返回月份（1-12）。.day：返回日期。.hour：返回小时。.minute：返回分钟。.second：返回秒。.microsecond：返回微秒。.nanosecond：返回纳秒。.date：返回日期部分。.time：返回时间部分。.dayofweek：返回星期几（0-6，星期一到星期日）。.dayofyear：返回年份中的第几天。.week：返回年份中的第几周。.is_month_start：检查日期是否是月初。.is_month_end：检查日期是否是月末。.is_quarter_start：检查日期是否是季度初。.is_quarter_end：检查日期是否是季度末。.is_year_start：检查日期是否是年初。.is_year_end：检查日期是否是年末。.to_period(freq)：将日期时间列转换为周期（Period）格式，freq参数指定周期的频率。
感觉直接使用df.dt.date会把timestamp变为datetime类型
import pandas as pd
data = {'date_column': ['2023-09-27 15:30:00', '2023-09-28 12:45:00', '2023-09-29 09:15:00']}
df = pd.DataFrame(data)
# 将 'date_column' 列转换为 datetime64 类型
df['date_column'] = pd.to_datetime(df['date_column'])
print(type(df.date_column[0]))
# 提取日期部分并将其转换为 datetime64[D] 类型
df['date_column'] = df['date_column'].dt.date
print(type(df.date_column[0]))
print(df)
<class 'pandas._libs.tslibs.timestamps.Timestamp'>
<class 'datetime.date'>
date_column
0 2023-09-27
1 2023-09-28
2 2023-09-29
避免转换为datetime
import pandas as pd
data = {'date_column': ['2023-09-27 15:30:00', '2023-09-28 12:45:00', '2023-09-29 09:15:00']}
df = pd.DataFrame(data)
# 将 'date_column' 列转换为 datetime64 类型
df['date_column'] = pd.to_datetime(df['date_column'])
print(type(df.date_column[0]))
# 提取日期部分并将其转换为 datetime64[D] 类型
df['date_column'] = df['date_column'].dt.floor('D')
print(type(df.date_column[0]))
print(df)
<class 'pandas._libs.tslibs.timestamps.Timestamp'>
<class 'pandas._libs.tslibs.timestamps.Timestamp'>
date_column
0 2023-09-27
1 2023-09-28
2 2023-09-29
示例和输出结果：
import pandas as pd
# 创建一个包含日期时间的 DataFrame
data = {'date_time': ['2023-09-27 15:30:00', '2023-10-15 08:45:00', '2023-11-20 18:00:00']}
df = pd.DataFrame(data)
# 将 'date_time' 列转换为 datetime64 类型
df['date_time'] = pd.to_datetime(df['date_time'])
# 使用 df.dt 的属性和方法
df['year'] = df['date_time'].dt.year
df['month'] = df['date_time'].dt.month
df['day'] = df['date_time'].dt.day
df['hour'] = df['date_time'].dt.hour
df['minute'] = df['date_time'].dt.minute
df['second'] = df['date_time'].dt.second
# 检查日期是否是月初或月末
df['is_month_start'] = df['date_time'].dt.is_month_start
df['is_month_end'] = df['date_time'].dt.is_month_end
# 转换为周期数据
df['period'] = df['date_time'].dt.to_period('M')
print(df)
输出结果：
date_time year month day hour minute second is_month_start is_month_end period
0 2023-09-27 15:30:00 2023 9 27 15 30 0 False False 2023-09
1 2023-10-15 08:45:00 2023 10 15 8 45 0 True False 2023-10
2 2023-11-20 18:00:00 2023 11 20 18 0 0 False False 2023-11
在上述示例中，我们首先将 ‘date_time’ 列转换为 datetime64 类型，然后使用 df.dt 的不同属性和方法提取和操作日期时间信息，并将结果添加到 DataFrame 中。这使我们能够轻松地进行日期时间处理和分析。
在 Pandas 中，当您使用 pd.to_datetime() 将输入数据转换为日期时间后，您可以使用 .dt 访问器来访问日期时间对象上的各种属性和方法，以便进行更深入的操作和分析。以下是一些常用的 pd.to_datetime().dt 访问器下可用的属性和方法的详细说明：
属性：
year：返回日期时间对象的年份部分。month：返回日期时间对象的月份部分。day：返回日期时间对象的日部分。hour：返回日期时间对象的小时部分。minute：返回日期时间对象的分钟部分。second：返回日期时间对象的秒部分。microsecond：返回日期时间对象的微秒部分。nanosecond：返回日期时间对象的纳秒部分。dayofweek：返回日期时间对象对应的星期几，其中0表示星期一，1表示星期二，以此类推。dayofyear：返回日期时间对象对应的年份中的第几天。weekofyear：返回日期时间对象对应的年份中的第几周。quarter：返回日期时间对象所在季度。is_leap_year：返回布尔值，指示日期时间对象对应的年份是否是闰年。
方法：
-
strftime(format)：将日期时间对象格式化为字符串，可以使用格式化字符串指定输出格式。示例：
import pandas as pd datetime_series = pd.to_datetime(['2023-09-28 14:30:00', '2023-09-29 15:45:00']) formatted_str = datetime_series.dt.strftime('%Y-%m-%d %H:%M:%S') print(formatted_str) # 输出： # 0 2023-09-28 14:30:00 # 1 2023-09-29 15:45:00 # dtype: object -
day_name()和month_name()：返回日期时间对象对应的星期和月份的名称。示例：
import pandas as pd datetime_series = pd.to_datetime(['2023-09-28', '2023-09-29']) day_names = datetime_series.dt.day_name() month_names = datetime_series.dt.month_name() print(day_names) print(month_names) # 输出： # 0 Wednesday # 1 Thursday # dtype: object # 0 September # 1 September # dtype: object -
to_period(freq)：将日期时间对象转换为周期对象，其中freq是频率字符串，用于指定周期的频率。示例：
import pandas as pd datetime_series = pd.to_datetime(['2023-09-28 14:30:00', '2023-09-29 15:45:00']) period_series = datetime_series.dt.to_period('D') # 转换为每日周期 print(period_series) # 输出： # 0 2023-09-28 # 1 2023-09-29 # dtype: period[D]
这些属性和方法允许您在 Pandas 中对日期时间对象进行更深入的操作和分析。您可以使用 .dt 访问器来提取日期时间的各个部分、格式化为字符串、获取星期和月份的名称，以及将日期时间对象转换为周期对象等。这些功能使得 Pandas 成为处理日期时间数据的强大工具。根据您的需求，您可以选择使用这些属性和方法来分析和操作日期时间数据。
dt.floor()
dt.floor() 是 Pandas 中用于向下取整日期时间数据的方法，可以用于将日期时间数据舍入到指定的时间单位。以下是 dt.floor() 的详细参数解释和示例演示其用法和输出结果：
参数解释：
freq：指定要舍入到的时间单位，可以是字符串，如 ‘D’（天），‘H’（小时），‘T’（分钟）等。这个参数是必需的。
示例和输出结果：
import pandas as pd
# 创建一个包含日期时间的 DataFrame
data = {'date_time': ['2023-09-27 15:30:00', '2023-10-15 08:45:00', '2023-11-20 18:00:00']}
df = pd.DataFrame(data)
# 将 'date_time' 列转换为 datetime64 类型
df['date_time'] = pd.to_datetime(df['date_time'])
# 使用 df.dt.floor() 将日期时间舍入到小时
df['floor_hour'] = df['date_time'].dt.floor('H')
# 使用 df.dt.floor() 将日期时间舍入到分钟
df['floor_minute'] = df['date_time'].dt.floor('T')
print(df)
输出结果：
date_time floor_hour floor_minute
0 2023-09-27 15:30:00 2023-09-27 15:00:00 2023-09-27 15:30:00
1 2023-10-15 08:45:00 2023-10-15 08:00:00 2023-10-15 08:45:00
2 2023-11-20 18:00:00 2023-11-20 18:00:00 2023-11-20 18:00:00
在上述示例中，我们首先将 ‘date_time’ 列转换为 datetime64 类型，然后使用 df.dt.floor() 方法将日期时间数据舍入到小时和分钟。这样，我们可以根据需要将日期时间数据精确到指定的时间单位，方便数据处理和分析。
pd.date_range()
pd.date_range() 是 pandas 中用于生成日期时间范围的函数，它可以帮助您创建一系列日期时间值，用于时间序列分析和数据操作。以下是 pd.date_range() 函数的详细参数解释以及示例：
- 基本用法：
pd.date_range(start=None, end=None, periods=None, freq='D', tz=None, normalize=False, name=None, closed=None, **kwargs)
-
参数解释：
-
start：可选参数，表示日期时间范围的开始日期时间。默认为None，如果未提供，则必须提供end或periods。 -
end：可选参数，表示日期时间范围的结束日期时间。默认为None，如果未提供，则必须提供start或periods。 -
periods：可选参数，表示生成日期时间范围的总周期数。可以与start或end一起使用，用于确定日期时间范围的长度。 -
freq：可选参数，表示日期时间的频率（间隔）。默认为 ‘D’，表示每日频率。可以是各种时间频率的字符串，例如 ‘H’ 表示每小时，‘M’ 表示月末，'MS’表示月初，‘W’ 表示每周等，'Y’表示年末，'YS’表示年初。 -
tz：可选参数，用于指定日期时间的时区。 -
normalize：可选参数，如果设置为 True，则规范化日期时间范围的时间部分为午夜（00:00:00）。 -
name：可选参数，用于为生成的日期时间范围指定名称。 -
closed：可选参数，用于指定日期时间范围的封闭方式，可以是 ‘right’（默认值）、‘left’、‘both’ 或 ‘neither’。 -
**kwargs：其他可选参数，用于传递给日期时间频率对象的额外参数。
示例和输出结果：
下面是一些示例，演示了如何使用 pd.date_range() 创建日期时间范围：
import pandas as pd
# 示例 1: 创建一个日期时间范围，指定开始和结束日期
date_range1 = pd.date_range(start='2023-09-01', end='2023-09-05')
print(date_range1)
# 示例 2: 创建一个日期时间范围，指定周期数
date_range2 = pd.date_range(start='2023-09-01', periods=5)
print(date_range2)
# 示例 3: 创建一个每小时的日期时间范围
hourly_range = pd.date_range(start='2023-09-01', end='2023-09-02', freq='H')
print(hourly_range)
# 示例 4: 创建一个每月最后一天的日期时间范围
monthly_last_day = pd.date_range(start='2023-01-31', end='2023-12-31', freq='M')
print(monthly_last_day)
输出结果：
DatetimeIndex(['2023-09-01', '2023-09-02', '2023-09-03', '2023-09-04',
'2023-09-05'],
dtype='datetime64[ns]', freq='D')
DatetimeIndex(['2023-09-01', '2023-09-02', '2023-09-03', '2023-09-04',
'2023-09-05'],
dtype='datetime64[ns]', freq='D')
DatetimeIndex(['2023-09-01 00:00:00', '2023-09-01 01:00:00',
'2023-09-01 02:00:00', '2023-09-01 03:00:00',
'2023-09-01 04:00:00', '2023-09-01 05:00:00',
'2023-09-01 06:00:00', '2023-09-01 07:00:00',
'2023-09-01 08:00:00', '2023-09-01 09:00:00',
'2023-09-01 10:00:00', '2023-09-01 11:00:00',
'2023-09-01 12:00:00', '2023-09-01 13:00:00',
'2023-09-01 14:00:00', '2023-09-01 15:00:00',
'2023-09-01 16:00:00', '2023-09-01 17:00:00',
'2023-09-01 18:00:00', '2023-09-01 19:00:00',
'2023-09-01 20:00:00', '2023-09-01 21:00:00',
'2023-09-01 22:00:00', '2023-09-01 23:00:00',
'2023-09-02 00:00:00'],
dtype='datetime64[ns]', freq='H')
DatetimeIndex(['2023-01-31', '2023-02-28', '2023-03-31', '2023-04-30',
'2023-05-31', '2023-06-30', '2023-07-31', '2023-08-31',
'2023-09-30', '2023-10-31', '2023-11-30', '2023-12-31'],
dtype='datetime64[ns]', freq='M')
df.index.month
df.index.month 是 pandas 数据框（DataFrame）的索引属性之一，用于提取索引中的月份信息。具体来说，它返回一个包含了索引中每个时间戳所对应月份的 Series。
例如，如果你有一个时间序列的数据框，并且该数据框的索引是日期时间类型的时间戳，你可以使用 df.index.month 来获取每个时间戳对应的月份。这对于进行按月份分组或计算月度统计信息非常有用。
以下是一个简单的示例，演示了 df.index.month 的用法：
import pandas as pd
# 创建一个示例数据框
data = {
'Value': [10, 20, 30, 25],
'Date': ['2021-01-15', '2021-02-20', '2021-03-10', '2021-03-25']
}
df = pd.DataFrame(data)
# 将 'Date' 列转换为日期时间类型
df['Date'] = pd.to_datetime(df['Date'])
# 将 'Date' 列设置为数据框的索引
df.set_index('Date', inplace=True)
# 使用 df.index.month 获取月份信息
months = df.index.month
print(months)
输出示例：
Date
2021-01-15 1
2021-02-20 2
2021-03-10 3
2021-03-25 3
Name: Date, dtype: int64
在上述示例中，df.index.month 返回了一个包含了索引中每个时间戳对应的月份的 Series。你可以进一步使用这个 Series 来进行按月份的分组、计算每个月份的统计量等操作。
pd.Grouper
pd.Grouper() 是 pandas 库中用于处理时间序列数据的一个功能强大的工具。它可以在对时间序列数据进行分组操作时提供很大的便利性。
pd.Grouper() 主要用于在聚合操作（如 groupby()）中指定时间间隔，以便对数据进行按时间分组。下面是一些主要的参数和用法：
key：用于指定要分组的时间序列列的名称。freq：用于指定分组的频率，可以是字符串（如 ‘D’ 表示天，‘M’ 表示月，‘A’ 表示年等）或 pandas DateOffset 对象。level：如果时间序列是多层索引的一部分，可以使用此参数指定要分组的级别。axis：如果时间序列不在默认的列中，可以使用此参数指定轴的方向（0 表示行，1 表示列）。sort：一个布尔值，表示是否在分组之前对数据进行排序。closed：用于指定时间区间的哪一侧是闭合的。默认为 ‘right’，表示右侧是闭合的，可以设置为 ‘left’。label：一个布尔值，用于指定分组的标签是否为时间间隔的左侧边界。convention：用于指定开始和结束时间的约定，可以是 ‘start’（默认）或 ‘end’。
下面是一个简单的例子，假设我们有一个包含日期和对应数值的数据框 df：
import pandas as pd
from datetime import datetime
date_rng = pd.date_range(start='2023-09-01', end='2023-09-10', freq='D')
print('date_rng的输出结果为:\n',date_rng)
data = {'date': date_rng, 'value': range(10)}
df = pd.DataFrame(data)
print('df的输出结果为:\n',df)
# 使用 pd.Grouper() 按每月分组
df.groupby(pd.Grouper(key='date', freq='M')).sum()
date_rng的输出结果为:
DatetimeIndex(['2023-09-01', '2023-09-02', '2023-09-03', '2023-09-04',
'2023-09-05', '2023-09-06', '2023-09-07', '2023-09-08',
'2023-09-09', '2023-09-10'],
dtype='datetime64[ns]', freq='D')
df的输出结果为:
date value
0 2023-09-01 0
1 2023-09-02 1
2 2023-09-03 2
3 2023-09-04 3
4 2023-09-05 4
5 2023-09-06 5
6 2023-09-07 6
7 2023-09-08 7
8 2023-09-09 8
9 2023-09-10 9
date value
2023-09-30 45
在上面的例子中，我们首先创建了一个包含日期范围的时间序列 date_rng，然后将其用作数据框的日期列。接着，我们使用 pd.Grouper() 将数据框按每月分组，并对每组进行了求和操作。
以下是几个使用 pd.Grouper 的示例：
示例 1：按月份分组并计算每月的平均值
import pandas as pd
# 创建包含日期时间和数值的 DataFrame
data = {
'date': pd.date_range(start='2023-01-01', periods=12, freq='M'),
'value': [10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65]
}
df = pd.DataFrame(data)
print('df的输出结果是：\n',df)
# 使用 pd.Grouper 按月份分组并计算每月的平均值
result = df.groupby(pd.Grouper(key='date', freq='M')).mean()
print('result的输出结果是：\n',result)
输出结果：
df的输出结果是：（因为M表示月末，MS表示月初）
date value
0 2023-01-31 10
1 2023-02-28 15
2 2023-03-31 20
3 2023-04-30 25
4 2023-05-31 30
5 2023-06-30 35
6 2023-07-31 40
7 2023-08-31 45
8 2023-09-30 50
9 2023-10-31 55
10 2023-11-30 60
11 2023-12-31 65
result的输出结果是：
value
date
2023-01-31 10.0
2023-02-28 15.0
2023-03-31 20.0
2023-04-30 25.0
2023-05-31 30.0
2023-06-30 35.0
2023-07-31 40.0
2023-08-31 45.0
2023-09-30 50.0
2023-10-31 55.0
2023-11-30 60.0
2023-12-31 65.0
示例 2：按周和年分组并计算每周的总和
import pandas as pd
# 创建包含日期时间和数值的 DataFrame
data = {
'date': pd.date_range(start='2023-01-01', periods=365, freq='D'),
'value': range(1, 366)
}
df = pd.DataFrame(data)
# 使用 pd.Grouper 按周和年分组并计算每周的总和
result = df.groupby([pd.Grouper(key='date', freq='W'), pd.Grouper(key='date', freq='Y')])['value'].sum()
print(result)
df的输出结果是：
date value
0 2023-01-01 1
1 2023-01-02 2
2 2023-01-03 3
3 2023-01-04 4
4 2023-01-05 5
.. ... ...
360 2023-12-27 361
361 2023-12-28 362
362 2023-12-29 363
363 2023-12-30 364
364 2023-12-31 365
[365 rows x 2 columns]
result的输出结果是：
date date
2023-01-01 2023-12-31 1
2023-01-08 2023-12-31 35
2023-01-15 2023-12-31 84
2023-01-22 2023-12-31 133
2023-01-29 2023-12-31 182
2023-02-05 2023-12-31 231
2023-02-12 2023-12-31 280
2023-02-19 2023-12-31 329
2023-02-26 2023-12-31 378
2023-03-05 2023-12-31 427
2023-03-12 2023-12-31 476
2023-03-19 2023-12-31 525
2023-03-26 2023-12-31 574
2023-04-02 2023-12-31 623
2023-04-09 2023-12-31 672
2023-04-16 2023-12-31 721
2023-04-23 2023-12-31 770
2023-04-30 2023-12-31 819
2023-05-07 2023-12-31 868
2023-05-14 2023-12-31 917
2023-05-21 2023-12-31 966
2023-05-28 2023-12-31 1015
2023-06-04 2023-12-31 1064
2023-06-11 2023-12-31 1113
2023-06-18 2023-12-31 1162
2023-06-25 2023-12-31 1211
2023-07-02 2023-12-31 1260
2023-07-09 2023-12-31 1309
2023-07-16 2023-12-31 1358
2023-07-23 2023-12-31 1407
2023-07-30 2023-12-31 1456
2023-08-06 2023-12-31 1505
2023-08-13 2023-12-31 1554
2023-08-20 2023-12-31 1603
2023-08-27 2023-12-31 1652
2023-09-03 2023-12-31 1701
2023-09-10 2023-12-31 1750
2023-09-17 2023-12-31 1799
2023-09-24 2023-12-31 1848
2023-10-01 2023-12-31 1897
2023-10-08 2023-12-31 1946
2023-10-15 2023-12-31 1995
2023-10-22 2023-12-31 2044
2023-10-29 2023-12-31 2093
2023-11-05 2023-12-31 2142
2023-11-12 2023-12-31 2191
2023-11-19 2023-12-31 2240
2023-11-26 2023-12-31 2289
2023-12-03 2023-12-31 2338
2023-12-10 2023-12-31 2387
2023-12-17 2023-12-31 2436
2023-12-24 2023-12-31 2485
2023-12-31 2023-12-31 2534
Name: value, dtype: int64
示例 3：按小时和星期几分组并计算每小时的平均值
import pandas as pd
import numpy as np
# 创建包含日期时间和数值的 DataFrame
data = {
'date': pd.date_range(start='2023-09-01', periods=24, freq='H'),
'value': np.random.randint(1, 100, size=24)
}
df = pd.DataFrame(data)
# 使用 pd.Grouper 按小时和星期几分组并计算每小时的平均值
result = df.groupby([pd.Grouper(key='date', freq='H'), pd.Grouper(key='date', freq='W')])['value'].mean()
print(result)
这些示例演示了如何使用 pd.Grouper 对日期时间数据进行分组和聚合操作。通过适当选择频率和键，您可以执行各种不同的日期时间分析和统计操作。
pd.DateOffset
pd.DateOffset 是 Pandas 中用于处理日期偏移的类。它允许你在日期上执行各种偏移操作，例如将日期向前或向后移动一定的时间间隔。以下是 pd.DateOffset 的基本信息、函数签名、各参数的详细解释以及示例：
函数签名：
pd.DateOffset(n=1, normalize=False, month_end=False, **kwds)
参数说明：
n（默认值为1）：表示要添加或减去的偏移数量，可以是正数或负数。它用于指定你要将日期向前或向后移动多少个偏移单元。normalize（默认值为False）：表示是否将结果日期规范化为午夜（00:00:00）。如果设置为 True，则结果日期的时间部分将被规范化为午夜；否则，时间部分保持不变。month_end（默认值为False）：表示是否将偏移应用到月末。如果设置为 True，则偏移将被应用到当前月的最后一天；否则，它将被应用到原始日期加上 n 个偏移单位。**kwds：可以接受其他参数，这些参数将传递给内部的 pandas DateOffset 子类（例如，BusinessDay、Week、Hour 等），以进一步定制偏移行为。
示例：
import pandas as pd
# 创建一个 pd.DateOffset 对象，表示向后移动一天
offset = pd.DateOffset(days=1)
date = pd.Timestamp('2023-10-09')
# 应用偏移并打印结果
new_date = date + offset
print(new_date) # 输出：2023-10-10 00:00:00
# 创建一个 pd.DateOffset 对象，表示向前移动一个工作日
offset = pd.DateOffset(weekday=0) # 0表示周一
date = pd.Timestamp('2023-10-09')
# 应用偏移并打印结果
new_date = date - offset
print(new_date) # 输出：2023-10-02 00:00:00
pd.DateOffset 的常用属性和方法包括：
freqstr属性：返回该偏移的字符串表示，例如 ‘D’ 表示一天、‘H’ 表示一小时。name属性：返回该偏移的名称，例如 ‘Day’ 表示一天。rollforward方法：将日期向前滚动到下一个符合偏移要求的日期。rollback方法：将日期向后滚动到上一个符合偏移要求的日期。
这些属性和方法可以帮助你更灵活地处理日期偏移对象。例如，你可以使用 rollforward 方法将日期滚动到下一个工作日，或者使用 name 属性获取偏移的名称。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
