python的dataframe常用处理方法

import pandas as pd

class DataFrameProcessor:

    @staticmethod
    def sort_by_column(df, by_column, ascending=True):
        """
        根据指定列对DataFrame进行排序。

        Parameters:
        df (pd.DataFrame): 要排序的DataFrame。
        by_column (str): 要排序的列名。
        ascending (bool): True表示升序排列，False表示降序排列。

        Returns:
        pd.DataFrame: 排序后的新DataFrame。
        """
        sorted_df = df.sort_values(by=by_column, ascending=ascending)
        return sorted_df

    @staticmethod
    def remove_rows_with_value(df, column_name, value_to_remove):
        """
        从DataFrame中删除指定列等于特定值的所有行。

        Parameters:
        df (pd.DataFrame): 要处理的DataFrame。
        column_name (str): 要检查的列名。
        value_to_remove: 要删除的特定值。

        Returns:
        pd.DataFrame: 新的DataFrame，不包含指定列等于特定值的行。
        """
        filtered_df = df[df[column_name] != value_to_remove]
        return filtered_df

    @staticmethod
    def drop_duplicates(df, subset=None):
        """
        去除DataFrame中的重复行。

        Parameters:
        df (pd.DataFrame): 要处理的DataFrame。
        subset (list): 可选，要考虑的列的子集。

        Returns:
        pd.DataFrame: 不包含重复行的新DataFrame。
        """
        deduplicated_df = df.drop_duplicates(subset=subset)
        return deduplicated_df

    @staticmethod
    def get_stats(df):
        """
        计算DataFrame的统计信息。

        Parameters:
        df (pd.DataFrame): 要计算统计信息的DataFrame。

        Returns:
        pd.Series: 包含统计信息的Series。
        """
        return df.describe()

    @staticmethod
    def get_missing(df):
        """
        计算DataFrame中每列的缺失值数量。

        Parameters:
        df (pd.DataFrame): 要计算缺失值的DataFrame。

        Returns:
        pd.Series: 包含每列缺失值数量的Series。
        """
        return df.isnull().sum()

    @staticmethod
    def fill_missing(df, value):
        """
        填充DataFrame中的缺失值。

        Parameters:
        df (pd.DataFrame): 要处理的DataFrame。
        value: 用于填充缺失值的值。

        Returns:
        pd.DataFrame: 填充缺失值后的新DataFrame。
        """
        filled_df = df.fillna(value)
        return filled_df

    @staticmethod
    def filter(df, query):
        """
        根据条件过滤DataFrame。

        Parameters:
        df (pd.DataFrame): 要过滤的DataFrame。
        query (str): 过滤条件。

        Returns:
        pd.DataFrame: 符合条件的新DataFrame。
        """
        filtered_df = df.query(query)
        return filtered_df

    @staticmethod
    def convert_data_types(df, conversion_dict):
        """
        将DataFrame的列的数据类型进行转换。

        Parameters:
        df (pd.DataFrame): 要处理的DataFrame。
        conversion_dict (dict): 包含列名和目标数据类型的字典。

        Returns:
        pd.DataFrame: 数据类型转换后的新DataFrame。
        """
        converted_df = df.astype(conversion_dict)
        return converted_df

    @staticmethod
    def rename_columns(df, column_mapping):
        """
        重命名DataFrame的列。

        Parameters:
        df (pd.DataFrame): 要处理的DataFrame。
        column_mapping (dict): 包含原列名和新列名的字典。

        Returns:
        pd.DataFrame: 列重命名后的新DataFrame。
        """
        renamed_df = df.rename(columns=column_mapping)

        return renamed_df

    @staticmethod
    def calculate_mean_and_std(df, column_name):
        """
        计算DataFrame中指定列的均值和3倍标准差。

        Parameters:
        df (pd.DataFrame): 要处理的DataFrame。
        column_name (str): 要计算统计值的列名。

        Returns:
        tuple: 包含均值和3倍标准差的元组 (mean, std).
        """
        column_data = df[column_name]
        mean_value = column_data.mean()
        std_value = column_data.std() * 3  # 3倍标准差
        return mean_value, std_value

# 示例用法：

# 创建一个示例DataFrame
data = {'A': [1, 4, 2, 5, 3],
        'B': ['apple', 'cherry', 'banana', 'banana', 'apple']}

df = pd.DataFrame(data)

# 使用DataFrameProcessor类的方法
sorted_df = DataFrameProcessor.sort_by_column(df, 'A', ascending=True)
filtered_df = DataFrameProcessor.remove_rows_with_value(df, 'B', 'apple')
deduplicated_df = DataFrameProcessor.drop_duplicates(df)
stats = DataFrameProcessor.get_stats(df)
missing = DataFrameProcessor.get_missing(df)
filled_df = DataFrameProcessor.fill_missing(df, value=0)
filtered_df = DataFrameProcessor.filter(df, query='A > 2')
converted_df = DataFrameProcessor.convert_data_types(df, {'A': float})
renamed_df = DataFrameProcessor.rename_columns(df, {'A': 'New_A'})
mean, std = DataFrameProcessor.calculate_mean_and_std(df, 'A')

print(sorted_df)
print(filtered_df)
print(deduplicated_df)
print(stats)
print(missing)
print(filled_df)
print(filtered_df)
print(converted_df)
print(renamed_df)
print(f"均值: {mean}, 3倍标准差: {std}")

这个完整的 DataFrameProcessor 类包含了各种常见的数据处理方法，可以根据需要使用。