目录
一、用法精讲
296、pandas.Series.dt.as_unit方法
296-1、语法
296-2、参数
296-3、功能
296-4、返回值
296-5、说明
296-6、用法
296-6-1、数据准备
296-6-2、代码示例
296-6-3、结果输出
297、pandas.Series.dt.days属性
297-1、语法
297-2、参数
297-3、功能
297-4、返回值
297-5、说明
297-6、用法
297-6-1、数据准备
297-6-2、代码示例
297-6-3、结果输出
298、pandas.Series.dt.seconds属性
298-1、语法
298-2、参数
298-3、功能
298-4、返回值
298-5、说明
298-6、用法
298-6-1、数据准备
298-6-2、代码示例
298-6-3、结果输出
299、pandas.Series.dt.microseconds属性
299-1、语法
299-2、参数
299-3、功能
299-4、返回值
299-5、说明
299-6、用法
299-6-1、数据准备
299-6-2、代码示例
299-6-3、结果输出
300、pandas.Series.dt.nanoseconds属性
300-1、语法
300-2、参数
300-3、功能
300-4、返回值
300-5、说明
300-6、用法
300-6-1、数据准备
300-6-2、代码示例
300-6-3、结果输出
二、推荐阅读
1、Python筑基之旅
2、Python函数之旅
3、Python算法之旅
4、Python魔法之旅
5、博客个人主页
一、用法精讲
296、pandas.Series.dt.as_unit方法
296-1、语法
# 296、pandas.Series.dt.as_unit方法
pandas.Series.dt.as_unit(*args, **kwargs)296-2、参数
296-2-1、unit(必须)：字符串，指定目标时间单位，具体包括：'Y'(年)、 'M'(月)、'D'(日)、'h'(小时)、 'm'(分钟)、's'(秒)、'ms'(毫秒)、 'us'(微秒)、'ns'(纳秒)。
296-3、功能
将DatetimeIndex对象中的时间数据转换为指定的时间单位，这对于时间序列数据的处理非常有用，特别是在需要将时间数据从高精度单位转换为低精度单位时。
296-4、返回值
返回一个新的pandas.Series对象，其中的时间数据被转换为指定的时间单位，转换后的数据会以指定的时间单位进行表示。
296-5、说明
使用场景：
296-5-1、时间序列重采样： 在进行重采样操作时，可能需要将高频率的时间戳转换为低频率的时间单位。例如，将分钟级别的数据转换为小时级别的数据，方便进行日常或周分析。
296-5-2、特征工程： 在机器学习模型中，有时需要将时间特征转换为更易于理解或使用的格式。比如，将时间戳转换为天数或小时数，以便进行数值计算或分类。
296-5-3、可视化： 在数据可视化时，选择合适的时间单位可以使图表更清晰。例如，将秒级别的数据转换为分钟或小时，可以使图表更易于阅读。
296-5-4、统计分析： 进行时间序列的统计分析时，可能需要将数据转换为不同的时间单位，以便计算如平均值、标准差等统计量。
296-6、用法
296-6-1、数据准备
无296-6-2、代码示例
# 296、pandas.Series.dt.as_unit方法
# 296-1、时间序列重采样
import pandas as pd
# 创建分钟级别的时间序列数据
minute_data = pd.Series(range(60), index=pd.date_range('2024-01-01', periods=60, freq='min'))
# 将数据重采样为小时
hourly_data = minute_data.resample('h').sum()
print(hourly_data, end='\n\n')
# 296-2、特征工程
import pandas as pd
# 创建一个时间序列
time_series = pd.Series(pd.date_range('2024-01-01', periods=10, freq='h'))
# 将时间转换为小时数
hours_since_start = (time_series - time_series.min()).dt.total_seconds() / 3600
print(hours_since_start, end='\n\n')
# 296-3、可视化
import pandas as pd
import matplotlib.pyplot as plt
# 创建一个小时级别的时间序列数据
hourly_data = pd.Series(range(24), index=pd.date_range('2024-01-01', periods=24, freq='h'))
# 将数据按天显示
daily_data = hourly_data.resample('D').sum()
# 可视化
daily_data.plot(kind='bar', color='purple')
plt.title('Daily Data')
plt.xlabel('Date')
plt.ylabel('Value')
plt.xticks(rotation=0)
plt.show()
# 296-4、统计分析
import pandas as pd
# 创建一个包含随机时间戳的数据
timestamps = pd.Series(pd.date_range('2024-01-01', periods=100, freq='min'))
# 计算每分钟的计数，并转换为小时
count_per_hour = timestamps.dt.to_period('h').value_counts()
print(count_per_hour, end='\n\n')296-6-3、结果输出
# 296、pandas.Series.dt.as_unit方法
# 296-1、时间序列重采样
# 2024-01-01 1770
# Freq: h, dtype: int64
# 296-2、特征工程
# 0 0.0
# 1 1.0
# 2 2.0
# 3 3.0
# 4 4.0
# 5 5.0
# 6 6.0
# 7 7.0
# 8 8.0
# 9 9.0
# dtype: float64
# 296-3、可视化
# 见图1
# 296-4、统计分析
# 2024-01-01 00:00 60
# 2024-01-01 01:00 40
# Freq: h, Name: count, dtype: int64图1：
297、pandas.Series.dt.days属性
297-1、语法
# 297、pandas.Series.dt.days属性
pandas.Series.dt.days297-2、参数
无
297-3、功能
用于提取时间间隔(timedelta)的天数部分，该属性通常应用于包含时间间隔数据的Series对象。
297-4、返回值
返回一个新的Series，其值为原始时间间隔的天数部分，数据类型为整数(int64)。
297-5、说明
使用场景：
297-5-1、项目管理和任务追踪：在项目管理中，可能需要分析任务的持续时间。例如，找到所有超过一定天数的任务。
297-5-2、营销活动分析：在分析营销活动的效果时，可能需要计算用户从注册到首次购买的天数，然后分析这段时间的分布。
297-5-3、工业和制造：在工业或制造领域，可能需要计算机器维修的间隔时间，并分析这些间隔时间以优化维护计划。
297-5-4、医疗健康：在医疗分析中，该属性可以用于计算患者在住院期间和康复期间的天数。
297-6、用法
297-6-1、数据准备
无297-6-2、代码示例
# 297、pandas.Series.dt.qyear属性
# 297-1、项目管理和任务追踪
import pandas as pd
# 创建一个包含任务开始和结束时间的DataFrame
data = {
'task_id': [1, 2, 3],
'start_time': ['2024-01-01', '2024-01-05', '2024-01-10'],
'end_time': ['2024-01-05', '2024-01-10', '2024-01-20']
}
df = pd.DataFrame(data)
df['start_time'] = pd.to_datetime(df['start_time'])
df['end_time'] = pd.to_datetime(df['end_time'])
# 计算每个任务的持续时间
df['duration'] = df['end_time'] - df['start_time']
# 提取持续时间中的天数
df['duration_days'] = df['duration'].dt.days
# 过滤掉持续时间超过5天的任务
long_tasks = df[df['duration_days'] > 5]
print(long_tasks, end='\n\n')
# 297-2、营销活动分析
import pandas as pd
# 创建一个包含用户注册和首次购买时间的DataFrame
data = {
'user_id': [1001, 1002, 1003],
'registration_date': ['2024-01-01', '2024-01-10', '2024-01-15'],
'first_purchase_date': ['2024-01-15', '2024-01-20', '2024-01-25']
}
df = pd.DataFrame(data)
df['registration_date'] = pd.to_datetime(df['registration_date'])
df['first_purchase_date'] = pd.to_datetime(df['first_purchase_date'])
# 计算从注册到首次购买的时间间隔
df['time_to_first_purchase'] = df['first_purchase_date'] - df['registration_date']
# 提取间隔中的天数
df['days_to_first_purchase'] = df['time_to_first_purchase'].dt.days
print(df, end='\n\n')
# 297-3、工业和制造
import pandas as pd
# 创建一个包含机器维修记录的DataFrame
data = {
'machine_id': [1, 1, 1, 2, 2],
'repair_date': ['2024-01-01', '2024-01-15', '2024-02-01', '2024-01-10', '2024-01-25']
}
df = pd.DataFrame(data)
df['repair_date'] = pd.to_datetime(df['repair_date'])
# 按机器和时间排序记录
df = df.sort_values(by=['machine_id', 'repair_date'])
# 计算维修间隔
df['previous_repair_date'] = df.groupby('machine_id')['repair_date'].shift(1)
df['repair_interval'] = df['repair_date'] - df['previous_repair_date']
# 提取间隔中的天数
df['repair_interval_days'] = df['repair_interval'].dt.days
print(df, end='\n\n')
# 297-4、医疗健康
import pandas as pd
# 创建一个包含患者入院和出院日期的DataFrame
data = {
'patient_id': [1, 2, 3],
'admission_date': ['2024-01-01', '2024-01-10', '2024-01-15'],
'discharge_date': ['2024-01-20', '2024-01-15', '2024-02-01']
}
df = pd.DataFrame(data)
df['admission_date'] = pd.to_datetime(df['admission_date'])
df['discharge_date'] = pd.to_datetime(df['discharge_date'])
# 计算住院天数
df['hospital_stay_duration'] = df['discharge_date'] - df['admission_date']
# 提取住院天数
df['hospital_stay_days'] = df['hospital_stay_duration'].dt.days
print(df)297-6-3、结果输出
# 297、pandas.Series.dt.qyear属性
# 297-1、项目管理和任务追踪
# task_id start_time end_time duration duration_days
# 2 3 2024-01-10 2024-01-20 10 days 10
# 297-2、营销活动分析
# user_id registration_date ... time_to_first_purchase days_to_first_purchase
# 0 1001 2024-01-01 ... 14 days 14
# 1 1002 2024-01-10 ... 10 days 10
# 2 1003 2024-01-15 ... 10 days 10
#
# [3 rows x 5 columns]
# 297-3、工业和制造
# machine_id repair_date ... repair_interval repair_interval_days
# 0 1 2024-01-01 ... NaT NaN
# 1 1 2024-01-15 ... 14 days 14.0
# 2 1 2024-02-01 ... 17 days 17.0
# 3 2 2024-01-10 ... NaT NaN
# 4 2 2024-01-25 ... 15 days 15.0
#
# [5 rows x 5 columns]
# 297-4、医疗健康
# patient_id admission_date ... hospital_stay_duration hospital_stay_days
# 0 1 2024-01-01 ... 19 days 19
# 1 2 2024-01-10 ... 5 days 5
# 2 3 2024-01-15 ... 17 days 17
#
# [3 rows x 5 columns]298、pandas.Series.dt.seconds属性
298-1、语法
# 298、pandas.Series.dt.seconds属性
pandas.Series.dt.seconds
Number of seconds (>= 0 and less than 1 day) for each element.298-2、参数
无
298-3、功能
用于从时间间隔(即timedelta对象)中提取秒数，该属性返回时间间隔中所包含的整秒数，而不包括分钟、小时等更大单位的部分。
298-4、返回值
一个Series对象，由整型构成，其中每个值表示对应时间间隔中的整秒数部分。
298-5、说明
使用场景：
298-5-1、任务和事件持续时间分析：在项目管理中，通常需要分析每个任务或事件的持续时间，以便进行资源分配和效率评估。
298-5-2、网站会话分析：在网站分析中，了解用户会话的持续时间对于优化用户体验至关重要。
298-5-3、机器运行时间分析：在制造业中，分析机器的运行时间有助于维护和优化生产效率。
298-5-4、视频播放分析：在多媒体分析中，计算视频播放的持续时间有助于理解用户的观看行为。
298-6、用法
298-6-1、数据准备
无298-6-2、代码示例
# 298、pandas.Series.dt.seconds属性
# 298-1、任务和事件持续时间分析
import pandas as pd
# 创建包含任务开始和结束时间的数据
data = {
'task_id': [1, 2, 3],
'start_time': ['2024-01-01 08:00:00', '2024-01-02 09:00:00', '2024-01-03 10:00:00'],
'end_time': ['2024-01-01 08:30:30', '2024-01-02 09:45:15', '2024-01-03 10:25:50']
}
df = pd.DataFrame(data)
df['start_time'] = pd.to_datetime(df['start_time'])
df['end_time'] = pd.to_datetime(df['end_time'])
# 计算每个任务的持续时间
df['duration'] = df['end_time'] - df['start_time']
# 提取持续时间中的秒数
df['duration_seconds'] = df['duration'].dt.seconds
print(df, end='\n\n')
# 298-2、网站会话分析
import pandas as pd
# 创建包含用户会话开始和结束时间的数据
data = {
'session_id': [101, 102, 103],
'login_time': ['2024-01-01 10:00:00', '2024-01-01 10:15:00', '2024-01-01 11:00:00'],
'logout_time': ['2024-01-01 10:25:00', '2024-01-01 10:30:30', '2024-01-01 11:20:45']
}
df = pd.DataFrame(data)
df['login_time'] = pd.to_datetime(df['login_time'])
df['logout_time'] = pd.to_datetime(df['logout_time'])
# 计算每个会话的持续时间
df['session_duration'] = df['logout_time'] - df['login_time']
# 提取会话持续时间中的秒数
df['session_duration_seconds'] = df['session_duration'].dt.seconds
print(df, end='\n\n')
# 298-3、机器运行时间分析
import pandas as pd
# 创建包含机器运行开始和结束时间的数据
data = {
'machine_id': [1, 2, 3],
'start_time': ['2024-01-01 06:00:00', '2024-01-01 12:00:00', '2024-01-01 18:00:00'],
'end_time': ['2024-01-01 08:15:45', '2024-01-01 14:30:20', '2024-01-01 20:45:50']
}
df = pd.DataFrame(data)
df['start_time'] = pd.to_datetime(df['start_time'])
df['end_time'] = pd.to_datetime(df['end_time'])
# 计算每台机器的运行时间
df['running_duration'] = df['end_time'] - df['start_time']
# 提取运行时间中的秒数
df['running_duration_seconds'] = df['running_duration'].dt.seconds
print(df, end='\n\n')
# 298-4、视频播放分析
import pandas as pd
# 创建包含视频播放开始和结束时间的数据
data = {
'video_id': [1, 2, 3],
'start_time': ['2024-01-01 12:00:00', '2024-01-01 13:00:00', '2024-01-01 14:00:00'],
'end_time': ['2024-01-01 12:10:30', '2024-01-01 13:15:45', '2024-01-01 14:20:50']
}
df = pd.DataFrame(data)
df['start_time'] = pd.to_datetime(df['start_time'])
df['end_time'] = pd.to_datetime(df['end_time'])
# 计算每次播放的持续时间
df['playback_duration'] = df['end_time'] - df['start_time']
# 提取播放持续时间中的秒数
df['playback_duration_seconds'] = df['playback_duration'].dt.seconds
print(df)298-6-3、结果输出
# 298、pandas.Series.dt.seconds属性
# 298-1、任务和事件持续时间分析
# task_id start_time ... duration duration_seconds
# 0 1 2024-01-01 08:00:00 ... 0 days 00:30:30 1830
# 1 2 2024-01-02 09:00:00 ... 0 days 00:45:15 2715
# 2 3 2024-01-03 10:00:00 ... 0 days 00:25:50 1550
#
# [3 rows x 5 columns]
# 298-2、网站会话分析
# session_id login_time ... session_duration session_duration_seconds
# 0 101 2024-01-01 10:00:00 ... 0 days 00:25:00 1500
# 1 102 2024-01-01 10:15:00 ... 0 days 00:15:30 930
# 2 103 2024-01-01 11:00:00 ... 0 days 00:20:45 1245
#
# [3 rows x 5 columns]
# 298-3、机器运行时间分析
# machine_id start_time ... running_duration running_duration_seconds
# 0 1 2024-01-01 06:00:00 ... 0 days 02:15:45 8145
# 1 2 2024-01-01 12:00:00 ... 0 days 02:30:20 9020
# 2 3 2024-01-01 18:00:00 ... 0 days 02:45:50 9950
#
# [3 rows x 5 columns]
# 298-4、视频播放分析
# video_id start_time ... playback_duration playback_duration_seconds
# 0 1 2024-01-01 12:00:00 ... 0 days 00:10:30 630
# 1 2 2024-01-01 13:00:00 ... 0 days 00:15:45 945
# 2 3 2024-01-01 14:00:00 ... 0 days 00:20:50 1250
#
# [3 rows x 5 columns]299、pandas.Series.dt.microseconds属性
299-1、语法
# 299、pandas.Series.dt.microseconds属性
pandas.Series.dt.microseconds
Number of microseconds (>= 0 and less than 1 second) for each element.299-2、参数
无
299-3、功能
从一个时间间隔(timedelta)对象中提取微秒部分。
299-4、返回值
返回一个整数序列，每个整数表示时间间隔的微秒部分。
299-5、说明
使用场景：
299-5-1、精确任务持续时间分析：在需要精确计算任务持续时间的场景下，特别是需要精确到微秒级别时，这个属性非常有用。
299-5-2、高频交易数据分析：在金融领域，高频交易数据的时间戳精度要求极高，需要分析交易执行时间精确到微秒。
299-5-3、科学实验数据分析：在科学实验中，尤其是物理实验和工程测试中，常常需要对精确到微秒的时间间隔进行分析。
299-6、用法
299-6-1、数据准备
无299-6-2、代码示例
# 299、pandas.Series.dt.microseconds属性
# 299-1、精确任务持续时间分析
import pandas as pd
# 创建包含任务开始和结束时间的数据
data = {
'task_id': [1, 2, 3],
'start_time': ['2024-01-01 08:00:00.123456', '2024-01-02 09:00:00.654321', '2024-01-03 10:00:00.789012'],
'end_time': ['2024-01-01 08:30:30.654321', '2024-01-02 09:45:15.987654', '2024-01-03 10:25:50.123456']
}
df = pd.DataFrame(data)
df['start_time'] = pd.to_datetime(df['start_time'])
df['end_time'] = pd.to_datetime(df['end_time'])
# 计算每个任务的持续时间
df['duration'] = df['end_time'] - df['start_time']
# 提取持续时间中的微秒数
df['duration_microseconds'] = df['duration'].dt.microseconds
print(df, end='\n\n')
# 299-2、高频交易数据分析
import pandas as pd
# 创建包含交易执行时间的数据
data = {
'trade_id': [1, 2, 3],
'execution_start': ['2024-01-01 09:30:00.123456', '2024-01-01 09:30:01.654321', '2024-01-01 09:30:02.789012'],
'execution_end': ['2024-01-01 09:30:00.223456', '2024-01-01 09:30:01.754321', '2024-01-01 09:30:02.889012']
}
df = pd.DataFrame(data)
df['execution_start'] = pd.to_datetime(df['execution_start'])
df['execution_end'] = pd.to_datetime(df['execution_end'])
# 计算每笔交易的执行时间
df['execution_duration'] = df['execution_end'] - df['execution_start']
# 提取执行时间中的微秒数
df['execution_microseconds'] = df['execution_duration'].dt.microseconds
print(df, end='\n\n')
# 299-3、科学实验数据分析
import pandas as pd
# 创建包含实验开始和结束时间的数据
data = {
'experiment_id': [1, 2, 3],
'start_time': ['2024-01-01 12:00:00.000123', '2024-01-01 12:30:00.000456', '2024-01-01 13:00:00.000789'],
'end_time': ['2024-01-01 12:00:00.000223', '2024-01-01 12:30:00.000556', '2024-01-01 13:00:00.000889']
}
df = pd.DataFrame(data)
df['start_time'] = pd.to_datetime(df['start_time'])
df['end_time'] = pd.to_datetime(df['end_time'])
# 计算每个实验的持续时间
df['duration'] = df['end_time'] - df['start_time']
# 提取持续时间中的微秒数
df['duration_microseconds'] = df['duration'].dt.microseconds
print(df)299-6-3、结果输出
# 299、pandas.Series.dt.microseconds属性
# 299-1、精确任务持续时间分析
# task_id ... duration_microseconds
# 0 1 ... 530865
# 1 2 ... 333333
# 2 3 ... 334444
#
# [3 rows x 5 columns]
# 299-2、高频交易数据分析
# trade_id ... execution_microseconds
# 0 1 ... 100000
# 1 2 ... 100000
# 2 3 ... 100000
#
# [3 rows x 5 columns]
# 299-3、科学实验数据分析
# experiment_id ... duration_microseconds
# 0 1 ... 100
# 1 2 ... 100
# 2 3 ... 100
#
# [3 rows x 5 columns]300、pandas.Series.dt.nanoseconds属性
300-1、语法
# 300、pandas.Series.dt.nanoseconds属性
pandas.Series.dt.nanoseconds
Number of nanoseconds (>= 0 and less than 1 microsecond) for each element.300-2、参数
无
300-3、功能
从一个时间间隔(timedelta)对象中提取纳秒部分。
300-4、返回值
返回一个整数序列，每个整数表示时间间隔的纳秒部分。
300-5、说明
使用场景：
300-5-1、高精度科学实验分析：在一些高精度的科学实验中，例如物理实验和工程测试中，数据记录可能精确到纳秒级别。
300-5-2、高频交易分析：在金融领域，高频交易的数据精确度要求极高，需要分析交易执行时间精确到纳秒。
300-5-3、电子工程测试：在电子工程测试中，例如测量信号延迟和处理时间，常常需要精确到纳秒级别的时间分析。
300-6、用法
300-6-1、数据准备
无300-6-2、代码示例
# 300、pandas.Series.dt.nanoseconds属性
# 300-1、高精度科学实验分析
import pandas as pd
# 创建包含实验开始和结束时间的数据
data = {
'experiment_id': [1, 2, 3],
'start_time': ['2024-01-01 12:00:00.000000123', '2024-01-01 12:30:00.000000456', '2024-01-01 13:00:00.000000789'],
'end_time': ['2024-01-01 12:00:00.000000223', '2024-01-01 12:30:00.000000556', '2024-01-01 13:00:00.000000889']
}
df = pd.DataFrame(data)
df['start_time'] = pd.to_datetime(df['start_time'])
df['end_time'] = pd.to_datetime(df['end_time'])
# 计算每个实验的持续时间
df['duration'] = df['end_time'] - df['start_time']
# 提取持续时间中的纳秒数
df['duration_nanoseconds'] = df['duration'].dt.nanoseconds
print(df, end='\n\n')
# 300-2、高频交易分析
import pandas as pd
# 创建包含交易执行时间的数据
data = {
'trade_id': [1, 2, 3],
'execution_start': ['2024-01-01 09:30:00.000000163', '2024-01-01 09:30:01.000000486', '2024-01-01 09:30:02.000000799'],
'execution_end': ['2024-01-01 09:30:00.000000223', '2024-01-01 09:30:01.000000556', '2024-01-01 09:30:02.000000889']
}
df = pd.DataFrame(data)
df['execution_start'] = pd.to_datetime(df['execution_start'])
df['execution_end'] = pd.to_datetime(df['execution_end'])
# 计算每笔交易的执行时间
df['execution_duration'] = df['execution_end'] - df['execution_start']
# 提取执行时间中的纳秒数
df['execution_nanoseconds'] = df['execution_duration'].dt.nanoseconds
print(df, end='\n\n')
# 300-3、电子工程测试
import pandas as pd
# 创建包含信号发送和接收时间的数据
data = {
'signal_id': [1, 2, 3],
'send_time': ['2024-01-01 10:00:00.000000316', '2024-01-01 10:05:00.000000618', '2024-01-01 10:10:00.000000889'],
'receive_time': ['2024-01-01 10:00:00.000000423', '2024-01-01 10:05:00.000000856', '2024-01-01 10:10:00.000000989']
}
df = pd.DataFrame(data)
df['send_time'] = pd.to_datetime(df['send_time'])
df['receive_time'] = pd.to_datetime(df['receive_time'])
# 计算每个信号的传输时间
df['transmission_duration'] = df['receive_time'] - df['send_time']
# 提取传输时间中的纳秒数
df['transmission_nanoseconds'] = df['transmission_duration'].dt.nanoseconds
print(df)300-6-3、结果输出
# 300、pandas.Series.dt.nanoseconds属性
# 300-1、高精度科学实验分析
# experiment_id ... duration_nanoseconds
# 0 1 ... 100
# 1 2 ... 100
# 2 3 ... 100
#
# [3 rows x 5 columns]
# 300-2、高频交易分析
# trade_id ... execution_nanoseconds
# 0 1 ... 60
# 1 2 ... 70
# 2 3 ... 90
#
# [3 rows x 5 columns]
# 300-3、电子工程测试
# signal_id ... transmission_nanoseconds
# 0 1 ... 107
# 1 2 ... 238
# 2 3 ... 100
#
# [3 rows x 5 columns]
