pandas基础补充

1.其他常用函数

1.重置索引

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

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)

参数说明： 

• labels：

  • 类型：数组或列表，默认为 None。

  • 描述：新的索引标签。

• index：

  • 类型：数组或列表，默认为 None。

  • 描述：新的行索引标签。

• columns：

  • 类型：数组或列表，默认为 None。

  • 描述：新的列索引标签。

• axis：

  • 类型：整数或字符串，默认为 None。

  • 描述：指定重新索引的轴。0 或 'index' 表示行，1 或 'columns' 表示列。

• method：

  • 类型：字符串，默认为 None。

  • 描述：用于填充缺失值的方法。可选值包括 'ffill'（前向填充）、'bfill'（后向填充）等。

• copy：

  • 类型：布尔值，默认为 True。

  • 描述：是否返回新的 DataFrame 或 Series。

• level：

  • 类型：整数或级别名称，默认为 None。

  • 描述：用于多级索引（MultiIndex），指定要重新索引的级别。

• fill_value：

  • 类型：标量，默认为 np.nan。

  • 描述：用于填充缺失值的值。

• limit：

  • 类型：整数，默认为 None。

  • 描述：指定连续填充的最大数量。

• tolerance：

  • 类型：标量或字典，默认为 None。

  • 描述：指定重新索引时的容差。

reindex 重置DataFrame索引 可以变相的添加行或列
index 新的行索引 axis=0默认为新的行索引
columns 新的列索引 axis=1
method 当新的行或列有缺省值 可以填充指定的值
-ffill 前向填充 用前一行（列）的数据充当当前行（列）
-bfill 后向填充 用后一行（列）的数据充当当前行（列）
fill_value 当前的行或列有缺省值时 可以指定一个值进行填充
重置行或列索引时 如果新的行或列索引不一致 则新行或列的数据默认填充为NaN
一致的行或列则填充原来的DataFrame中对应的数据

def pd_df_reindex():
    df = pd.DataFrame(
        {'A': [1, 2, 3],
         'B': [4, 5, 6],
         'C': [7, 8, 9]},
    index=["a", "b", "c"])

    new_index = ['e', 'b', 'c', 'd']
    df1 = df.reindex(new_index, axis=0)
    print(df1)

    df01 = df.reindex(index=new_index)
    print(df01)

    new_colunm = ["A", "B", "C", "D"]
    df2 = df.reindex(new_colunm, axis=1, method="ffill")
    print(df2)

    print("---------------------------------")
    df02 = df.reindex(index = new_index)
    print(df02)

    df3 = df.reindex(new_index, fill_value=1)
    print(df3)

2.reindex_like()

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

语法：

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

参数说明： 

• other：

  • 类型：DataFrame 或 Series。

  • 描述：用于对齐索引和列的参考对象。

• method：

  • 类型：字符串，默认为 None。

  • 描述：用于填充缺失值的方法。可选值包括 'ffill'（前向填充）、'bfill'（后向填充）等。

• copy：

  • 类型：布尔值，默认为 True。

  • 描述：是否返回新的 DataFrame 或 Series。

• limit：

  • 类型：整数，默认为 None。

  • 描述：指定连续填充的最大数量。

• tolerance：

  • 类型：标量或字典，默认为 None。

  • 描述：指定重新索引时的容差。

def pd_df_reindex_like():
    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=["a", 'b', 'd']
    )
    df3 = df1.reindex_like(df2)
    print(df3)

    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', 'd']
    )

    df4 = df1.reindex_like(df2)
    print(df4)

2.遍历 

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

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

1.Series遍历

1.Series可以像遍历数组一样操作

2.通过items遍历

• items存放的是一个地址
• 遍历的两个属性分别是索引和数据

3.使用index属性遍历

• index是Series的索引

4.使用values属性遍历

• values就是Series里的值

def pd_Series_iter():
    # 遍历Series可以像遍历数组一样操作
    s = pd.Series([1, 2, 3, 4, 5, 6])
    for i in s:
        print(i)

    # 遍历DataFrame不能直接遍历 打印结果为列名
    df = pd.DataFrame({
        'A': [1, 2, 3],
        'B': [4, 5, 6]})
    for i in df:
        print(i)

    # 1、通过items遍历
    for i,j in s.items():
        print(f"index:{i},value:{j}")
    # items存放的是一个地址
    # 遍历的两个属性分别是索引和数据

    # 2、通过index遍历
    for i in s.index:
        print(f"index:{i},value:{s[i]}")

    # 3、通过value遍历
    for v in s.values:
        print(f"value:{v}")

2.DataFrame遍历

1.直接遍历DataFrame返回的是列标签

2.通过iterrows遍历

• 遍历返回index，rows两个变量
• 遍历返回的rows为Series对象

3.通过itertuples遍历

• 返回一个对象
• 遍历返回值为元组对象

4. 通过items()遍历列

• 返回两个对象
• 返回列索引名和列的Series对象

5.使用属性遍历

• 通过遍历行和遍历列的嵌套得到整个DataFrame的元素
• loc 和 iloc 方法可以用于按索引或位置遍历 DataFrame 的行和列。

def pd_df_iter():
    df = pd.DataFrame({
        'A': [1, 2, 3],
        'B': [4, 5, 6]})
    # 行遍历
    # 通过iterrows遍历 遍历返回index rows两个变量 遍历返回的row为Series对象
    for index, row in df.iterrows():
        print(f"index:{index}\nrow:\n{row}")

    # 通过itertuples遍历 返回一个对象 遍历返回值为元组对象
    for row in df.itertuples():
        print(f"{row}")

    # 列遍历
    # 通过items()遍历列 返回列索引名和列的Series对象
    for col_index,col_values in df.items():
        print(f"col:{col_index},\nval:\n{col_values}")

    print(df)
    for i in df.columns: # 遍历行
        for v in df.index: # 遍历行里的每个元素
            value = df.loc[v,i]
            print(f"value:{value}")
    print(df.index)
    print(df.index.start)
    print(df.index.stop)
    print(df.columns)

    for i in range(df.index.stop):
        for j in range(len(df.columns)):
            print(df.iloc[i,j])

3.排序 

1.sort_index()

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

语法：

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

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

参数说明： 

• axis：指定要排序的轴。默认为 0，表示按行索引排序。如果设置为 1，将按列索引排序。

• ascending：布尔值，指定是升序排序（True）还是降序排序（False）。

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

2. sort_values

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

语法：

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

Series.sort_value(ascending=True, inplace=False)

参数说明：

• by：列的标签或列的标签列表。指定要排序的列。

• axis：指定沿着哪个轴排序。默认为 0，表示按列排序。如果设置为 1，将按行排序。

• ascending：布尔值或布尔值列表，指定是升序排序（True）还是降序排序（False）。可以为每个列指定不同的排序方向。

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

• kind：排序算法。默认为 'quicksort'，也可以选择 'mergesort' 或 'heapsort'。

• na_position：指定缺失值（NaN）的位置。可以是 'first' 或 'last'。

def pd_df_sort():
    s = pd.Series([1,9,7,6,9,6,88,11,60])
    s.sort_values(inplace=True)
    print(s)
    # sort_index:按行标签排序
    # 参数:
    # axis 爱排序的轴 axis=0按行 axis=1按列
    # inplace 为True返回原列表 False返回新列表
    df = pd.DataFrame({
        'A':[1,2,3],
        'B':[4,5,6]
    },index=["b",'c','a'])
    print(df)

    df1 = df.sort_index(ascending=False)
    print(df1)

    df.sort_index(ascending=False,inplace=True)
    print(df)

    df3 = df.sort_values('A')
    print(df3)
    # 按列表签排序
    # 参数
    # by 指定要排序的列 可以是单个列表或列表列表名列表
    # axis axis = 0表示行排列
    # acending False为倒序 True为升序

    df4 = df.sort_values(['a', 'b'], ascending=False,axis = 1)
    print(df4)

4.去重

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，则返回一个新的删除重复项后的对象。

def pd_df_drop():
    # 去重
    # by 指定重复的列或者列名的列表
    # keep 处理重复项
    # —first 保留第一项
    # —last 保留最后一项
    # -False 重复性都不保留
    df = pd.DataFrame({
        'A': [1, 2, 2, 3],
        'B': [4, 5, 5, 6],
        'C': [7, 8, 8, 9]})
    df1 = df.drop_duplicates()
    print(df1)

    df2 = df.drop_duplicates(keep="last")
    print(df2)

    df3 = df.drop_duplicates(keep=False)
    print(df3)

5.分组

1.grouby

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，则只考虑数据中出现的标签。

• transform：transform用于在分组操作中对每个组内的数据进行转换，并将结果合并回原始 DataFrame。计算出来的结构应与原df保持一致

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

def pd_df_groupby():
    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)
    grouped = df.groupby('A')
    for i,j in grouped:
        print(f"name:{i},\ngroup:\n{j}")
    # 按A分组求C列的平均值
    mean = df.groupby('A')['C'].mean()
    print(mean)
    normal01 = df.groupby('A')["C"].transform(lambda x: (x - x.mean()) / x.std())
    print(normal01)

    mean02 = df.groupby('A')['C'].transform("mean")
    print(mean02)
    df["group_mean"] = mean02
    df["normal"] = normal01
    print(df)
    print("---------------------------------------------------------")
    df01 = df.groupby('A').filter(lambda x:x["C"].mean() > 4)
    print(df01)

    df1 = pd.DataFrame({
        'A': [1, 2, 3],
        'B': [4, 5, 6],
    })
    # 计算出来的结构应与原df保持一致
    df2 = df1.transform('sqrt')
    df3 = df1.transform('abs')
    df4 = df1.transform(lambda x:x**2)

    print(df2)
    print(df3)
    print(df4)

6.合并

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：验证合并是否符合特定的模式。

def pd_df_merge():
    # pd.merge 两个DataFrame按照公共列进行合并
    # left 左边的DataFrame
    # right 右边的DataFrame
    # on 指定两个DataFrame公共列进行合并 如果不指定 则按照相同的列名作为公共列
    # how连接的方式
    # —inner内连接默认
    # -outer外连接并集
    # left左连接 以左边的DataFrame为准 右边的DataFrame如果有缺省值 则用NaN填补
    # left左连接 以右边的DataFrame为准 左边的DataFrame如果有缺省值 则用NaN填补
    left = pd.DataFrame({
        "key":[1,2,3,4,5],
        "A" :["A1" ,"A2" ,"A3" ,"A4", "A5"],
        "B" :["B1" ,"B2" ,"B3" ,"B4", "B5"]
    })
    right = pd.DataFrame({
        "key": [1, 2, 3, 4, 6],
        "C": ["C1", "C2", "C3", "C4", "C5"],
        "D": ["D1", "D2", "D3", "D4", "D5"]
    })
    df = pd.merge(left, right, how="left")
    print(df)

    df1 = pd.merge(left, right, how="outer")
    print(df1)

2.时间

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

1.日期解析

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

2.data_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。

def pd_df_datatime():
    datatime = dt.datetime(2024,10,25,16,3,30)
    print(datatime)
    data = dt.date(2024,10,25)
    print(data)
    time = dt.time(16,5,30,111)
    print(time)
    datetime1 = pd.Timestamp(1729843950000)
    print(datetime1)

    # 字符串转日期
    s = "2024-10-25 16:20:5"
    d2 = pd.to_datetime(s)
    print(d2)

    d3 = pd.date_range(start='2024-10-01',end='2024-10-10',freq='D')
    print(d3)
    d4 = pd.date_range(start='2024-10-01 9:0:0',end='2024-10-02 10:0:0',freq='h')
    print(d4)