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

# ---- 1. 數(shù)據(jù)加載 ----
# 假設的CSV數(shù)據(jù)內(nèi)容 (如果在本地有文件，請使用 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 在內(nèi)存中模擬一個CSV文件對象
# 然后使用 pandas 讀取這個模擬文件
# 如果有實際文件 'students.csv'，直接用 df = pd.read_csv('students.csv') 即可
df = pd.read_csv(io.StringIO(csv_data))

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


# ---- 2. 數(shù)據(jù)基本查看 ----

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

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

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

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

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

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

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

# 繼續(xù)使用上一個案例創(chuàng)建的 df

print("--- 原始數(shù)據(jù) ---")
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在選擇行時表現(xiàn)類似
print("\n--- 使用 loc 選擇索引為 1 的行 ---")
row_1_loc = df.loc[1] # 索引標簽為 1
print(row_1_loc)

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

# 選擇連續(xù)多行
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)

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

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

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

# ---- 1. 創(chuàng)建包含缺失值的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("--- 包含缺失值的原始數(shù)據(jù) ---")
print(df_nan)

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

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

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

# 統(tǒng)計總的缺失值數(shù)量
print("\n--- 統(tǒng)計總?cè)笔е禂?shù)量 ---")
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 列 (例如用中位數(shù))
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)

import pandas as pd

# 銷售數(shù)據(jù)
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("--- 原始銷售數(shù)據(jù) ---")
print(df_sales)

# 繼續(xù)使用上面創(chuàng)建的 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' 分組，計算每個類別的平均銷售額和總數(shù)量
# 如果對分組后的對象直接調(diào)用聚合函數(shù)，會對所有數(shù)值列進行計算
print("\n--- 按 Category 分組計算所有數(shù)值列的均值 (mean) ---")
category_mean = df_sales.groupby('Category').mean() # 計算 Sales 和 Quantity 的均值
print(category_mean)
print(type(category_mean)) # 返回 DataFrame

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

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

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


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

# 對不同列應用不同的聚合函數(shù)，或者對同一列應用多個聚合函數(shù)
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')     # 計算每個類別有多少個產(chǎn)品記錄
)
print(agg_results)

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

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)

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

# 內(nèi)連接 (Inner Join): 只保留兩個DataFrame中鍵都存在的行
# 需要指定左右DataFrame的連接鍵 (left_on, right_on)
print("\n--- 內(nèi)連接 (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'             # 連接方式為內(nèi)連接
)
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) - 通常需要索引對齊
# 創(chuàng)建一個基于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通常更直觀。