目录
一、用法精讲
256、pandas.Series.sparse方法
256-1、语法
256-2、参数
256-3、功能
256-4、返回值
256-5、说明
256-6、用法
256-6-1、数据准备
256-6-2、代码示例
256-6-3、结果输出
257、pandas.DataFrame.sparse方法
257-1、语法
257-2、参数
257-3、功能
257-4、返回值
257-5、说明
257-6、用法
257-6-1、数据准备
257-6-2、代码示例
257-6-3、结果输出
258、pandas.Series.dt.date属性
258-1、语法
258-2、参数
258-3、功能
258-4、返回值
258-5、说明
258-6、用法
258-6-1、数据准备
258-6-2、代码示例
258-6-3、结果输出
259、pandas.Series.dt.time属性
259-1、语法
259-2、参数
259-3、功能
259-4、返回值
259-5、说明
259-6、用法
259-6-1、数据准备
259-6-2、代码示例
259-6-3、结果输出
260、pandas.Series.dt.timetz属性
260-1、语法
260-2、参数
260-3、功能
260-4、返回值
260-5、说明
260-6、用法
260-6-1、数据准备
260-6-2、代码示例
260-6-3、结果输出
二、推荐阅读
1、Python筑基之旅
2、Python函数之旅
3、Python算法之旅
4、Python魔法之旅
5、博客个人主页
一、用法精讲
256、pandas.Series.sparse方法
256-1、语法
# 256、pandas.Series.sparse方法
pandas.Series.sparse()
Accessor for SparseSparse from other sparse matrix data types.256-2、参数
无
256-3、功能
将一个Series对象转换为稀疏数组(SparseArray)，这在处理大规模数据时非常有用，特别是当数据包含大量零值或缺失值时。
256-4、返回值
一个稀疏数组(SparseArray)对象，它是pandas中用于存储稀疏数据的主要数据结构。
256-5、说明
无
256-6、用法
256-6-1、数据准备
无256-6-2、代码示例
# 256、pandas.Series.sparse方法
# 256-1、基本用法
import pandas as pd
s = pd.Series([0, 0, 2, 2, 2], dtype="Sparse[int]")
s1 = s.sparse.density
print(s1)
s2= s.sparse.sp_values
print(s2, end='\n\n')
# 256-2、处理大规模稀疏数据集
import pandas as pd
data = [0, 0, 0, 1, 0, 0, 2, 0, 0, 3]
sparse_series = pd.Series(data).astype(pd.SparseDtype("int", fill_value=0))
print(sparse_series, end='\n\n')
# 256-3、时间序列分析中的缺失数据处理
import pandas as pd
import numpy as np
dates = pd.date_range('2024-01-01', periods=10)
data = [np.nan, 1, np.nan, np.nan, 2, np.nan, np.nan, 3, np.nan, np.nan]
sparse_series = pd.Series(data).astype(pd.SparseDtype("float", fill_value=np.nan))
sparse_series.index = dates
print(sparse_series)256-6-3、结果输出
# 256、pandas.Series.sparse方法
# 256-1、基本用法
# 0.6
# [2 2 2]
# 256-2、处理大规模稀疏数据集
# 0 0
# 1 0
# 2 0
# 3 1
# 4 0
# 5 0
# 6 2
# 7 0
# 8 0
# 9 3
# dtype: Sparse[int32, 0]
# 256-3、时间序列分析中的缺失数据处理
# 2024-01-01 NaN
# 2024-01-02 1.0
# 2024-01-03 NaN
# 2024-01-04 NaN
# 2024-01-05 2.0
# 2024-01-06 NaN
# 2024-01-07 NaN
# 2024-01-08 3.0
# 2024-01-09 NaN
# 2024-01-10 NaN
# Freq: D, dtype: Sparse[float64, nan]257、pandas.DataFrame.sparse方法
257-1、语法
# 257、pandas.DataFrame.sparse方法
pandas.DataFrame.sparse()
DataFrame accessor for sparse data.257-2、参数
无
257-3、功能
将一个DataFrame对象转换为稀疏数据框，这在处理大规模数据且数据包含大量零值时非常有用。
257-4、返回值
一个稀疏数据框(SparseDataFrame)对象，它是pandas中用于存储稀疏数据的主要数据结构。
257-5、说明
无
257-6、用法
257-6-1、数据准备
无257-6-2、代码示例
# 257、pandas.DataFrame.sparse方法
# 257-1、基本用法
import pandas as pd
df = pd.DataFrame({"a": [1, 2, 0, 0],
"b": [3, 0, 0, 4]}, dtype="Sparse[int]")
df1 = df.sparse.density
print(df1, end='\n\n')
# 257-2、机器学习中的稀疏特征矩阵
import pandas as pd
import numpy as np
# 示例数据：用户-商品评分矩阵
data = {
'user_id': [1, 1, 2, 3, 3, 3],
'item_id': [1, 3, 2, 1, 2, 3],
'rating': [5, 3, 4, 2, 5, 1]
}
# 创建DataFrame
df = pd.DataFrame(data)
# 创建透视表（用户-商品矩阵）
pivot_df = df.pivot(index='user_id', columns='item_id', values='rating').fillna(0)
# 转换为稀疏DataFrame
sparse_df = pivot_df.astype(pd.SparseDtype("float", 0))
print("稀疏DataFrame:")
print(sparse_df)
# 查看内存使用情况
print("内存使用情况:")
print(sparse_df.memory_usage(deep=True), end='\n\n')
# 257-3、金融数据分析中的时间序列处理
import pandas as pd
import numpy as np
# 创建日期索引
dates = pd.date_range('2024-01-01', periods=5)
# 示例数据：股票价格时间序列（含缺失值）
data = {
'stock_A': [100, np.nan, 102, np.nan, 105],
'stock_B': [np.nan, 200, np.nan, 202, 203]
}
# 创建DataFrame
df = pd.DataFrame(data, index=dates)
# 转换为稀疏DataFrame
sparse_df = df.astype(pd.SparseDtype("float", np.nan))
print("稀疏DataFrame:")
print(sparse_df)
# 查看内存使用情况
print("内存使用情况:")
print(sparse_df.memory_usage(deep=True), end='\n\n')
# 257-4、高维数据分析中的稀疏矩阵
import pandas as pd
from scipy.sparse import random
# 创建一个稀疏矩阵（例如，1000个样本，100个特征，稀疏度为95%）
rows = 1000
cols = 100
density = 0.05
sparse_matrix = random(rows, cols, density=density, format='csr')
# 转换为DataFrame
df = pd.DataFrame.sparse.from_spmatrix(sparse_matrix)
print("稀疏DataFrame:")
print(df)
# 查看内存使用情况
print("内存使用情况:")
print(df.memory_usage(deep=True))257-6-3、结果输出
# 257、pandas.DataFrame.sparse方法
# 257-1、基本用法
# 0.5
# 257-2、机器学习中的稀疏特征矩阵
# 稀疏DataFrame:
# item_id 1 2 3
# user_id
# 1 5.0 0 3.0
# 2 0 4.0 0
# 3 2.0 5.0 1.0
# 内存使用情况:
# Index 24
# 1 24
# 2 24
# 3 24
# dtype: int64
# 257-3、金融数据分析中的时间序列处理
# 稀疏DataFrame:
# stock_A stock_B
# 2024-01-01 100.0 NaN
# 2024-01-02 NaN 200.0
# 2024-01-03 102.0 NaN
# 2024-01-04 NaN 202.0
# 2024-01-05 105.0 203.0
# 内存使用情况:
# Index 40
# stock_A 36
# stock_B 36
# dtype: int64
# 257-4、高维数据分析中的稀疏矩阵
# 稀疏DataFrame:
# 0 1 2 3 4 ... 95 96 97 98 99
# 0 0 0 0 0 0 ... 0 0 0 0 0
# 1 0 0 0 0 0 ... 0.399786 0 0 0 0
# 2 0 0 0 0 0 ... 0 0 0 0 0
# 3 0 0 0 0 0 ... 0 0 0 0 0
# 4 0 0 0 0 0 ... 0 0 0 0 0
# .. ... .. ... .. .. ... ... .. ... ... ...
# 995 0 0 0 0 0 ... 0 0 0 0 0.269866
# 996 0 0 0.930464 0 0 ... 0 0 0 0 0
# 997 0 0 0 0 0 ... 0 0 0 0 0
# 998 0 0 0 0 0 ... 0 0 0.73455 0.815879 0
# 999 0.605492 0 0 0 0 ... 0 0 0 0 0
#
# [1000 rows x 100 columns]
# 内存使用情况:
# Index 132
# 0 516
# 1 672
# 2 576
# 3 660
# ...
# 95 576
# 96 540
# 97 636
# 98 732
# 99 540
# Length: 101, dtype: int64258、pandas.Series.dt.date属性
258-1、语法
# 258、pandas.Series.dt.date属性
pandas.Series.dt.date
Returns numpy array of python datetime.date objects.
Namely, the date part of Timestamps without time and timezone information.258-2、参数
无
258-3、功能
用于获取Series中的日期时间数据的日期部分。
258-4、返回值
返回一个包含日期的Series对象。
258-5、说明
258-5-1、Series.dt.date只能应用于包含日期时间数据的Series，如果尝试在其他类型的数据上使用该属性，会引发错误。
258-5-2、返回的Series对象中的日期部分为datetime.date类型，而不是datetime.datetime类型。
258-6、用法
258-6-1、数据准备
无258-6-2、代码示例
# 258、pandas.Series.dt.date属性
# 258-1、基本用法
import pandas as pd
# 创建包含日期时间数据的Series
date_series = pd.Series(pd.to_datetime(['2022-01-01 12:00:00', '2023-01-02 14:30:00', '2024-01-03 09:15:00']))
# 使用dt.date获取日期部分
date_only_series = date_series.dt.date
print(date_only_series, end='\n\n')
# 258-2、数据清洗和预处理
import pandas as pd
# 创建示例DataFrame
data = {
'transaction_id': [1, 2, 3, 4],
'transaction_datetime': ['2024-01-01 12:00:00', '2024-01-01 14:30:00', '2024-01-02 09:15:00', '2024-01-02 18:45:00']
}
df = pd.DataFrame(data)
df['transaction_datetime'] = pd.to_datetime(df['transaction_datetime'])
# 使用dt.date获取日期部分
df['transaction_date'] = df['transaction_datetime'].dt.date
print(df, end='\n\n')
# 258-3、时间序列分析
import pandas as pd
# 创建示例DataFrame
data = {
'transaction_id': [1, 2, 3, 4],
'transaction_datetime': ['2024-01-01 12:00:00', '2024-01-01 14:30:00', '2024-01-02 09:15:00', '2024-01-02 18:45:00'],
'amount': [100, 200, 150, 300]
}
df = pd.DataFrame(data)
df['transaction_datetime'] = pd.to_datetime(df['transaction_datetime'])
# 使用dt.date获取日期部分
df['transaction_date'] = df['transaction_datetime'].dt.date
# 计算每一天的交易总额
daily_totals = df.groupby('transaction_date')['amount'].sum()
print(daily_totals, end='\n\n')
# 258-4、数据可视化
import pandas as pd
import matplotlib.pyplot as plt
# 创建示例DataFrame
data = {
'transaction_id': [1, 2, 3, 4],
'transaction_datetime': ['2024-01-01 12:00:00', '2024-01-01 14:30:00', '2024-01-02 09:15:00', '2024-01-02 18:45:00'],
'amount': [100, 200, 150, 300]
}
df = pd.DataFrame(data)
df['transaction_datetime'] = pd.to_datetime(df['transaction_datetime'])
# 使用dt.date获取日期部分
df['transaction_date'] = df['transaction_datetime'].dt.date
# 计算每一天的交易总额
daily_totals = df.groupby('transaction_date')['amount'].sum()
# 绘制趋势图
daily_totals.plot(kind='line')
plt.xlabel('Date')
plt.ylabel('Total Amount')
plt.title('Daily Sales Trend')
plt.show()
# 258-5、数据合并与对齐
import pandas as pd
# 创建交易数据DataFrame
transaction_data = {
'transaction_id': [1, 2, 3, 4],
'transaction_datetime': ['2024-01-01 12:00:00', '2024-01-01 14:30:00', '2024-01-02 09:15:00', '2024-01-02 18:45:00'],
'amount': [100, 200, 150, 300]
}
transaction_df = pd.DataFrame(transaction_data)
transaction_df['transaction_datetime'] = pd.to_datetime(transaction_df['transaction_datetime'])
transaction_df['transaction_date'] = transaction_df['transaction_datetime'].dt.date
# 创建库存数据DataFrame
inventory_data = {
'inventory_date': ['2024-01-01', '2024-01-02'],
'stock': [500, 400]
}
inventory_df = pd.DataFrame(inventory_data)
inventory_df['inventory_date'] = pd.to_datetime(inventory_df['inventory_date']).dt.date
# 按日期合并数据
merged_df = pd.merge(transaction_df, inventory_df, left_on='transaction_date', right_on='inventory_date')
print(merged_df)258-6-3、结果输出
# 258、pandas.Series.dt.date属性
# 258-1、基本用法
# 0 2022-01-01
# 1 2023-01-02
# 2 2024-01-03
# dtype: object
# 258-2、数据清洗和预处理
# transaction_id transaction_datetime transaction_date
# 0 1 2024-01-01 12:00:00 2024-01-01
# 1 2 2024-01-01 14:30:00 2024-01-01
# 2 3 2024-01-02 09:15:00 2024-01-02
# 3 4 2024-01-02 18:45:00 2024-01-02
# 258-3、时间序列分析
# transaction_date
# 2024-01-01 300
# 2024-01-02 450
# Name: amount, dtype: int64
# 258-4、数据可视化
# 见图1
# 258-5、数据合并与对齐
# transaction_id transaction_datetime ... inventory_date stock
# 0 1 2024-01-01 12:00:00 ... 2024-01-01 500
# 1 2 2024-01-01 14:30:00 ... 2024-01-01 500
# 2 3 2024-01-02 09:15:00 ... 2024-01-02 400
# 3 4 2024-01-02 18:45:00 ... 2024-01-02 400
#
# [4 rows x 6 columns]图1：
259、pandas.Series.dt.time属性
259-1、语法
# 259、pandas.Series.dt.time属性
pandas.Series.dt.time
Returns numpy array of datetime.time objects.
The time part of the Timestamps.259-2、参数
无
259-3、功能
用于从包含日期时间数据的Series中提取时间部分。
259-4、返回值
返回一个新的Series，其中包含每个元素的时间部分，以datetime.time对象的形式表示，这意味着提取出来的时间部分包括时、分、秒，而不包括日期信息。
259-5、说明
使用场景：
259-5-1、时间分析：如果你需要分析一天中的时间模式，例如确定一组活动发生在一天的哪个时段，dt.time可以将时间从日期中分离出来，便于进一步分析。
259-5-2、时间区间分类：在数据中，根据时间进行分类时，比如将时间分为“早晨”、“下午”和“晚上”，可以使用dt.time提取时间部分，然后应用分类规则。
259-5-3、时间比较：比如你想比较不同记录的时间是否在特定时间段内(如检查订单是否在工作时间内)，dt.time提供了一种简单的方法来实现。
259-5-4、生成时间特征：在机器学习中，有时你需要将时间作为特征进行建模，dt.time可以帮助你生成用于训练模型的时间特征。
259-5-5、过滤数据：如果你需要从数据集中提取某个时间段的数据，例如过滤出只包含“上午9点到11点”的记录，可以先提取时间部分，然后应用条件筛选。
259-6、用法
259-6-1、数据准备
无259-6-2、代码示例
# 259、pandas.Series.dt.time属性
# 259-1、时间分析
import pandas as pd
# 创建一个包含日期时间的Series
data = pd.Series(pd.to_datetime([
'2024-08-04 08:30:00',
'2024-08-04 13:15:00',
'2024-08-04 19:45:00'
]))
# 提取时间部分
times = data.dt.time
print(times, end='\n\n')
# 259-2、时间区间分类
import pandas as pd
# 创建一个包含日期时间的Series
data = pd.Series(pd.to_datetime([
'2024-08-04 08:30:00',
'2024-08-04 13:15:00',
'2024-08-04 19:45:00'
]))
# 提取时间部分
times = data.dt.time
# 分类规则函数
def categorize_time(t):
if t < pd.to_datetime('12:00:00').time():
return '早晨'
elif t < pd.to_datetime('18:00:00').time():
return '下午'
else:
return '晚上'
# 应用分类规则
categories = times.apply(categorize_time)
print(categories, end='\n\n')
# 259-3、时间比较
import pandas as pd
# 创建一个包含订单时间的Series
order_times = pd.Series(pd.to_datetime([
'2024-08-04 09:30:00',
'2024-08-04 15:00:00',
'2024-08-04 20:00:00'
]))
# 提取时间部分
times = order_times.dt.time
# 定义工作时间区间
start_time = pd.to_datetime('09:00:00').time()
end_time = pd.to_datetime('18:00:00').time()
# 检查时间是否在工作时间内
in_working_hours = times.apply(lambda t: start_time <= t <= end_time)
print(in_working_hours, end='\n\n')
# 259-4、生成时间特征
import pandas as pd
# 创建一个包含日期时间的Series
data = pd.Series(pd.to_datetime([
'2024-08-04 08:30:00',
'2024-08-04 13:15:00',
'2024-08-04 19:45:00'
]))
# 提取时间部分并转换为秒数特征
times = data.dt.time
time_features = pd.Series([(t.hour * 3600 + t.minute * 60 + t.second) for t in times])
print(time_features, end='\n\n')
# 259-5、过滤数据
import pandas as pd
# 创建一个包含日期时间的 Series
data = pd.Series(pd.to_datetime([
'2024-08-04 08:30:00',
'2024-08-04 09:45:00',
'2024-08-04 10:30:00',
'2024-08-04 11:15:00',
'2024-08-04 12:00:00'
]))
# 提取时间部分
times = data.dt.time
# 定义时间段
start_time = pd.to_datetime('09:00:00').time()
end_time = pd.to_datetime('11:00:00').time()
# 过滤时间段内的数据
filtered_data = data[times.apply(lambda t: start_time <= t <= end_time)]
print(filtered_data)259-6-3、结果输出
# 259、pandas.Series.dt.time属性
# 259-1、时间分析
# 0 08:30:00
# 1 13:15:00
# 2 19:45:00
# dtype: object
# 259-2、时间区间分类
# 0 早晨
# 1 下午
# 2 晚上
# dtype: object
# 259-3、时间比较
# 0 True
# 1 True
# 2 False
# dtype: bool
# 259-4、生成时间特征
# 0 30600
# 1 47700
# 2 71100
# dtype: int64
# 259-5、过滤数据
# 1 2024-08-04 09:45:00
# 2 2024-08-04 10:30:00
# dtype: datetime64[ns]260、pandas.Series.dt.timetz属性
260-1、语法
# 260、pandas.Series.dt.timetz属性
pandas.Series.dt.timetz
Returns numpy array of datetime.time objects with timezones.
The time part of the Timestamps.260-2、参数
无
260-3、功能
允许你从datetime类型的Series中提取时间部分，并保留时区信息，这意味着你可以获取带有时区的时间部分，而忽略日期部分。
260-4、返回值
返回的是一个DatetimeIndex对象，其中每个时间部分都是一个datetime.time对象，带有时区信息。
260-5、说明
使用场景：
260-5-1、时区敏感的时间数据提取：当你需要从带有时区的日期时间数据中提取时间部分，并保持时区信息时，timetz属性非常有用。例如，在全球业务中，你可能需要在不同的时区之间进行时间比较或调度任务。
260-5-2、时间格式化与展示：提取时间部分并保留时区信息后，可以用于格式化和展示。例如，在用户界面上显示带有时区的时间，以确保用户看到的是他们所在时区的时间。
260-5-3、时间区间检查：用于检查某一时间是否在特定的工作时间区间内。例如，分析订单是否在工作时间内，或者根据时间数据筛选符合条件的记录。
260-5-4、时区转换后的时间提取：将时间数据从一个时区转换到另一个时区，并提取带时区的时间部分，这对于需要对全球用户的活动进行分析的应用场景非常有帮助。
260-5-5、时间与日期分离：有时你可能只对时间部分感兴趣，而日期部分无关紧要，timetz允许你从日期时间中提取时间部分，而忽略日期信息，便于进行进一步的分析或处理。
260-6、用法
260-6-1、数据准备
无260-6-2、代码示例
# 260、pandas.Series.dt.timetz属性
# 260-1、检查用户活动时间是否在工作时间内
import pandas as pd
# 创建一个包含用户活动时间的Series
activity_times = pd.Series(pd.to_datetime([
'2024-08-04 10:30:00',
'2024-08-04 15:45:00',
'2024-08-04 22:00:00'
]))
# 设置时区为UTC
activity_times = activity_times.dt.tz_localize('UTC')
# 转换到本地时区（例如 'Asia/Shanghai'）
activity_times_local = activity_times.dt.tz_convert('Asia/Shanghai')
# 提取带时区的时间部分
times_with_tz = activity_times_local.dt.timetz
# 定义工作时间区间
work_start_time = pd.to_datetime('09:00:00').time()
work_end_time = pd.to_datetime('18:00:00').time()
# 检查是否在工作时间内
is_working_hour = times_with_tz.apply(lambda t: work_start_time <= t <= work_end_time)
print(is_working_hour, end='\n\n')
# 260-2、时区转换后的时间提取
import pandas as pd
# 创建一个包含日期时间的Series
dates = pd.Series(pd.to_datetime([
'2024-08-04 06:00:00',
'2024-08-04 12:00:00',
'2024-08-04 18:00:00'
]))
# 设置时区为UTC
dates_utc = dates.dt.tz_localize('UTC')
# 转换到另一个时区（例如 'Europe/Berlin'）
dates_berlin = dates_utc.dt.tz_convert('Europe/Berlin')
# 提取带时区的时间部分
times_with_tz = dates_berlin.dt.timetz
print(times_with_tz, end='\n\n')
# 260-3、时间数据提取与展示
import pandas as pd
# 创建一个包含日期时间的Series
dates = pd.Series(pd.to_datetime([
'2024-08-04 01:00:00',
'2024-08-04 10:00:00',
'2024-08-04 15:00:00'
]))
# 设置时区为UTC
dates_utc = dates.dt.tz_localize('UTC')
# 转换到本地时区（例如 'America/New_York'）
dates_ny = dates_utc.dt.tz_convert('America/New_York')
# 提取带时区的时间部分
times_with_tz = dates_ny.dt.timetz
# 打印结果
print("Times with timezone information:")
print(times_with_tz, end='\n\n')
# 260-4、时间区间检查
import pandas as pd
# 创建一个包含时间数据的Series
times = pd.Series(pd.to_datetime([
'2024-08-04 07:30:00',
'2024-08-04 12:00:00',
'2024-08-04 19:30:00'
]))
# 设置时区为UTC
times_utc = times.dt.tz_localize('UTC')
# 转换到本地时区（例如 'Asia/Tokyo'）
times_tokyo = times_utc.dt.tz_convert('Asia/Tokyo')
# 提取带时区的时间部分
times_with_tz = times_tokyo.dt.timetz
# 定义检查时间区间
check_start_time = pd.to_datetime('10:00:00').time()
check_end_time = pd.to_datetime('18:00:00').time()
# 检查是否在指定时间区间内
is_in_interval = times_with_tz.apply(lambda t: check_start_time <= t <= check_end_time)
print(is_in_interval, end='\n\n')
# 260-5、与指定时间点比较
import pandas as pd
# 创建一个包含日期时间的Series
dates = pd.Series(pd.to_datetime([
'2024-08-04 04:30:00',
'2024-08-04 09:15:00',
'2024-08-04 14:45:00'
]))
# 设置时区为UTC
dates_utc = dates.dt.tz_localize('UTC')
# 转换到本地时区（例如 'Australia/Sydney'）
dates_sydney = dates_utc.dt.tz_convert('Australia/Sydney')
# 提取带时区的时间部分
times_with_tz = dates_sydney.dt.timetz
# 定义参考时间点
reference_time = pd.to_datetime('12:00:00').time()
# 检查时间是否在参考时间点之前
is_before_reference = times_with_tz.apply(lambda t: t < reference_time)
print(is_before_reference, end='\n\n')
# 260-6、计算时间间隔
import pandas as pd
# 创建一个包含日期时间的Series
dates = pd.Series(pd.to_datetime([
'2024-08-04 08:00:00',
'2024-08-04 12:00:00',
'2024-08-04 16:00:00'
]))
# 设置时区为UTC
dates_utc = dates.dt.tz_localize('UTC')
# 转换到本地时区（例如 'America/Los_Angeles'）
dates_la = dates_utc.dt.tz_convert('America/Los_Angeles')
# 提取带时区的时间部分
times_with_tz = dates_la.dt.timetz
# 计算与第一个时间的间隔（按秒计算）
first_time = times_with_tz.iloc[0]
time_intervals = times_with_tz.apply(lambda t: (pd.Timestamp.combine(pd.Timestamp.now().date(), t) - pd.Timestamp.combine(pd.Timestamp.now().date(), first_time)).total_seconds())
print(time_intervals, end='\n\n')
# 260-7、显示时间的小时和分钟
import pandas as pd
# 创建一个包含日期时间的Series
dates = pd.Series(pd.to_datetime([
'2024-08-04 03:30:00',
'2024-08-04 07:45:00',
'2024-08-04 14:15:00'
]))
# 设置时区为UTC
dates_utc = dates.dt.tz_localize('UTC')
# 转换到本地时区（例如 'Asia/Seoul'）
dates_seoul = dates_utc.dt.tz_convert('Asia/Seoul')
# 提取带时区的时间部分
times_with_tz = dates_seoul.dt.timetz
# 显示时间的小时和分钟部分
hours_minutes = times_with_tz.apply(lambda t: f"{t.hour:02}:{t.minute:02}")
print(hours_minutes)260-6-3、结果输出
# 260、pandas.Series.dt.timetz属性
# 260-1、检查用户活动时间是否在工作时间内
# 0 False
# 1 False
# 2 False
# dtype: bool
# 260-2、时区转换后的时间提取
# 0 08:00:00
# 1 14:00:00
# 2 20:00:00
# dtype: object
# 260-3、时间数据提取与展示
# Times with timezone information:
# 0 21:00:00
# 1 06:00:00
# 2 11:00:00
# dtype: object
# 260-4、时间区间检查
# 0 True
# 1 False
# 2 False
# dtype: bool
# 260-5、与指定时间点比较
# 0 False
# 1 False
# 2 True
# dtype: bool
# 260-6、计算时间间隔
# 0 0.0
# 1 14400.0
# 2 28800.0
# dtype: float64
# 260-7、显示时间的小时和分钟
# 0 12:30
# 1 16:45
# 2 23:15
# dtype: object
