import pandas as pd
import os

def remove_duplicates_from_excel(file_path, output_path, subset_cols=None):
    """
    從Excel文件中移除重復行。
    這是Python數(shù)據(jù)清洗和數(shù)據(jù)去重的核心功能。
    :param file_path: 源Excel文件路徑
    :param output_path: 去重后Excel文件的輸出路徑
    :param subset_cols: 可選，指定根據(jù)哪些列判斷重復。如果為None，則根據(jù)所有列判斷。
    """
    if not os.path.exists(file_path): return print(f"? Excel文件不存在：{file_path}")
    
    try:
        df = pd.read_excel(file_path)
        original_rows = len(df)
        print(f"?? 正在處理文件 '{os.path.basename(file_path)}'，原始行數(shù): {original_rows}")

        if subset_cols:
            # 根據(jù)指定列去重
            df_cleaned = df.drop_duplicates(subset=subset_cols, keep='first') # keep='first'保留第一次出現(xiàn)的重復項
            print(f"   ?? 根據(jù)列 {subset_cols} 去重。")
        else:
            # 根據(jù)所有列去重
            df_cleaned = df.drop_duplicates(keep='first')
            print("   ?? 根據(jù)所有列去重。")
        
        cleaned_rows = len(df_cleaned)
        removed_count = original_rows - cleaned_rows

        os.makedirs(os.path.dirname(output_path), exist_ok=True)
        df_cleaned.to_excel(output_path, index=False)
        
        print(f"? 去重成功！已移除 {removed_count} 條重復數(shù)據(jù)。")
        print(f"   去重后數(shù)據(jù)已保存到：'{os.path.basename(output_path)}' (行數(shù): {cleaned_rows})")
        print("\n   --- 去重后數(shù)據(jù)頭部 ---")
        print(df_cleaned.head())
    except Exception as e:
        print(f"? 去重失?。簕e}")

if __name__ == "__main__":
    # 準備測試Excel文件，包含重復行
    # 例如：
    # ID | Name | Phone
    # -- | ---- | -----
    # 1  | Alice| 111
    # 2  | Bob  | 222
    # 1  | Alice| 111  <-- 重復行
    # 3  | Carol| 333
    # 2  | Bob  | 444  <-- Phone不同，如果按ID+Name去重，則不算重復
    
    test_excel_path = os.path.expanduser("~/Desktop/customer_data_duplicates.xlsx")
    output_cleaned_path = os.path.expanduser("~/Desktop/customer_data_cleaned.xlsx")

    # 簡單創(chuàng)建測試文件（包含重復）
    pd.DataFrame({'ID': [1, 2, 1, 3, 2], 
                  'Name': ['Alice', 'Bob', 'Alice', 'Carol', 'Bob'], 
                  'Phone': ['111', '222', '111', '333', '444']}).to_excel(test_excel_path, index=False)

    print("--- 示例1：根據(jù)所有列去重 ---")
    remove_duplicates_from_excel(test_excel_path, output_cleaned_path)

    print("\n--- 示例2：根據(jù) 'ID' 和 'Name' 列去重 ---")
    remove_duplicates_from_excel(test_excel_path, os.path.expanduser("~/Desktop/customer_data_id_name_cleaned.xlsx"), subset_cols=['ID', 'Name'])

import pandas as pd
import os

def identify_missing_values(file_path):
    """
    識別Excel文件中的缺失值，并顯示其分布。
    這是缺失值處理的第一步。
    :param file_path: Excel文件路徑
    """
    if not os.path.exists(file_path): return print(f"? Excel文件不存在：{file_path}")
    
    try:
        df = pd.read_excel(file_path)
        print(f"?? 正在識別文件 '{os.path.basename(file_path)}' 中的缺失值...")
        
        # 核心操作：isnull() 返回一個布爾型DataFrame，每個True表示一個缺失值
        missing_data = df.isnull() 
        print("\n   --- 缺失值布爾型視圖（True表示缺失）---")
        print(missing_data.head())

        # 統(tǒng)計每列的缺失值數(shù)量
        missing_counts = df.isnull().sum()
        print("\n   --- 每列缺失值數(shù)量 ---")
        print(missing_counts)

        # 統(tǒng)計總缺失值數(shù)量
        total_missing = df.isnull().sum().sum()
        print(f"\n   總缺失值數(shù)量: {total_missing}")
        
        # 可選：顯示缺失值比例
        missing_percentage = df.isnull().sum() * 100 / len(df)
        print("\n   --- 每列缺失值比例 (%) ---")
        print(missing_percentage)

    except Exception as e:
        print(f"? 識別缺失值失敗：{e}")

if __name__ == "__main__":
    # 準備測試Excel文件，包含一些缺失值 (空單元格或#N/A)
    # 例如：
    # Name | Age | City
    # ---- | --- | ----
    # Alice| 25  | NY
    # Bob  | NaN | LA   <-- 缺失
    # Carol| 30  |      <-- 缺失
    test_excel_path = os.path.expanduser("~/Desktop/data_with_missing.xlsx")
    pd.DataFrame({'Name': ['Alice', 'Bob', 'Carol', 'David'], 
                  'Age': [25, None, 30, 40], 
                  'City': ['NY', 'LA', None, 'SF']}).to_excel(test_excel_path, index=False)

    identify_missing_values(test_excel_path)

import pandas as pd
import os

def fill_missing_values(file_path, output_path, fill_strategy="mean"):
    """
    填充Excel文件中的缺失值。
    這是Python數(shù)據(jù)清洗和缺失值處理的核心功能，實現(xiàn)數(shù)據(jù)完整無缺。
    :param file_path: 源Excel文件路徑
    :param output_path: 填充后Excel文件的輸出路徑
    :param fill_strategy: 填充策略 ("mean", "median", "mode", "ffill", "bfill", "constant")
    """
    if not os.path.exists(file_path): return print(f"? Excel文件不存在：{file_path}")
    try:
        df = pd.read_excel(file_path)
        print(f"?? 正在使用 '{fill_strategy}' 策略填充 '{os.path.basename(file_path)}' 中的缺失值...")
        
        df_filled = df.copy() # 操作副本，不改變原DataFrame

        if fill_strategy == "mean":
            df_filled = df_filled.fillna(df_filled.mean(numeric_only=True)) # 填充數(shù)值列的均值
        elif fill_strategy == "median":
            df_filled = df_filled.fillna(df_filled.median(numeric_only=True)) # 填充數(shù)值列的中位數(shù)
        elif fill_strategy == "mode":
            # 眾數(shù)可能不止一個，這里取第一個
            for col in df_filled.columns:
                if df_filled[col].isnull().any():
                    mode_val = df_filled[col].mode()[0] if not df_filled[col].mode().empty else None
                    df_filled[col] = df_filled[col].fillna(mode_val)
        elif fill_strategy == "ffill": # forward fill，用前一個非缺失值填充
            df_filled = df_filled.fillna(method='ffill')
        elif fill_strategy == "bfill": # backward fill，用后一個非缺失值填充
            df_filled = df_filled.fillna(method='bfill')
        elif fill_strategy == "constant": # 用固定值填充
            # 針對不同數(shù)據(jù)類型可以設置不同常數(shù)，這里簡化
            df_filled = df_filled.fillna("未知") # 填充字符串為“未知”
            df_filled = df_filled.fillna(0, numeric_only=True) # 填充數(shù)字為0
        else:
            print("?? 未知填充策略。")
            
        os.makedirs(os.path.dirname(output_path), exist_ok=True)
        df_filled.to_excel(output_path, index=False)
        
        print(f"? 缺失值填充成功！結果保存到：'{os.path.basename(output_path)}'")
        print("\n   --- 填充后數(shù)據(jù)頭部 ---")
        print(df_filled.head())
    except Exception as e:
        print(f"? 填充缺失值失?。簕e}")

if __name__ == "__main__":
    test_excel_path = os.path.expanduser("~/Desktop/data_with_missing.xlsx") # 使用2.1節(jié)創(chuàng)建的文件
    output_filled_path_mean = os.path.expanduser("~/Desktop/data_filled_mean.xlsx")
    output_filled_path_constant = os.path.expanduser("~/Desktop/data_filled_unknown.xlsx")

    # 示例1：用均值填充數(shù)值缺失值
    fill_missing_values(test_excel_path, output_filled_path_mean, fill_strategy="mean")

    # 示例2：用常數(shù)“未知”填充字符串缺失值
    # fill_missing_values(test_excel_path, output_filled_path_constant, fill_strategy="constant")

import pandas as pd
import os

def drop_missing_values(file_path, output_path, how_to_drop="any", subset_cols=None):
    """
    刪除Excel文件中包含缺失值的行或列。
    這是Python數(shù)據(jù)清洗和缺失值處理的關鍵功能。
    :param file_path: 源Excel文件路徑
    :param output_path: 刪除后Excel文件的輸出路徑
    :param how_to_drop: 刪除策略 ("any" - 只要有缺失就刪除, "all" - 整行/列都是缺失才刪除)
    :param subset_cols: 可選，指定只檢查這些列的缺失值
    """
    if not os.path.exists(file_path): return print(f"? Excel文件不存在：{file_path}")
    try:
        df = pd.read_excel(file_path)
        original_rows = len(df)
        print(f"?? 正在刪除 '{os.path.basename(file_path)}' 中的缺失值，原始行數(shù): {original_rows}")

        # **核心操作：df.dropna()**
        # how="any" 表示只要有任一缺失值就刪除該行/列
        # how="all" 表示只有當所有值為缺失值時才刪除該行/列
        # axis=0 (默認) 表示刪除行，axis=1 表示刪除列
        df_dropped = df.dropna(how=how_to_drop, subset=subset_cols)
        
        dropped_rows = original_rows - len(df_dropped)

        os.makedirs(os.path.dirname(output_path), exist_ok=True)
        df_dropped.to_excel(output_path, index=False)
        
        print(f"? 缺失值刪除成功！已刪除 {dropped_rows} 條數(shù)據(jù)。")
        print(f"   刪除后數(shù)據(jù)已保存到：'{os.path.basename(output_path)}' (行數(shù): {len(df_dropped)})")
        print("\n   --- 刪除后數(shù)據(jù)頭部 ---")
        print(df_dropped.head())
    except Exception as e:
        print(f"? 刪除缺失值失?。簕e}")

if __name__ == "__main__":
    test_excel_path = os.path.expanduser("~/Desktop/data_with_missing.xlsx") # 使用2.1節(jié)創(chuàng)建的文件
    output_dropped_any = os.path.expanduser("~/Desktop/data_dropped_any.xlsx")
    output_dropped_subset = os.path.expanduser("~/Desktop/data_dropped_subset.xlsx")

    # 示例1：刪除任何包含缺失值的行
    print("\n--- 示例1：刪除任何包含缺失值的行 ---")
    drop_missing_values(test_excel_path, output_dropped_any, how_to_drop="any")

    # 示例2：只刪除 'Age' 列有缺失值的行
    print("\n--- 示例2：只刪除 'Age' 列有缺失值的行 ---")
    drop_missing_values(test_excel_path, output_dropped_subset, how_to_drop="any", subset_cols=['Age'])

import pandas as pd
import os

def normalize_strings_in_excel(file_path, output_path, column_name="Product"):
    """
    統(tǒng)一Excel指定列的字符串格式（大小寫，去除空格）。
    這是Python數(shù)據(jù)清洗和Excel數(shù)據(jù)處理自動化的常見操作。
    :param file_path: 源Excel文件路徑
    :param output_path: 統(tǒng)一格式后Excel文件的輸出路徑
    :param column_name: 要處理的字符串列名
    """
    if not os.path.exists(file_path): return print(f"? Excel文件不存在：{file_path}")
    try:
        df = pd.read_excel(file_path)
        print(f"?? 正在統(tǒng)一列 '{column_name}' 的字符串格式...")

        # 確保列是字符串類型，然后進行操作
        if pd.api.types.is_string_dtype(df[column_name]):
            # 核心操作：轉換為小寫，去除首尾空格
            df[column_name] = df[column_name].str.lower().str.strip()
            print("   ? 已將字符串轉換為小寫并去除首尾空格。")
        else:
            print(f"?? 列 '{column_name}' 不是字符串類型，跳過格式統(tǒng)一。")
        
        os.makedirs(os.path.dirname(output_path), exist_ok=True)
        df.to_excel(output_path, index=False)
        
        print(f"? 字符串格式統(tǒng)一成功！結果保存到：'{os.path.basename(output_path)}'")
        print("\n   --- 統(tǒng)一格式后數(shù)據(jù)頭部 ---")
        print(df.head())
    except Exception as e:
        print(f"? 字符串格式統(tǒng)一失敗：{e}")

if __name__ == "__main__":
    test_excel_path = os.path.expanduser("~/Desktop/product_names.xlsx")
    output_cleaned_path = os.path.expanduser("~/Desktop/product_names_cleaned.xlsx")

    pd.DataFrame({'Product': [' APPLE ', 'Banana', 'ORANGE ', ' apple'], 'Price': [10, 5, 8, 12]}).to_excel(test_excel_path, index=False)

    normalize_strings_in_excel(test_excel_path, output_cleaned_path, column_name="Product")

import pandas as pd
import os

def convert_data_types_in_excel(file_path, output_path):
    """
    轉換Excel文件中指定列的數(shù)據(jù)類型。
    這是Python數(shù)據(jù)清洗和Excel數(shù)據(jù)處理自動化的核心。
    :param file_path: 源Excel文件路徑
    :param output_path: 轉換后Excel文件的輸出路徑
    """
    if not os.path.exists(file_path): return print(f"? Excel文件不存在：{file_path}")
    try:
        df = pd.read_excel(file_path)
        print(f"?? 正在轉換 '{os.path.basename(file_path)}' 中的數(shù)據(jù)類型...")
        print("\n   --- 原始數(shù)據(jù)類型 ---")
        print(df.dtypes)

        # **核心操作1：文本列轉為數(shù)值**
        # errors='coerce' 會將無法轉換的值變?yōu)镹aN，而不是報錯
        df['Sales_Amount'] = pd.to_numeric(df['Sales_Amount'], errors='coerce')
        
        # **核心操作2：統(tǒng)一日期格式**
        df['Order_Date'] = pd.to_datetime(df['Order_Date'], errors='coerce')
        # 如果需要特定日期字符串格式，可以再轉換一次：df['Order_Date'] = df['Order_Date'].dt.strftime('%Y-%m-%d')
        
        print("\n   --- 轉換后數(shù)據(jù)類型 ---")
        print(df.dtypes)

        os.makedirs(os.path.dirname(output_path), exist_ok=True)
        df.to_excel(output_path, index=False)
        
        print(f"? 數(shù)據(jù)類型轉換成功！結果保存到：'{os.path.basename(output_path)}'")
        print("\n   --- 轉換后數(shù)據(jù)頭部 ---")
        print(df.head())
    except Exception as e:
        print(f"? 數(shù)據(jù)類型轉換失?。簕e}")

if __name__ == "__main__":
    test_excel_path = os.path.expanduser("~/Desktop/mixed_data.xlsx")
    output_cleaned_path = os.path.expanduser("~/Desktop/mixed_data_cleaned.xlsx")

    # 簡單創(chuàng)建測試文件，包含字符串形式的數(shù)字和不同格式的日期
    pd.DataFrame({'Sales_Amount': ['123', '456.78', 'N/A', '789'], 
                  'Order_Date': ['2023-01-15', '1/2/23', 'March 10, 2023', None]}).to_excel(test_excel_path, index=False)

    convert_data_types_in_excel(test_excel_path, output_cleaned_path)

import pandas as pd
import os

def handle_outliers_simple(file_path, output_path, column_name="Age", lower_bound=0, upper_bound=120):
    """
    簡單處理Excel中指定列的異常值（過濾掉超出合理范圍的數(shù)據(jù)）。
    這是Python數(shù)據(jù)清洗和異常值處理的基礎。
    :param file_path: 源Excel文件路徑
    :param output_path: 處理后Excel文件的輸出路徑
    :param column_name: 要檢查異常值的列名
    :param lower_bound: 合理范圍的下限
    :param upper_bound: 合理范圍的上限
    """
    if not os.path.exists(file_path): return print(f"? Excel文件不存在：{file_path}")
    try:
        df = pd.read_excel(file_path)
        original_rows = len(df)
        print(f"?? 正在處理列 '{column_name}' 中的異常值，原始行數(shù): {original_rows}")

        # 確保列是數(shù)值類型
        df[column_name] = pd.to_numeric(df[column_name], errors='coerce')
        df_cleaned = df.dropna(subset=[column_name]) # 先刪除無法轉換為數(shù)字的行

        # **核心操作：基于閾值過濾異常值**
        df_filtered = df_cleaned[(df_cleaned[column_name] >= lower_bound) & (df_cleaned[column_name] <= upper_bound)]
        
        removed_outliers = original_rows - len(df_filtered)

        os.makedirs(os.path.dirname(output_path), exist_ok=True)
        df_filtered.to_excel(output_path, index=False)
        
        print(f"? 異常值處理成功！已移除 {removed_outliers} 條異常數(shù)據(jù)。")
        print(f"   處理后數(shù)據(jù)已保存到：'{os.path.basename(output_path)}' (行數(shù): {len(df_filtered)})")
        print("\n   --- 處理后數(shù)據(jù)頭部 ---")
        print(df_filtered.head())
    except Exception as e:
        print(f"? 異常值處理失?。簕e}")

if __name__ == "__main__":
    test_excel_path = os.path.expanduser("~/Desktop/data_with_outliers.xlsx")
    output_cleaned_path = os.path.expanduser("~/Desktop/data_outliers_cleaned.xlsx")

    pd.DataFrame({'Name': ['A', 'B', 'C', 'D'], 
                  'Age': [25, 200, 30, -5], # 包含異常值
                  'Score': [90, 85, 95, 10]}).to_excel(test_excel_path, index=False)

    handle_outliers_simple(test_excel_path, output_cleaned_path, column_name="Age", lower_bound=1, upper_bound=100)