Python酷库之旅-第三方库Pandas(065)

于 2024-08-05 07:45:00 发布
阅读量482 收藏 12
点赞数 24
分类专栏： Myelsa的Python酷库之旅 文章标签： python pandas 开发语言 人工智能 标准库及第三方库 excel 学习与成长
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ygb_1024/article/details/140887589
版权

目录

一、用法精讲

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: int64
258、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

二、推荐阅读

1、Python筑基之旅
2、Python函数之旅
3、Python算法之旅
4、Python魔法之旅
5、博客个人主页
神奇夜光杯
关注
  • 24
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
Python酷库之旅-第三方库Pandas(005)
07-05
Pandas_read_excel函数数据准备
python-3.12.1-amd64安装包
01-26
此外，Python的pip工具允许用户方便地安装、升级和管理第三方库，进一步扩展了Python的功能。 总之，"python-3.12.1-amd64.exe"是一个针对64位Windows系统的Python 3.12.1安装程序，包含了运行和开发Python应用所需...
Python酷库之旅-第三方库Pandas(046)
ygb_1024的博客
07-26 1376
第三方库Pandas(046)
Python酷库之旅-第三方库Pandas(059)
ygb_1024的博客
08-02 1746
第三方库Pandas(059)
Python酷库之旅-第三方库Pandas(023)
ygb_1024的博客
07-15 1560
第三方库Pandas(023)
Python酷库之旅-第三方库Pandas(060)
ygb_1024的博客
08-02 1441
第三方库Pandas(060)
Python酷库之旅-第三方库Pandas(062)
ygb_1024的博客
08-03 1735
第三方库Pandas(062)
Python酷库之旅-第三方库Pandas(021)
ygb_1024的博客
07-14 1493
第三方库Pandas(021)
Python酷库之旅-第三方库Pandas(051)
ygb_1024的博客
07-29 883
第三方库Pandas(051)
Python酷库之旅-第三方库Pandas(011)
ygb_1024的博客
07-09 2025
第三方库Pandas(011)
Python酷库之旅-第三方库Pandas(001)
ygb_1024的博客
07-04 2532
第三方库Pandas(001)
Python酷库之旅-第三方库Pandas(009)
ygb_1024的博客
07-08 1600
第三方库Pandas(009)
Python库 | coconut-develop-2.0.0a0.dev23.tar.gz
03-01
你可以使用pip来安装和管理Coconut库，同时，它与其他Python库（如NumPy、Pandas等）无缝协作，这意味着你可以在使用Coconut的同时，充分利用Python丰富的第三方库资源。 Coconut库的源代码打包为`coconut-develop-...
Python库 | seleniumbase-1.38.6-py2.py3-none-any.whl
03-24
7. **集成第三方库**：`seleniumbase`能够与`unittest`、`pytest`等测试框架无缝集成，也可以与其他库如`pandas`和`requests`配合，实现更复杂的测试需求。 8. **可扩展性**：`seleniumbase`设计为模块化，用户可以...
python官方3.8.7-amd64版本exe安装包
08-11
在安装Python后，开发者可以利用丰富的第三方库如NumPy、Pandas、Matplotlib进行数据分析，或者使用Django、Flask框架进行Web开发。Python的生态系统庞大且活跃，不断有新的库和工具涌现，以满足各种需求。 总之，...
【Python】pandas：排序、重复值、缺省值处理、合并、分组
yannan20190313的博客
07-30 1182
【Python】pandas：排序（sort_index,sort_values,nsmallest,nlargest）、重复值（duplicated,drop_duplicates,value_counts,nunique）、缺省值处理（isna,isnull,notna,notnull,fillna,dropna,replace）、合并（join,merge,append,concat）、分组（groupby）
本地部署 Llama-3-EvoVLM-JP-v2
最新发布
engchina的专栏
08-04 295
本地部署 Llama-3-EvoVLM-JP-v2
Selenium与WebDriver：Errno 8 Exec格式错误的多种解决方案
ip16yun的博客
07-30 440
在使用Selenium和WebDriver进行网页自动化时，可能会遇到各种错误。其中一个常见问题是执行格式错误（Errno 8 Exec format error）。这个错误通常在运行ChromeDriver时出现，错误提示涉及路径中的某个文件。本文将概述这个问题的背景，并提供多种解决方案，包括如何使用代理IP技术进行数据抓取。
python字符串数据容器练习（replace,split,count）
2301_79600015的博客
07-31 517
Python字符串是由一系列字符组成的数据类型。在Python中，字符串是不可变的，这意味着一旦创建了一个字符串，就不能修改它的内容。以下是关于Python字符串的一些重要知识点：1. 字符串的基本操作：拼接字符串：使用`+`运算符。重复字符串：使用`*`运算符。索引和切片：使用`[]`和`:`操作符访问字符串中的子串。长度：使用`len()`函数获取字符串长度。转换大小写：使用`upper()`和`lower()`方法。分割和连接：使用`split()`和`join()`方法。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

神奇夜光杯

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值