24.10.25 人工智能基础 Pandas库 函数 学习笔记

函数

重置索引

常用的统计学函数

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)

reindex_like

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

语法：

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

代码实现：

import pandas as pd


def pd_df_reindex():
    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'])
    df3 = df1.reindex_like(df2)
    print(df3)

    df4 = pd.DataFrame({
        'A': [1, 2, 3],
        'B': [4, 5, 6]
    }, index=['a', 'b', 'c'])
    df5 = pd.DataFrame({
        'B': [7, 8, 9],
        'C': [10, 11, 12]
    }, index=['a', 'b', 'c'])
    df6 = df4.reindex_like(df5)
    print(df6)

遍历

Series遍历

使用 items()

使用 index 属性

使用 values 属性

import pandas as pd


def pd_series_iter():
    # 像遍历列表一样遍历
    s = pd.Series(['A', 'B', 'C'], index=['a', 'b', 'c'])
    print('Series：')
    for i in s:
        print(i, end=' ')
    print()

    
    for i in s:
        print(i, end=' ')
    print()
    print("通过items遍历")
    # 通过items遍历 , 列遍历
    for index, value in s.items():
        print(index, value)

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

    print("通过values遍历")
    # 通过values遍历
    for i in s.values:
        print(i)

DataFrame 遍历

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

遍历行

• iterrows() 方法用于遍历 DataFrame 的行，返回一个包含索引和行的迭代器
• itertuples() 方法用于遍历 DataFrame 的行，返回一个包含行数据的命名元组。  
• 当处理大型数据集时，应尽量避免使用 iterrows()，因为它的性能相对较差。itertuples() 是遍历 DataFrame 的推荐方法，因为它在速度和内存使用上都更高效。

遍历列

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

使用属性遍历

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

import pandas as pd


def pd_df_iterrows():
    # iterrows 行遍历
    df = pd.DataFrame({
        'A': [1, 2, 3],
        'B': [4, 5, 6],
        'C': [7, 8, 9]
    }, index=['a', 'b', 'c'])
    for i, r in df.iterrows():
        print("index:", i, "row:", r)

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

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

排序

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，则返回一个新的排序后的对象

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

def pd_df_sort():
    df = pd.DataFrame({
        'A': [1, 2, 3, 5, 8, 7, 4, 6, 9],
        'B': [4, 6, 5, 8, 8, 5, 9, 6, 3]
    }, index=[9, 2, 2, 1, 5, 2, 4, 7, 5])

    # sort_index
    # 将行标签 从小到大 升序 排序
    # ascending 参数控制 升序True 降序False
    # inplace 参数控制 在原数据上修改数据True 不在原数据上修改数据False
    df1 = df.sort_index(ascending=True, inplace=False)
    print("将行标签 从小到大 升序 排序")
    print(df1)
    print("----------")

    # sort_values
    # by 参数控制要排序的列,可以是单个,也可以是多个列
    # ascending 参数控制升序(True)降序(False)
    # inplace 参数控制 在原数据上修改数据True 不在原数据上修改数据False
    df2 = df.sort_values(by='B', ascending=True, inplace=False)
    print("根据某一列的 值 来进行排序")
    print(df2)

去重

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


def pd_df_drop():
    df = pd.DataFrame({
        'A': [1, 2, 3, 5, 8, 8, 4, 6, 9],
        'B': [4, 6, 5, 8, 5, 5, 9, 6, 3],
        'C': [9, 2, 2, 1, 2, 2, 4, 7, 5]
    })
    # drop_duplicates 处理重复项
    # by 指定重复的列或者列名的列表
    # keep 处理重复项
    #     False 就不保留重复项
    #     True 去重
    #   ' first '保留重复的前面的项 ( 默认 keep='first')
    #   ' last '保留重复的后面的项
    df1 = df.drop_duplicates()
    print(df1)
    df2 = df.drop_duplicates(keep=False)
    print(df2)
    df3 = df.drop_duplicates(keep='first')
    print(df3)

分组

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

filter

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

import pandas as pd

def pd_df_filter():
    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)

合并

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

import pandas as pd


def pd_df_merge():
    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='right')
    print(df1)

    # inner 内连接,返回都拥有的键(交集)(所以1,2,3,4是共有的被返回，5,6不是共有的所以没有返回)
    df2 = pd.merge(left, right, how='inner')
    print(df2)

    # outer 外连接,返回所有的键(并集)(所以所有的键有1,2,3,4,5,6，都被返回了)
    df3 = pd.merge(left, right, how='outer')
    print(df3)