五個案例快速熟悉 Pandas 常用操作

作者：用戶007 2025-04-24 10:20:00

本文展示了Pandas在日常數據處理中最常用的一些功能，熟練掌握這些操作是進行任何數據分析項目的基礎。

Pandas是Python生態系統中用于數據處理和分析的核心庫。它構建在NumPy之上，提供了高性能、易于使用的數據結構(主要是Series一維數據和DataFrame二維數據)和數據分析工具。無論是數據清洗、轉換、合并還是可視化前的準備，Pandas都是數據科學家的得力助手。

案例一：數據加載與查看

(1) 場景描述

數據分析的第一步通常是從外部文件(如CSV、Excel)加載數據，并快速查看數據的基本信息，如前幾行、后幾行、整體結構等。

# 導入pandas庫，通常簡寫為pd
import pandas as pd
import io # 用于在內存中模擬文件

# ---- 1. 數據加載 ----
# 假設的CSV數據內容 (如果在本地有文件，請使用 pd.read_csv('students.csv'))
csv_data = """StudentID,Name,Age,Major,GPA
1001,Alice,21,Computer Science,3.8
1002,Bob,22,Physics,3.5
1003,Charlie,20,Mathematics,3.9
1004,David,23,Computer Science,3.7
1005,Eve,21,Engineering,3.6
"""

# 使用 io.StringIO 在內存中模擬一個CSV文件對象
# 然后使用 pandas 讀取這個模擬文件
# 如果有實際文件 'students.csv'，直接用 df = pd.read_csv('students.csv') 即可
df = pd.read_csv(io.StringIO(csv_data))

print("--- 數據加載成功 ---")
# 打印整個DataFrame (對于大數據集，通常不建議直接打印整個df)
# print(df)


# ---- 2. 數據基本查看 ----

# 查看數據的前5行 (默認n=5)
print("\n--- 查看前5行 (head) ---")
print(df.head())

# 查看數據的后3行
print("\n--- 查看后3行 (tail) ---")
print(df.tail(3))

# 查看DataFrame的索引、列名和數據類型等信息
print("\n--- 查看基本信息 (info) ---")
df.info()

# 查看數值型列的描述性統計信息（計數、均值、標準差、最小值、四分位數、最大值）
print("\n--- 查看描述性統計 (describe) ---")
print(df.describe())

# 查看DataFrame的維度（行數, 列數）
print("\n--- 查看數據維度 (shape) ---")
print(df.shape)

# 查看所有列名
print("\n--- 查看列名 (columns) ---")
print(df.columns)

# 查看每一列的數據類型
print("\n--- 查看數據類型 (dtypes) ---")
print(df.dtypes)

(2) 代碼注釋

pd.read_csv(): 這是Pandas用于讀取CSV文件的核心函數。它可以直接讀取文件路徑或類文件對象。
df.head(n): 返回DataFrame的前n行，默認為5。用于快速預覽數據。
df.tail(n): 返回DataFrame的后n行，默認為5。用于檢查數據結尾。
df.info(): 提供DataFrame的緊湊摘要，包括索引類型、列名、非空值數量和內存使用情況。非常適合快速了解數據概況和類型。
df.describe(): 生成描述性統計數據，主要針對數值類型的列。對于非數值列，可以加include='object'或include='all'。
df.shape: 返回一個元組，表示DataFrame的維度(行數，列數)。
df.columns: 返回包含所有列名的索引對象。
df.dtypes: 返回一個Series，其中包含每列的數據類型。

案例二：數據選擇與過濾

(1) 場景描述

在數據分析中，我們經常需要根據特定條件選擇數據的子集，例如選擇特定的列、或滿足某些條件的行。

(2) 使用數據

我們繼續使用上一個案例中加載的 df (學生數據)。

(3) 代碼實現

# 繼續使用上一個案例創建的 df

print("--- 原始數據 ---")
print(df)

# ---- 1. 選擇列 ----

# 選擇單列 (返回一個 Series)
print("\n--- 選擇 'Name' 列 ---")
name_series = df['Name']
print(type(name_series)) # 輸出 <class 'pandas.core.series.Series'>
print(name_series)

# 選擇多列 (返回一個新的 DataFrame)
print("\n--- 選擇 'Name' 和 'GPA' 列 ---")
name_gpa_df = df[['Name', 'GPA']] # 注意這里用的是雙層方括號
print(type(name_gpa_df)) # 輸出 <class 'pandas.core.frame.DataFrame'>
print(name_gpa_df)


# ---- 2. 選擇行 (基于標簽 loc 和 位置 iloc) ----

# 使用 .loc 按標簽（索引名）選擇行
# DataFrame默認索引是0, 1, 2... 此時loc和iloc在選擇行時表現類似
print("\n--- 使用 loc 選擇索引為 1 的行 ---")
row_1_loc = df.loc[1] # 索引標簽為 1
print(row_1_loc)

# 使用 .iloc 按整數位置選擇行 (從0開始)
print("\n--- 使用 iloc 選擇第 3 行 (位置為 2) ---")
row_3_iloc = df.iloc[2] # 第3行的位置是2
print(row_3_iloc)

# 選擇連續多行
print("\n--- 使用 iloc 選擇第 2 到第 4 行 (位置 1 到 3) ---")
rows_1_to_3 = df.iloc[1:4] # 不包括位置4
print(rows_1_to_3)


# ---- 3. 選擇行和列 ----

# 使用 loc 選擇特定行和列
print("\n--- 使用 loc 選擇索引為 0 和 2 的行的 'Name' 和 'Age' 列 ---")
subset_loc = df.loc[[0, 2], ['Name', 'Age']]
print(subset_loc)

# 使用 iloc 選擇特定行和列 (按位置)
# 選擇第1行(位置0)、第3行(位置2) 的 第2列(位置1)、第4列(位置3)
print("\n--- 使用 iloc 選擇特定行和列 (按位置) ---")
subset_iloc = df.iloc[[0, 2], [1, 3]] # 行位置0, 2; 列位置1 (Name), 3 (Major)
print(subset_iloc)


# ---- 4. 條件過濾 (布爾索引) ----

# 選擇 Age 大于 21 的學生
print("\n--- 選擇 Age > 21 的學生 ---")
older_students = df[df['Age'] > 21]
print(older_students)

# 選擇 專業為 'Computer Science' 的學生
print("\n--- 選擇專業為 'Computer Science' 的學生 ---")
cs_students = df[df['Major'] == 'Computer Science']
print(cs_students)

# 組合條件：選擇專業為 'Computer Science' 且 GPA 大于 3.7 的學生
print("\n--- 選擇專業為 'Computer Science' 且 GPA > 3.7 的學生 ---")
top_cs_students = df[(df['Major'] == 'Computer Science') & (df['GPA'] > 3.7)] # 使用 & (and), | (or)
print(top_cs_students)

(4) 代碼注釋

df['ColumnName']: 選擇單列，返回 Pandas Series。
df[['Col1', 'Col2']]: 使用列表選擇多列，返回 Pandas DataFrame。
df.loc[row_label, col_label]: 基于標簽(索引名和列名)進行選擇。標簽可以是單個標簽、列表或切片。
df.iloc[row_position, col_position]: 基于整數位置(從0開始)進行選擇。位置可以是單個整數、列表或切片。
df[boolean_condition]: 這是布爾索引的核心。boolean_condition 通常是一個評估為布爾值(True/False)的 Series(例如 df['Age'] > 21)。Pandas會返回 boolean_condition 為 True 的所有行。
& (與), | (或), ~ (非): 用于組合多個布爾條件。注意：必須使用 & 和 |，而不是 Python 的 and 和 or。每個條件需要用括號括起來。

案例三：處理缺失值

(1) 場景描述

真實世界的數據往往不完美，包含缺失值(通常表示為 NaN, Not a Number)。處理缺失值是數據清洗的關鍵步驟，常見策略包括刪除缺失值或填充缺失值。

(2) 準備數據

我們創建一個包含缺失值的新DataFrame。

(3) 代碼實現

import pandas as pd
import numpy as np # NumPy 通常用于生成 NaN

# ---- 1. 創建包含缺失值的DataFrame ----
data_with_nan = {
    'StudentID': [1001, 1002, 1003, 1004, 1005, 1006],
    'Name': ['Alice', 'Bob', 'Charlie', 'David', np.nan, 'Frank'],
    'Age': [21, 22, 20, np.nan, 21, 22],
    'GPA': [3.8, 3.5, 3.9, 3.7, np.nan, np.nan]
}
df_nan = pd.DataFrame(data_with_nan)

print("--- 包含缺失值的原始數據 ---")
print(df_nan)

# ---- 2. 檢測缺失值 ----

# 檢查整個DataFrame是否有缺失值 (返回布爾型DataFrame)
print("\n--- 檢查缺失值 (isnull) ---")
print(df_nan.isnull()) # isnull() 和 isna() 等價

# 統計每列的缺失值數量
print("\n--- 統計每列的缺失值數量 ---")
print(df_nan.isnull().sum())

# 統計總的缺失值數量
print("\n--- 統計總缺失值數量 ---")
print(df_nan.isnull().sum().sum())

# ---- 3. 處理缺失值：刪除 ----

# 刪除任何包含缺失值的行 (dropna)
# axis=0 表示按行操作，how='any' 表示只要有一個NaN就刪除該行
print("\n--- 刪除包含NaN的行 (how='any') ---")
df_dropped_any = df_nan.dropna(axis=0, how='any') # 默認行為
print(df_dropped_any)

# 刪除所有值都是缺失值的行 (how='all')
# 在這個例子中沒有這樣的行
# df_dropped_all = df_nan.dropna(axis=0, how='all')

# 刪除任何包含缺失值的列
# axis=1 表示按列操作
print("\n--- 刪除包含NaN的列 ---")
df_dropped_cols = df_nan.dropna(axis=1, how='any')
print(df_dropped_cols) # Name, Age, GPA列都會被刪除

# ---- 4. 處理缺失值：填充 ----

# 用一個特定值填充所有NaN
print("\n--- 用 0 填充所有 NaN ---")
df_filled_zero = df_nan.fillna(0)
print(df_filled_zero)

# 使用指定值填充特定列的NaN
# 例如，用 'Unknown' 填充 'Name' 列的NaN，用 'Age' 列的平均值填充 'Age' 的NaN
print("\n--- 分別填充不同列的 NaN ---")
# 先復制一份，避免修改原始 df_nan
df_filled_specific = df_nan.copy()
# 計算 Age 的平均值 (忽略NaN)
age_mean = df_filled_specific['Age'].mean()
print(f"Calculated mean age: {age_mean}")
# 填充 Name 列
df_filled_specific['Name'].fillna('Unknown', inplace=True) # inplace=True 直接修改原DataFrame
# 填充 Age 列
df_filled_specific['Age'].fillna(age_mean, inplace=True)
# 填充 GPA 列 (例如用中位數)
gpa_median = df_filled_specific['GPA'].median()
print(f"Calculated median GPA: {gpa_median}")
df_filled_specific['GPA'].fillna(gpa_median, inplace=True)

print(df_filled_specific)

# 使用前向填充 (用前一個有效值填充)
print("\n--- 使用前向填充 (ffill) ---")
df_ffilled = df_nan.fillna(method='ffill') # or .ffill()
print(df_ffilled)

# 使用后向填充 (用后一個有效值填充)
print("\n--- 使用后向填充 (bfill) ---")
df_bfilled = df_nan.fillna(method='bfill') # or .bfill()
print(df_bfilled)

(4) 代碼注釋

pd.DataFrame(): 用于創建DataFrame。
df.isnull() / df.isna(): 返回一個與原DataFrame形狀相同的布爾DataFrame，True表示對應位置是缺失值。
df.isnull().sum(): 對布爾DataFrame按列求和，得到每列缺失值的數量。
df.dropna(axis=0/1, how='any'/'all', subset=['col']): 刪除包含缺失值的行(axis=0)或列(axis=1)。
how='any'：只要有NaN就刪除。
how='all'：所有值都是NaN才刪除。
subset：指定只在哪些列中檢查NaN。
df.fillna(value, method='ffill'/'bfill', inplace=False): 填充缺失值。
value: 可以是標量(填充所有NaN)，或是一個字典(指定每列用什么值填充)。
method='ffill'：前向填充。
method='bfill'：后向填充。
inplace=True: 直接修改原DataFrame，而不是返回一個新對象。謹慎使用。
df['column'].mean(), df['column'].median(), df['column'].mode()[0]: 常用于計算填充缺失值所需的統計量(均值、中位數、眾數)。

案例四：數據分組與聚合

(1) 場景描述

分組聚合是數據分析中非常強大的功能，允許我們按照某些類別對數據進行分組，然后對每個組應用聚合函數(如求和、計數、平均值等)，從而提取有價值的洞察。

(2) 準備數據

假設我們有以下銷售數據：

import pandas as pd

# 銷售數據
sales_data = {
    'Category': ['Electronics', 'Clothing', 'Electronics', 'Groceries', 'Clothing', 'Groceries', 'Electronics', 'Clothing'],
    'Product': ['Laptop', 'T-Shirt', 'Phone', 'Apples', 'Jeans', 'Milk', 'Tablet', 'Jacket'],
    'Sales': [1200, 25, 800, 5, 70, 3, 650, 150],
    'Quantity': [1, 2, 1, 10, 1, 3, 1, 1]
}
df_sales = pd.DataFrame(sales_data)

print("--- 原始銷售數據 ---")
print(df_sales)

(3) 代碼實現

# 繼續使用上面創建的 df_sales

# ---- 1. 按單列分組并聚合 ----

# 按 'Category' 分組，計算每個類別的總銷售額
print("\n--- 按 Category 分組計算總銷售額 (sum) ---")
category_sales_sum = df_sales.groupby('Category')['Sales'].sum()
print(category_sales_sum)
print(type(category_sales_sum)) # 返回 Series

# 按 'Category' 分組，計算每個類別的平均銷售額和總數量
# 如果對分組后的對象直接調用聚合函數，會對所有數值列進行計算
print("\n--- 按 Category 分組計算所有數值列的均值 (mean) ---")
category_mean = df_sales.groupby('Category').mean() # 計算 Sales 和 Quantity 的均值
print(category_mean)
print(type(category_mean)) # 返回 DataFrame

# 按 'Category' 分組，計算每個類別有多少條記錄 (size 或 count)
print("\n--- 按 Category 分組計算記錄數 (size) ---")
category_counts = df_sales.groupby('Category').size()
print(category_counts)
# 使用 count() - 會分別計算每列的非空記錄數
# print("\n--- 按 Category 分組計算記錄數 (count) ---")
# category_counts_col = df_sales.groupby('Category').count()
# print(category_counts_col)

# ---- 2. 按多列分組 ----

# 按 'Category' 和 'Product' 分組 (雖然這里Product唯一，演示多級索引)
# 計算每個產品組的總銷售額 (在這個數據里，每個組只有一行)
print("\n--- 按 Category 和 Product 分組計算總銷售額 ---")
category_product_sales = df_sales.groupby(['Category', 'Product'])['Sales'].sum()
print(category_product_sales) # 結果是一個具有多級索引 (MultiIndex) 的 Series


# ---- 3. 使用 agg 進行多種聚合 ----

# 對不同列應用不同的聚合函數，或者對同一列應用多個聚合函數
print("\n--- 使用 agg 對 Category 分組進行多種聚合 ---")
agg_results = df_sales.groupby('Category').agg(
    TotalSales=('Sales', 'sum'),          # 計算 Sales 的總和，結果列名為 TotalSales
    AverageSales=('Sales', 'mean'),       # 計算 Sales 的平均值，結果列名為 AverageSales
    TotalQuantity=('Quantity', 'sum'),    # 計算 Quantity 的總和
    ProductCount=('Product', 'count')     # 計算每個類別有多少個產品記錄
)
print(agg_results)

# 對同一列應用多個聚合函數
print("\n--- 對 Sales 列應用多個聚合函數 ---")
sales_agg = df_sales.groupby('Category')['Sales'].agg(['sum', 'mean', 'min', 'max', 'count'])
print(sales_agg)

(4) 代碼注釋

① df.groupby('ColumnName') 或 df.groupby(['Col1', 'Col2']): 創建一個 GroupBy 對象，按指定的列(一個或多個)對 DataFrame 進行分組。這本身不進行計算，只是定義了分組規則。

② .sum(), .mean(), .median(), .min(), .max(), .count(), .size(), .std(), .var(): 這些是常用的聚合函數，可以直接應用在 GroupBy 對象上或選擇了特定列的 GroupBy 對象上。

③ .size(): 返回每個組的大小(行數)，結果是 Series。

④ .count(): 返回每個組中每列的非空值的數量，結果是 DataFrame。

⑤ GroupBy_Object['TargetColumn']: 在分組后選擇要進行聚合的列。

⑥ .agg(): 提供更靈活的聚合方式。

可以傳遞一個函數列表，如 ['sum', 'mean']，對選定的列應用所有這些函數。
可以傳遞一個字典，如 {'Sales': 'sum', 'Quantity': 'mean'}，對不同的列應用不同的聚合函數。
可以使用命名聚合(如 TotalSales=('Sales', 'sum'))，允許自定義輸出列名，語法為 NewColumnName = ('SourceColumnName', 'AggregationFunction')。這在 Pandas 較高版本中推薦使用。

案例五：數據合并與連接 (Bonus)

(1) 場景描述

在實際項目中，數據通常分散在多個表(DataFrame)中，需要將它們根據共同的鍵(key)合并或連接起來。

(2) 準備數據

創建兩個簡單的DataFrame用于演示合并。

import pandas as pd

# 第一個DataFrame: 員工信息
df_employees = pd.DataFrame({
    'EmpID': [101, 102, 103, 104],
    'Name': ['Alice', 'Bob', 'Charlie', 'David'],
    'DepartmentID': [1, 2, 1, 3]
})

# 第二個DataFrame: 部門信息
df_departments = pd.DataFrame({
    'DeptID': [1, 2, 3, 4],
    'DepartmentName': ['HR', 'Engineering', 'Sales', 'Marketing'],
    'Location': ['New York', 'San Francisco', 'New York', 'Chicago']
})

print("--- 員工信息 DataFrame ---")
print(df_employees)
print("\n--- 部門信息 DataFrame ---")
print(df_departments)

(3) 代碼實現

# ---- 1. 使用 merge 進行合并 ----

# 內連接 (Inner Join): 只保留兩個DataFrame中鍵都存在的行
# 需要指定左右DataFrame的連接鍵 (left_on, right_on)
print("\n--- 內連接 (Inner Join) ---")
# EmpID 和 DeptID 是連接鍵，但名字不同
inner_merged_df = pd.merge(
    df_employees,
    df_departments,
    left_on='DepartmentID', # df_employees 中的鍵
    right_on='DeptID',      # df_departments 中的鍵
    how='inner'             # 連接方式為內連接
)
print(inner_merged_df)
# 注意 David (DepartmentID=3) 和 Sales (DeptID=3) 都被包含
# Marketing (DeptID=4) 沒有對應的員工，HR (DeptID=1) 有兩個員工

# 左連接 (Left Join): 保留左邊DataFrame的所有行，以及右邊DataFrame匹配的行，不匹配的用NaN填充
print("\n--- 左連接 (Left Join) ---")
left_merged_df = pd.merge(
    df_employees,
    df_departments,
    left_on='DepartmentID',
    right_on='DeptID',
    how='left'
)
print(left_merged_df)
# 所有員工都被保留。David (DepartmentID=3) 對應 Sales。

# 右連接 (Right Join): 保留右邊DataFrame的所有行，以及左邊DataFrame匹配的行，不匹配的用NaN填充
print("\n--- 右連接 (Right Join) ---")
right_merged_df = pd.merge(
    df_employees,
    df_departments,
    left_on='DepartmentID',
    right_on='DeptID',
    how='right'
)
print(right_merged_df)
# 所有部門都被保留。Marketing (DeptID=4) 沒有對應的員工，所以員工信息列為 NaN。

# 外連接 (Outer Join): 保留兩邊DataFrame的所有行，不匹配的用NaN填充
print("\n--- 外連接 (Outer Join) ---")
outer_merged_df = pd.merge(
    df_employees,
    df_departments,
    left_on='DepartmentID',
    right_on='DeptID',
    how='outer'
)
print(outer_merged_df)
# 包含所有員工和所有部門。Marketing沒有員工，員工信息為NaN。


# ---- 2. 使用 concat 進行連接 (堆疊) ----
# concat 主要用于沿某個軸（行或列）將多個DataFrame粘合在一起

# 假設有另一個員工 DataFrame
df_more_employees = pd.DataFrame({
    'EmpID': [105, 106],
    'Name': ['Eve', 'Frank'],
    'DepartmentID': [2, 4] # Frank 在 Marketing 部門
})

print("\n--- 另一個員工 DataFrame ---")
print(df_more_employees)

# 按行堆疊 (axis=0, 默認)
print("\n--- 按行堆疊兩個員工 DataFrame (concat axis=0) ---")
all_employees_stacked = pd.concat([df_employees, df_more_employees], ignore_index=True)
# ignore_index=True 重新生成從0開始的索引
print(all_employees_stacked)

# 按列連接 (axis=1) - 通常需要索引對齊
# 創建一個基于EmpID索引的DataFrame
df_salary = pd.DataFrame({
    'EmpID': [101, 102, 103, 105],
    'Salary': [70000, 80000, 75000, 90000]
}).set_index('EmpID')

df_employees_indexed = df_employees.set_index('EmpID')

print("\n--- 按列連接員工信息和薪水信息 (concat axis=1) ---")
# 需要先將 EmpID 設置為索引才能正確對齊
employee_salary_concat = pd.concat([df_employees_indexed, df_salary], axis=1)
print(employee_salary_concat)
# EmpID 104 (David) 沒有薪水信息，Salary 列為 NaN
# EmpID 105 (Eve) 有薪水但原始df_employees_indexed中沒有，所以Name和DepartmentID為NaN
# 注意：對于這種基于共同列的匹配連接，merge通常更直觀。

(4) 代碼注釋

① pd.merge(left_df, right_df, how='inner'/'left'/'right'/'outer', on='key_col', left_on='left_key', right_on='right_key'): 這是主要的合并函數。

left_df, right_df: 要合并的兩個DataFrame。
how: 指定合并方式(內、左、右、外連接)。默認為 'inner'。
on: 如果連接鍵在兩個DataFrame中名稱相同，可以用 on='key_col' 或 on=['key1', 'key2']。
left_on, right_on: 如果連接鍵在兩個DataFrame中名稱不同，需要分別指定。

② pd.concat([df1, df2, ...], axis=0/1, ignore_index=False, join='outer'/'inner'): 用于沿指定軸連接(堆疊)多個DataFrame。

axis=0: 按行堆疊(默認)。列名不匹配的列會用NaN填充(除非join='inner')。
axis=1: 按列并排連接。基于索引對齊。行索引不匹配的行會用NaN填充(除非join='inner')。
ignore_index=True: 創建新的連續整數索引，忽略原始索引。
join: 類似merge的how，'outer'保留所有標簽，'inner'只保留共有的標簽。默認為 'outer'。

總結

本文展示了Pandas在日常數據處理中最常用的一些功能。熟練掌握這些操作是進行任何數據分析項目的基礎。當然，Pandas的功能遠不止于此，還包括時間序列處理、數據重塑、數據可視化接口等，值得進一步深入探索。

責任編輯：趙寧寧來源： Python數智工坊

Pandas 數據分析數據處理