首页 > 其他分享 >2024-10-25 学习人工智能的Day15 Pandas(2)

2024-10-25 学习人工智能的Day15 Pandas(2)

时间：2024-10-26 11:18:39浏览次数：9  
标签：10 None 25 df index DataFrame 2024 pd print

二、函数

1、常用的统计学函数

函数名称描述说明
count()统计某个非空值的数量
sum()求和
mean()求均值
median()求中位数
std()求标准差
min()求最小值
max()求最大值
abs()求绝对值
prod()求所有数值的乘积

案例：

# 创建一个示例 DataFrame
data = {
    'A': [1, 2, 3, 4, 5],
    'B': [10, 20, 30, 40, 50],
    'C': [100, 200, 300, 400, 500]
}
df = pd.DataFrame(data)

# 计算每列的均值
mean_values = df.mean()
print(mean_values)

# 计算每列的中位数
median_values = df.median()
print(median_values)

#计算每列的方差
var_values = df.var()
print(var_values)

# 计算每列的标准差
std_values = df.std()
print(std_values)

# 计算每列的最小值
min_values = df.min()
print("最小值:")
print(min_values)

# 计算每列的最大值
max_values = df.max()
print("最大值:")
print(max_values)

# 计算每列的总和
sum_values = df.sum()
print(sum_values)

# 计算每列的非空值数量
count_values = df.count()
print(count_values)

注意：numpy的方差默认为总体方差，pandas默认为样本方差

总体方差：
σ 2 = 1 N ∑ i = 1 N ( X i − μ ) 2 σ^2=\dfrac{1}{N}∑_{i=1}^N(X_i−μ)^2 σ2=N1​i=1∑N​(Xi​−μ)2
样本方差：
s 2 = 1 N − 1 ∑ i = 1 N ( X i − X ‾ ) 2 s^2=\dfrac{1}{N-1}∑_{i=1}^N(X_i−\overline X)^2 s2=N−11​i=1∑N​(Xi​−X)2
分母为n-1的样本方差的期望等于总体的方差，因此样本方差是总体方差的无偏估计。

2、重置索引

​ 重置索引（reindex）可以更改原 DataFrame 的行标签或列标签，并使更改后的行、列标签与 DataFrame 中的数据逐一匹配。通过重置索引操作，您可以完成对现有数据的重新排序。如果重置的索引标签在原 DataFrame 中不存在，那么该标签对应的元素值将全部填充为 NaN。

2.1 reindex

reindex() 方法用于重新索引 DataFrame 或 Series 对象。重新索引意味着根据新的索引标签重新排列数据，并填充缺失值。如果重置的索引标签在原 DataFrame 中不存在，那么该标签对应的元素值将全部填充为 NaN。

语法：

DataFrame.reindex(labels=None, index=None, columns=None, axis=None, method=None, copy=True, level=None, fill_value=np.nan, limit=None, tolerance=None)

参数：

  1. labels：
    • 类型：数组或列表，默认为 None。
    • 描述：新的索引标签。
  2. index：
    • 类型：数组或列表，默认为 None。
    • 描述：新的行索引标签。
  3. columns：
    • 类型：数组或列表，默认为 None。
    • 描述：新的列索引标签。
  4. axis：
    • 类型：整数或字符串，默认为 None。
    • 描述：指定重新索引的轴。0 或 ‘index’ 表示行，1 或 ‘columns’ 表示列。
  5. method：
    • 类型：字符串，默认为 None。
    • 描述：用于填充缺失值的方法。可选值包括 ‘ffill’（前向填充）、‘bfill’（后向填充）等。
  6. copy：
    • 类型：布尔值，默认为 True。
    • 描述：是否返回新的 DataFrame 或 Series。
  7. level：
    • 类型：整数或级别名称，默认为 None。
    • 描述：用于多级索引（MultiIndex），指定要重新索引的级别。
  8. fill_value：
    • 类型：标量，默认为 np.nan。
    • 描述：用于填充缺失值的值。
  9. limit：
    • 类型：整数，默认为 None。
    • 描述：指定连续填充的最大数量。
  10. tolerance：
    • 类型：标量或字典，默认为 None。
    • 描述：指定重新索引时的容差。

案例：

# 创建一个示例 DataFrame
data = {
    'A': [1, 2, 3],
    'B': [4, 5, 6],
    'C': [7, 8, 9]
}
df = pd.DataFrame(data, index=['a', 'b', 'c'])

# 重新索引行
new_index = ['a', 'b', 'c', 'd']
df_reindexed = df.reindex(new_index)
print(df_reindexed)

# 重新索引列
new_columns = ['A', 'B', 'C', 'D']
df_reindexed = df.reindex(columns=new_columns)
print(df_reindexed)

# 重新索引行，并使用前向填充
# 新的行索引 ['a', 'b', 'c', 'd'] 包含了原索引中不存在的标签 'd'，使用 method='ffill' 进行前向填充，因此 'd' 对应的行填充了前一行的值。
new_index = ['a', 'b', 'c', 'd']
df_reindexed = df.reindex(new_index, method='ffill')
print(df_reindexed)

# 重新索引行，并使用指定的值填充缺失值
new_index = ['a', 'b', 'c', 'd']
df_reindexed = df.reindex(new_index, fill_value=0)
print(df_reindexed)

2.2 reindex_like

reindex_like 方法用于将一个 DataFrame 或 Series 的索引重新排列，使其与另一个 DataFrame 或 Series 的索引相匹配。如果在重新索引的过程中，新的索引与原始索引不完全匹配，那么不匹配的位置将会被填充为 NaN 值。

语法：

DataFrame.reindex_like(other, method=None, copy=True, limit=None, tolerance=None)

参数：

  1. other：
    • 类型：DataFrame 或 Series。
    • 描述：用于对齐索引和列的参考对象。
  2. method：
    • 类型：字符串，默认为 None。
    • 描述：用于填充缺失值的方法。可选值包括 ‘ffill’（前向填充）、‘bfill’（后向填充）等。
  3. copy：
    • 类型：布尔值，默认为 True。
    • 描述：是否返回新的 DataFrame 或 Series。
  4. limit：
    • 类型：整数，默认为 None。
    • 描述：指定连续填充的最大数量。
  5. tolerance：
    • 类型：标量或字典，默认为 None。
    • 描述：指定重新索引时的容差。

**案例1：**对齐行索引

import pandas as pd

# 创建两个示例 DataFrame
df1 = pd.DataFrame({
    'A': [1, 2, 3],
    'B': [4, 5, 6]
}, index=['a', 'b', 'c'])

df2 = pd.DataFrame({
    'A': [7, 8, 9],
    'B': [10, 11, 12]
}, index=['b', 'c', 'd'])

# 使用 reindex_like 对齐 df1 的行索引到 df2
# df1 的行索引被重新索引为 df2 的行索引，因此 df1 中不存在的行索引 'd' 对应的行填充了 NaN。
df1_reindexed = df1.reindex_like(df2)
print(df1_reindexed)

案例2：对齐列索引

# 创建两个示例 DataFrame
df1 = pd.DataFrame({
    'A': [1, 2, 3],
    'B': [4, 5, 6]
}, index=['a', 'b', 'c'])

df2 = pd.DataFrame({
    'B': [7, 8, 9],
    'C': [10, 11, 12]
}, index=['a', 'b', 'c'])

# 使用 reindex_like 对齐 df1 的列索引到 df2
df1_reindexed = df1.reindex_like(df2)

print(df1_reindexed)

3、遍历

对于 Series 而言，您可以把它当做一维数组进行遍历操作；而像 DataFrame 这种二维数据表结构，则类似于遍历 Python 字典

Series 可直接获取相应的 value，而 DataFrame 则会获取列标签

案例：

import pandas as pd

series_data = pd.Series(['a','b','c','d','e','f',None])

print('Series：')
for item in series_data:
    print(item, end=' ')

3.1 Series遍历

使用 items()

import pandas as pd

# 创建一个示例 Series
series = pd.Series([1, 2, 3], index=['a', 'b', 'c'])
for index, value in series.items():
    print(f"Index: {index}, Value: {value}")

使用 index 属性

import pandas as pd

# 创建一个示例 Series
series = pd.Series([1, 2, 3], index=['a', 'b', 'c'])

# 遍历索引
for index in series.index:
    print(f"Index: {index}, Value: {series[index]}")

使用 values 属性

import pandas as pd

# 创建一个示例 Series
series = pd.Series([1, 2, 3], index=['a', 'b', 'c'])

# 遍历值
for value in series.values:
    print(f"Value: {value}")

3.2 DataFrame 遍历

dataFrame_data = pd.DataFrame({
    'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']),
    'two': pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])
})
# 遍历dataframe得到的是列标签
print('DataFrame：')
for item in dataFrame_data:
    print(item, end=' ')

迭代器返回的是原数据的副本

遍历行

iterrows() 方法用于遍历 DataFrame 的行，返回一个包含索引和行的迭代器。

案例：

import pandas as pd

# 创建一个示例 DataFrame
data = {
    'A': [1, 2, 3],
    'B': [4, 5, 6],
    'C': [7, 8, 9]
}
df = pd.DataFrame(data, index=['a', 'b', 'c'])

# 使用 iterrows() 遍历行
for index, row in df.iterrows():
    print(f"Index: {index}, Row: {row}")

itertuples() 方法用于遍历 DataFrame 的行，返回一个包含行数据的命名元组。

案例：

import pandas as pd

# 创建一个示例 DataFrame
data = {
    'A': [1, 2, 3],
    'B': [4, 5, 6],
    'C': [7, 8, 9]
}
df = pd.DataFrame(data, index=['a', 'b', 'c'])

# 使用 itertuples() 遍历行
for row in df.itertuples():
    print(row)
    # 获取列名
    columns = row._fields
    
    # 遍历每一行的元素值
    for col in columns:
        # getattr:获取row对象中的col属性
        print(f"{col}: {getattr(row, col)}")

当处理大型数据集时，应尽量避免使用 iterrows()，因为它的性能相对较差。

itertuples() 是遍历 DataFrame 的推荐方法，因为它在速度和内存使用上都更高效。

遍历列

items() 方法用于遍历 DataFrame 的列，返回一个包含列名和列数据的迭代器。

案例：

import pandas as pd

# 创建一个示例 DataFrame
data = {
    'A': [1, 2, 3],
    'B': [4, 5, 6],
    'C': [7, 8, 9]
}
df = pd.DataFrame(data, index=['a', 'b', 'c'])

# 使用 items() 遍历列
for column_name, column_data in df.items():
    print(f"Column Name: {column_name}, Column Data: {column_data}")

使用属性遍历

loc 和 iloc 方法可以用于按索引或位置遍历 DataFrame 的行和列。

import pandas as pd

# 创建一个示例 DataFrame
data = {
    'A': [1, 2, 3],
    'B': [4, 5, 6],
    'C': [7, 8, 9]
}
df = pd.DataFrame(data, index=['a', 'b', 'c'])

# 使用 loc 遍历行和列
for index in df.index:
    for column in df.columns:
        print(f"Index: {index}, Column: {column}, Value: {df.loc[index, column]}")

4、排序

4.1 sort_index

sort_index 方法用于对 DataFrame 或 Series 的索引进行排序。

语法：

DataFrame.sort_index(axis=0, ascending=True, inplace=False)
Series.sort_index(axis=0, ascending=True, inplace=False)

参数：

  • axis：指定要排序的轴。默认为 0，表示按行索引排序。如果设置为 1，将按列索引排序。
  • ascending：布尔值，指定是升序排序（True）还是降序排序（False）。
  • inplace：布尔值，指定是否在原地修改数据。如果为 True，则会修改原始数据；如果为 False，则返回一个新的排序后的对象。

案例：

import pandas as pd

# 创建一个示例 DataFrame
data = {
    'A': [1, 2, 3],
    'B': [4, 5, 6],
    'C': [7, 8, 9]
}
df = pd.DataFrame(data, index=['b', 'c', 'a'])

# 按行索引排序
df_sorted = df.sort_index()

print(df_sorted)

4.2 sort_values

sort_values 方法用于根据一个或多个列的值对 DataFrame 进行排序。

语法：

DataFrame.sort_values(by, axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last')

参数：

  • by：列的标签或列的标签列表。指定要排序的列。
  • axis：指定沿着哪个轴排序。默认为 0，表示按列排序。如果设置为 1，将按行排序。
  • ascending：布尔值或布尔值列表，指定是升序排序（True）还是降序排序（False）。可以为每个列指定不同的排序方向。
  • inplace：布尔值，指定是否在原地修改数据。如果为 True，则会修改原始数据；如果为 False，则返回一个新的排序后的对象。
  • kind：排序算法。默认为 ‘quicksort’，也可以选择 ‘mergesort’ 或 ‘heapsort’。
  • na_position：指定缺失值（NaN）的位置。可以是 ‘first’ 或 ‘last’。

案例：

import pandas as pd

# 创建一个示例 DataFrame
data = {
    'A': [3, 2, 1],
    'B': [6, 5, 4],
    'C': [9, 8, 7]
}
df = pd.DataFrame(data, index=['b', 'c', 'a'])

# 按列 'A' 排序
df_sorted = df.sort_values(by='A')
print(df_sorted)

# 按列 'A' 和 'B' 排序
df_sorted = df.sort_values(by=['A', 'B'])
print(df_sorted)

# 按列 'A' 降序排序
df_sorted = df.sort_values(by='A', ascending=False)
print(df_sorted)

5、去重

drop_duplicates 方法用于删除 DataFrame 或 Series 中的重复行或元素。

语法：

drop_duplicates(by=None, subset=None, keep='first', inplace=False)
Series.drop_duplicates(keep='first', inplace=False)

参数：

  • by：用于标识重复项的列名或列名列表。如果未指定，则使用所有列。

  • subset：与 by 类似，但用于指定列的子集。

  • keep：指定如何处理重复项。可以是：

    • ‘first’：保留第一个出现的重复项（默认值）。
    • ‘last’：保留最后一个出现的重复项。
    • False：删除所有重复项。

  • inplace：布尔值，指定是否在原地修改数据。如果为 True，则会修改原始数据；如果为 False，则返回一个新的删除重复项后的对象。

案例：

import pandas as pd

# 创建一个示例 DataFrame
data = {
    'A': [1, 2, 2, 3],
    'B': [4, 5, 5, 6],
    'C': [7, 8, 8, 9]
}
df = pd.DataFrame(data)

# 删除所有列的重复行，默认保留第一个出现的重复项
df_unique = df.drop_duplicates()
print(df_unique)

# 删除重复行，保留最后一个出现的重复项
df_unique = df.drop_duplicates(keep='last')
print(df_unique)

6、分组

6.1 groupby

groupby 方法用于对数据进行分组操作，这是数据分析中非常常见的一个步骤。通过 groupby，你可以将数据集按照某个列（或多个列）的值分组，然后对每个组应用聚合函数，比如求和、平均值、最大值等。

语法：

DataFrame.groupby(by, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=False, observed=False, **kwargs)

参数：

  • by：用于分组的列名或列名列表。
  • axis：指定沿着哪个轴进行分组。默认为 0，表示按行分组。
  • level：用于分组的 MultiIndex 的级别。
  • as_index：布尔值，指定分组后索引是否保留。如果为 True，则分组列将成为结果的索引；如果为 False，则返回一个列包含分组信息的 DataFrame。
  • sort：布尔值，指定在分组操作中是否对数据进行排序。默认为 True。
  • group_keys：布尔值，指定是否在结果中添加组键。
  • squeeze：布尔值，如果为 True，并且分组结果返回一个元素，则返回该元素而不是单列 DataFrame。
  • observed：布尔值，如果为 True，则只考虑数据中出现的标签。
import pandas as pd

# 创建一个示例 DataFrame
    data = {
        'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'],
        'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],
        'C': [1, 2, 3, 4, 5, 6, 7, 8],
        'D': [10, 20, 30, 40, 50, 60, 70, 80]
    }
    df = pd.DataFrame(data)

    # 按列 'A' 分组
    grouped = df.groupby('A')

    # 查看分组结果
    for name, group in grouped:
        print(f"Group: {name}")
        print(group)
        print()

    # 在分组内根据C列求平均值
    # transform用于在分组操作中对每个组内的数据进行转换，并将结果合并回原始 DataFrame。
    mean = grouped['C'].transform(lambda x: x.mean())
    df['C_mean'] = mean
    print(df)

    # 在分组内根据C列求标准差
    std = grouped['C'].transform(np.std)
    df['C_std'] = std
    print(df)

    # 在分组内根据C列进行正太分布标准化
    norm = grouped['C'].transform(lambda x: (x - x.mean()) / x.std())
    df['C_normal'] = norm
    print(df)

6.2 filter

​ 通过 filter() 函数可以实现数据的筛选，该函数根据定义的条件过滤数据并返回一个新的数据集

import pandas as pd

# 创建一个示例 DataFrame
    data = {
        'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'],
        'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],
        'C': [1, 2, 3, 4, 5, 6, 7, 8],
        'D': [10, 20, 30, 40, 50, 60, 70, 80]
    }
    df = pd.DataFrame(data)

# 按列 'A' 分组，并过滤掉列 'C' 的平均值小于 4 的组
filtered = df.groupby('A').filter(lambda x: x['C'].mean() >= 4)

print(filtered)

7、合并

merge 函数用于将两个 DataFrame 对象根据一个或多个键进行合并，类似于 SQL 中的 JOIN 操作。这个方法非常适合用来基于某些共同字段将不同数据源的数据组合在一起，最后拼接成一个新的 DataFrame 数据表。

函数：

pandas.merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=True, indicator=False, validate=None)

参数：

  • left：左侧的 DataFrame 对象。

  • right：右侧的 DataFrame 对象。

  • how

    ：合并方式，可以是 ‘inner’、‘outer’、‘left’ 或 ‘right’。默认为 ‘inner’。

    • ‘inner’：内连接，返回两个 DataFrame 共有的键。
    • ‘outer’：外连接，返回两个 DataFrame 的所有键。
    • ‘left’：左连接，返回左侧 DataFrame 的所有键，以及右侧 DataFrame 匹配的键。
    • ‘right’：右连接，返回右侧 DataFrame 的所有键，以及左侧 DataFrame 匹配的键。

  • on：用于连接的列名。如果未指定，则使用两个 DataFrame 中相同的列名。

  • left_on 和 right_on：分别指定左侧和右侧 DataFrame 的连接列名。

  • left_index 和 right_index：布尔值，指定是否使用索引作为连接键。

  • sort：布尔值，指定是否在合并后对结果进行排序。

  • suffixes：一个元组，指定当列名冲突时，右侧和左侧 DataFrame 的后缀。

  • copy：布尔值，指定是否返回一个新的 DataFrame。如果为 False，则可能修改原始 DataFrame。

  • indicator：布尔值，如果为 True，则在结果中添加一个名为 __merge 的列，指示每行是如何合并的。

  • validate：验证合并是否符合特定的模式。

案例1：内连接

import pandas as pd

# 创建两个示例 DataFrame
left = pd.DataFrame({
    'key': ['K0', 'K1', 'K2', 'K3'],
    'A': ['A0', 'A1', 'A2', 'A3'],
    'B': ['B0', 'B1', 'B2', 'B3']
})

right = pd.DataFrame({
    'key': ['K0', 'K1', 'K2', 'K4'],
    'C': ['C0', 'C1', 'C2', 'C3'],
    'D': ['D0', 'D1', 'D2', 'D3']
})

# 内连接
result = pd.merge(left, right, on='key')

print(result)

案例2：左连接

import pandas as pd

# 创建两个示例 DataFrame
left = pd.DataFrame({
    'key': ['K0', 'K1', 'K2', 'K3'],
    'A': ['A0', 'A1', 'A2', 'A3'],
    'B': ['B0', 'B1', 'B2', 'B3']
})

right = pd.DataFrame({
    'key': ['K0', 'K1', 'K2', 'K4'],
    'C': ['C0', 'C1', 'C2', 'C3'],
    'D': ['D0', 'D1', 'D2', 'D3']
})

# 左连接
result = pd.merge(left, right, on='key', how='left')

print(result)

8、时间

8.1 datetime

datetime 模块提供了用于处理日期和时间的类。

from datetime import datetime

dt = datetime(2024, 5, 19, 16, 45, 30)
print(dt)
print(dt.date())  # 输出: 2024-05-19
print(dt.time())  # 输出: 16:45:00

8.2 Timestamp

Timestamp 是一个特殊的 datetime 类型，用于表示单个时间点。它是 pandas 时间序列功能的核心组件，提供了丰富的方法和属性来处理日期和时间数据。

import pandas as pd

# 从日期字符串创建
ts = pd.Timestamp('2024-05-19 16:45:00')
print(ts)

# 从时间戳创建
ts = pd.Timestamp(1652937700)  # Unix 时间戳
print(ts)

8.3 日期解析

pd.to_datetime() 方法用于将字符串或其他格式的日期转换为 Pandas 的 Datetime 对象。

案例：

import pandas as pd

# 将字符串转换为 Datetime 对象
date_str = '2023-10-01'
date_obj = pd.to_datetime(date_str)
print(date_obj)

# 获取当前时间
print('当前时间：')
print(datetime.now())

8.4 date_range

date_range() 函数用于生成一个固定频率的日期时间索引（DatetimeIndex）。这个函数非常灵活，可以用于生成各种时间序列数据。

语法：

pandas.date_range(start=None, end=None, periods=None, freq=None, tz=None, normalize=False, name=None, closed=None, **kwargs)

参数：

  1. start：
    • 类型：字符串或日期时间对象，默认为 None。
    • 描述：起始日期时间。
  2. end：
    • 类型：字符串或日期时间对象，默认为 None。
    • 描述：结束日期时间。
  3. periods：
    • 类型：整数，默认为 None。
    • 描述：生成的日期时间索引的数量。
  4. freq：
    • 类型：字符串或日期偏移对象，默认为 None。
    • 描述：时间频率。常见的频率包括 ‘D’（天）、‘H’（小时）、‘T’ 或 ‘min’（分钟）、‘S’（秒）等。
  5. tz：
    • 类型：字符串或时区对象，默认为 None。
    • 描述：指定时区。
  6. normalize：
    • 类型：布尔值，默认为 False。
    • 描述：是否将时间归一化到午夜。
  7. name：
    • 类型：字符串，默认为 None。
    • 描述：生成的日期时间索引的名称。
  8. closed：
    • 类型：字符串，默认为 None。
    • 描述：指定区间是否包含起始或结束日期时间。可选值为 ‘left’、‘right’ 或 None。

案例：

import pandas as pd

# 生成从 2023-01-01 到 2023-01-10 的每日日期时间索引
date_index = pd.date_range(start='2023-01-01', end='2023-01-10', freq='D')
print(date_index)

# 生成从 2023-01-01 00:00:00 到 2023-01-01 23:00:00 的每小时日期时间索引
date_index = pd.date_range(start='2023-01-01', periods=24, freq='H')
print(date_index)

8.5 时间差

Timedelta 是一个用于表示时间间隔的对象。它可以表示两个时间点之间的差异，或者表示某个时间段的长度。Timedelta 对象可以用于时间序列分析、日期运算等场景。

创建 Timedelta

1.使用字符串表示

import pandas as pd

td1 = pd.Timedelta('1 days 2 hours 30 minutes')
print(td1)  # 输出: 1 days 02:30:00

2.使用参数

td2 = pd.Timedelta(days=1, hours=2, minutes=30)
print(td2)  # 输出: 1 days 02:30:00

3.使用整数和单位

td3 = pd.Timedelta(5, unit='days')  # 5天
print(td3)  # 输出: 5 days 00:00:00

4.时间差加减

import pandas as pd

td1 = pd.Timedelta('1 days 2 hours 30 minutes')
print(td1)  # 输出: 1 days 02:30:00

ts = pd.Timestamp('2024-01-01')
new_ts = ts + td1
print(new_ts)  # 输出: 2024-01-02 02:30:00

8.6 时间日期格式化

strftime 用于将日期时间对象转换为指定格式的字符串，而 strptime 用于将字符串解析为日期时间对象。

from datetime import datetime

# 创建一个日期时间对象
date_obj = datetime(2023, 10, 1, 14, 30, 45)

# 将日期时间对象转换为字符串
date_str = date_obj.strftime("%Y-%m-%d %H:%M:%S")

print(f"Formatted date string: {date_str}")

# 将字符串解析为日期时间对象
parsed_date_obj = datetime.strptime(date_str, "%Y-%m-%d %H:%M:%S")

print(f"Parsed datetime object: {parsed_date_obj}")

时间日期符号：
符号 说明
%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（0000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00=59）
%S 秒（00-59）
%a 本地英文缩写星期名称
%A 本地英文完整星期名称
%b 本地缩写英文的月份名称
%B 本地完整英文的月份名称
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%U 一年中的星期数（00-53）星期天为星期的开始
%j 年内的一天（001-366）
%c 本地相应的日期表示和时间表示

标签：10,None,25,df,index,DataFrame,2024,pd,print
From： https://blog.csdn.net/ctrey_/article/details/143239428

相关文章

  • 解决Mysql:ERROR 1045 (28000):Access denied for user ‘root‘@‘localhost‘ (usin
    遇到 ERROR1045(28000):Accessdeniedforuser'root'@'localhost'(usingpassword:NO) 错误时，通常是因为尝试以root用户身份登录MySQL时没有提供密码或提供的密码不正确。以下是解决此问题的步骤：检查是否设置了密码：如果从未为root用户设置过密码，可以尝试在命......
  • 鲜花-CSP2024 游记
    前言坐标\(\text{SX}\)，去年\(\text{CSP}\)和\(\text{NOIP}\)都爆炸了，于是这就是我最后一年了。初赛赛前随便做了三份题，可以随便过线就放下不管了。赛时光速写完选择，然后被状压题硬控，没太看懂在求什么，有点慌乱，后面的完善程序二分题很快写上去了，但是\(K\)短路完全没学过，......
  • 2024年工作笔记
    CMake相关CMake从基础到高级技巧#根据操作系统类型安装不同的文件if(CMAKE_SYSTEM_NAMESTREQUAL"Linux")install(FILES"linux_specific_file.conf"DESTINATIONetc)elseif(CMAKE_SYSTEM_NAMESTREQUAL"Windows")install(FILES"windows_speci......
  • springboot医疗物品采购系统-计算机设计毕业源码10210
    摘 要本文基于SpringBoot框架，设计并实现了一个医疗物品采购系统。该系统旨在解决医疗物品采购中的管理和信息化问题，提供便捷的服务和支持。通过系统的设计与实现，实现了医疗物品的供应商家管理、物品类型管理、物品仓库管理、采购计划管理、采购入库管理、出库申请管理、......
  • 10.26
    [实验任务一]：女娲造人使用简单工厂模式模拟女娲(Nvwa)造人(Person)，如果传入参数M，则返回一个Man对象，如果传入参数W，则返回一个Woman对象，如果传入参数R，则返回一个Robot对象。请用程序设计实现上述场景。实验要求：1.画出对应的类图； 2. 提交源代码；//抽象产品类：Person接口public......
  • 文档透明加密系统怎么用？五款透明加密软件汇总！2024热门推荐，实测分享！
    数据泄露事件频发，让无数企业谈之色变。想要自动对存储在计算机上的文档进行加密吗？怎么在不影响日常工作的前提，确保文档在存储和传输过程中的安全？透明加密系统来助力！本文，将详细介绍文档透明加密系统的使用方法，并汇总五款2024年热门的透明加密软件。文档透明加密系统是什么......
  • 数据防泄漏dlp厂商排名 | 十家数据防泄漏dlp厂商推荐，赶快码住！（2024最新）
    数据泄露事件频发，你是否正在寻找可靠的数据防泄漏（DLP）解决方案？2024年的数据防泄漏市场，哪些DLP厂商能够脱颖而出，成为企业信赖的守护者？为了帮助您更好地了解当前DLP市场的最新动态，我们精心挑选了十家备受推崇的DLP厂商。它们凭借卓越的技术实力、全面的解决方案和优质的服务，......
  • 2024.10.26 InfiniCLOUD WebDAV 简易登录器
     2024.10.26InfiniCLOUDWebDAV简易登录器  ;;2024.10.26InfiniCLOUDWebDAV简易登录器;;C:\APP\WinSCP\AHK\InfiniCLOUD.ahk;;WinSCP一键登录InfiniCLOUD的WebDAV文件服务的AutoHotkey脚本源代码#SingleInstance,force#Persistent;身份验证,请使用飞......
  • 产品推介——LSOP4晶体管光耦KL101X
    产品描述ProductDescriptionKL101X产品系列是由苏州晶台光电有限公司开发的晶体管光耦，由一个红外发射二极管和一个光电晶体管构成，采用4引脚LSOP封装。功能图FunctionalDiagram封装尺寸PackageDrawing产品特点ProductFeatures•电流转换率(Currenttransferra......
  • Windows 10 on ARM, version 22H2 (updated Oct 2024) ARM64 AArch64 中文版、英文版
    Windows10onARM,version22H2(updatedOct2024)ARM64AArch64中文版、英文版下载基于ARM的Windows10请访问原文链接：https://sysin.org/blog/windows-10-arm/查看最新版。原创作品，转载请保留出处。作者主页：sysin.org基于ARM的Windows10起初，Windows10（与Wi......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99