Python 與 pandas 讀碼：看懂程式片段在做什麼

拿到一段已經寫好的程式時，要能判斷它跑完手上是什麼。先固定兩個物件。

Series 是一維的一欄，自帶索引（index）。DataFrame 是二維表，多個 Series 並排，共用同一組列索引。shape 的順序是（列數, 欄數）。

import pandas as pd

s = pd.Series([10, 5, 3], index=['a', 'b', 'c'])
df = pd.DataFrame({'a': [10, 5, 3], 'b': [1, 2, 0]})
print(s.shape)
print(df.shape)

輸出長什麼樣：s.shape 是 (3,)，只有長度。df.shape 是 (3, 2)，3 列、2 欄。

大多數 pandas 操作回傳新物件，原表保持原樣。變數要指到新結果時，必須重新指定，例如 df = df.dropna()。

import pandas as pd

df = pd.DataFrame({'a': [10, None, 3]})
df2 = df.dropna()
print(df.shape)
print(df2.shape)

輸出長什麼樣：df.shape 仍是 (3, 1)，缺失還在。df2 是新表，3 列去掉 1 列缺失，df2.shape 是 (2, 1)。

方法串接（method chaining） 從左讀到右。每一步的輸出是下一步的輸入。讀的時候先寫下「現在是什麼型別、什麼形狀」，再看下一個點。型別若從 DataFrame 變成 Series，後面接得上的方法也跟著變。

import pandas as pd

df = pd.DataFrame({'a': [1, 5, 10, 3, 2]})
out = df[['a']].head(2)
print(out.shape)

輸出長什麼樣：df 是 (5, 1)。[['a']] 仍是 DataFrame，形狀還是 (5, 1)。head(2) 留下前 2 列，out.shape 是 (2, 1)。

head 不寫列數時取前 5 列；表不到 5 列就全部留下。shape 回傳（列數, 欄數）。info 把每一欄的型別與非空數印出來。describe 只對數值欄給 count、mean、std、min、25%、50%、75%、max；std 是標準差（standard deviation），50% 那一列是中位數（median）。這八列裡沒有眾數（mode）。include='all' 才把類別欄也放進結果。

import pandas as pd

df = pd.DataFrame({'sales': [10, 5, 3], 'city': ['N', 'S', 'N']})
print(df.shape)
print(df.head(2).shape)
df.info()
print(df.describe().index.tolist())
print(df.describe(include='all').columns.tolist())

輸出長什麼樣：shape 是 (3, 2)。head(2) 是 (2, 2) 的 DataFrame。info 印出 sales、city 的型別，非空數都是 3。describe() 的列名是那八個統計量，欄只有 sales。include='all' 的欄才同時有 sales 與 city。

df['a'] 回傳 Series。df[['a', 'b']] 多一層方括號，回傳 DataFrame，哪怕只點一欄也一樣。

loc 依標籤選，切片含終點。iloc 依位置選，切片不含終點。預設整數索引時，標籤剛好就是 0、1、2、…，所以兩種切片的差只剩「終點算不算」。標籤 0 到 2 含終點的個數是 2 - 0 + 1 = 3；位置 0 到 2 不含終點的個數是 2 - 0 = 2。

import pandas as pd

df = pd.DataFrame({'a': range(10), 'b': range(10)})
print(df['a'].shape)
print(df[['a']].shape)
print(df.loc[0:2].shape)
print(df.iloc[0:2].shape)

輸出長什麼樣：df['a'] 是 (10,) 的 Series。df[['a']] 是 (10, 1) 的 DataFrame。loc[0:2] 是 (3, 2)，3 列。iloc[0:2] 是 (2, 2)，2 列。

多條件用 &（且）、|（或）、~（非），每個條件各自加括號。Python 的 and／or 不能用來連接 Series：它們要求整條 Series 收成一個真假值，做不到，這一行會報錯。

另一個寫法 df['a'] > 5 & df['b'] == 'x' 也會錯。& 的優先順序高於比較運算，這行不會先做成兩個比較再取交集。

import pandas as pd

df = pd.DataFrame({'a': [10, 10, 3, 1], 'b': ['x', 'y', 'x', 'x']})
both = df[(df['a'] > 5) & (df['b'] == 'x')]
either = df[(df['a'] > 5) | (df['b'] == 'y')]
small = df[~(df['a'] > 5)]
print(both.shape, either.shape, small.shape)

輸出長什麼樣：a > 5 的是前兩列（值都是 10）；其中 b == 'x' 的只有第 1 列，所以 both 是 (1, 2)。either 含前兩列，是 (2, 2)。small 是後兩列（3 與 1），也是 (2, 2)。三個結果都是 DataFrame。

isna().sum() 給出每欄的缺失數，是一條以欄名為索引的 Series。dropna() 與 fillna(值) 都回傳新表。

astype('int64') 與 astype(int) 不能存 NaN，欄裡有缺失就會報錯。Int64（大寫 I）是可空整數（nullable integer），缺失留得住，其餘格子仍是整數。先 fillna(0) 再轉整數，缺失會變成 0；年齡欄裡就是 0 歲，缺失已經不在了。astype('category') 用來降低重複字串的記憶體，列數不變。

import pandas as pd

df = pd.DataFrame({'age': [10, None, 5], 'city': ['N', 'S', 'N']})
print(df.isna().sum())
print(df.dropna().shape)
filled = df.fillna(0)
age_ok = df['age'].astype('Int64')
df['city'] = df['city'].astype('category')
print(filled.shape)
print(age_ok.dtype)
print(df['city'].dtype)

輸出長什麼樣：isna().sum() 裡 age 的缺失數是 1，city 是 0。dropna() 是 (2, 2)，3 列去掉 1 列。fillna(0) 仍是 (3, 2)，缺的那一格變成 0，原表 df 沒被這兩行改掉。age_ok 的型別是 Int64，中間那一格仍是缺失。city 的型別是 category，還是 3 列。

pd.to_datetime 把時間字串收成時間型別。之後用 .dt.dayofweek 取星期，星期一為 0；用 .dt.hour 取小時。兩條都是與列數相同的整數 Series。

import pandas as pd

df = pd.DataFrame({'ts': ['2010-03-01 10:00:00', '2010-03-02 05:00:00']})
df['ts'] = pd.to_datetime(df['ts'])
print(df['ts'].dt.dayofweek.shape)
print(df['ts'].dt.hour.shape)

輸出長什麼樣：兩者都是 (2,)。列數與原表相同。

groupby 要拆開讀。df.groupby('region')['sales'].sum() 先分組、再取一欄、再加總，回傳以 region 為索引的 Series。.agg(['mean', 'count']) 點了兩個彙總，回傳 DataFrame，欄數等於函數個數。.sort_values(ascending=False) 讓數值大的排前面。.head(3) 切的是列，不是欄。nlargest(3, 'sales') 不先加總，直接從原表取該欄最大的 3 列，所以仍是 DataFrame。value_counts() 算各值次數，預設由多到少，回傳 Series。

import pandas as pd

df = pd.DataFrame({
    'region': ['N', 'N', 'S', 'E', 'W'],
    'sales': [10, 5, 3, 1, 2],
})
s = df.groupby('region')['sales'].sum()
t = df.groupby('region')['sales'].agg(['mean', 'count'])
top = s.sort_values(ascending=False).head(3)
big = df.nlargest(3, 'sales')
print(s.shape, t.shape, top.shape, big.shape)
print(top.index.tolist())
print(pd.Series(['x', 'x', 'x', 'y']).value_counts().index.tolist())

輸出長什麼樣：5 列裡 N 出現兩次，分組後是 4 個區域，所以 s.shape 是 (4,)，t.shape 是 (4, 2)。N 的總額是 10 + 5 = 15，其後是 S 的 3、W 的 2、E 的 1；top 取前 3 個，索引是 N、S、W，top.shape 是 (3,)。big 是原表裡 10、5、3 那 3 列，shape 是 (3, 2)，裡面會有兩列 N。value_counts 的索引先是 x（3 次）再是 y（1 次）。

merge 的 how='left' 保留左表全部列，右表對不到的欄是 NaN。how='inner' 只留兩邊都有的鍵。pd.concat([df1, df2]) 上下堆疊，列數相加，欄仍是原來的欄。

import pandas as pd

orders = pd.DataFrame({'user_id': [1, 2, 3, 5, 10], 'amt': [10, 5, 3, 1, 2]})
users = pd.DataFrame({'user_id': [1, 2], 'city': ['N', 'S']})
left = pd.merge(orders, users, on='user_id', how='left')
inner = pd.merge(orders, users, on='user_id', how='inner')
stacked = pd.concat([
    pd.DataFrame({'a': [1, 2]}),
    pd.DataFrame({'a': [3, 5]}),
])
print(left.shape, inner.shape, stacked.shape)

輸出長什麼樣：訂單 5 列，其中 user_id 為 3、5、10 的 3 列不在 users。left.shape 是 (5, 3)，這 3 列的 city 是 NaN。inner 只留對得到的 2 列，5 - 3 = 2，inner.shape 是 (2, 3)。stacked 是 2 + 2 = 4 列、1 欄，(4, 1)。merge 與 concat 都回傳新表，users 的列數不會被改寫。

melt 把寬表轉成長表：欄名收成一欄的值。pivot_table 反向，長表轉寬表，並依 aggfunc 聚合。seaborn 多數繪圖函式偏好長表，也就是一列一筆、類別放在同一欄。

import pandas as pd

wide = pd.DataFrame({
    'store': ['A', 'B'],
    'Jan': [10, 5],
    'Feb': [3, 1],
    'Mar': [2, 0],
})
long = pd.melt(
    wide,
    id_vars=['store'],
    value_vars=['Jan', 'Feb', 'Mar'],
    var_name='month',
    value_name='sales',
)
back = long.pivot_table(index='store', columns='month', values='sales', aggfunc='sum')
print(long.shape, back.shape)

輸出長什麼樣：2 家店 × 3 個月 = 6 列，加上 store、month、sales 三欄，long.shape 是 (6, 3)。轉回去後一列一家店、一個月一欄，back.shape 是 (2, 3)。

map 用字典逐元素換值；指定回 df['b'] 時，這一次會改到 df，因為寫了指定。np.where(條件, 真值, 假值) 對整欄做二選一。apply(func, axis=1) 逐列跑，比較慢；同一件事能寫成整欄運算時，就用整欄運算。

import numpy as np
import pandas as pd

df = pd.DataFrame({'a': ['M', 'F', 'M']})
df['b'] = df['a'].map({'M': 0, 'F': 1})
num = pd.DataFrame({'a': [1, -1, 0]})
num['sign'] = np.where(num['a'] > 0, '正', '負')
num['by_apply'] = num.apply(lambda r: r['a'] + 1, axis=1)
print(df['b'].tolist())
print(num['sign'].tolist())
print(num['by_apply'].tolist())

輸出長什麼樣：b 是 [0, 1, 0]，df 變成 (3, 2)。sign 是 ['正', '負', '負']，0 不大於 0，所以落在「負」。by_apply 是 [2, 0, 1]，也就是 1 + 1、-1 + 1、0 + 1；同一結果可寫成 num['a'] + 1。

檔案大於記憶體時，pd.read_csv(..., chunksize=1_000_000) 回傳可迭代的分塊讀取器，一次交一塊。chunksize 要配 usecols（只讀需要的欄）與 dtype（指定較小的型別）。每一塊自己是 DataFrame。

import pandas as pd

reader = pd.read_csv(
    'big.csv',
    chunksize=1_000_000,
    usecols=['region', 'sales'],
    dtype={'region': 'category'},
)
for chunk in reader:
    block_total = chunk['sales'].sum()

輸出長什麼樣：reader 不是一張已裝好的大表。迴圈裡的 chunk 最多 1,000,000 列、2 欄；block_total 是這一塊的銷售合計，一個數。

pd.get_dummies(df, columns=['city']) 把指定欄拆成 One-Hot 欄位，每個不同的值一個 0/1 欄。

import pandas as pd

df = pd.DataFrame({'city': ['N', 'S', 'N']})
out = pd.get_dummies(df, columns=['city'])
print(out.shape)

輸出長什麼樣：3 列不變，city 換成 2 個 0/1 欄，shape 是 (3, 2)。N 所在的列，對應欄為 1、另一欄為 0。

seaborn 這幾個函式看的是圖種與資料形狀。histplot 看一個數值欄的分佈。boxplot 看各組的分佈，x 是組別、y 是數值。scatterplot 一列一個點。countplot 畫類別次數，高度對應次數，回傳的是圖。heatmap 吃的是矩陣：df.corr(numeric_only=True) 只留數值欄，做成相關矩陣，annot=True 把係數寫進格子，vmin=-1、vmax=1 把顏色範圍定在 -1 到 1。

import pandas as pd
import seaborn as sns

df = pd.DataFrame({
    'a': [1, 2, 3, 5, 10],
    'b': [10, 5, 3, 2, 1],
    'group': ['x', 'x', 'y', 'y', 'x'],
    'value': [1, 3, 5, 2, 10],
    'cat': ['x', 'y', 'x', 'x', 'y'],
})
sns.histplot(df, x='a')
sns.boxplot(data=df, x='group', y='value')
sns.scatterplot(data=df, x='a', y='b')
sns.countplot(data=df, x='cat')
sns.heatmap(df.corr(numeric_only=True), annot=True, cmap='coolwarm', vmin=-1, vmax=1)

輸出長什麼樣：每個呼叫畫一種圖；像這樣連續寫在同一段時，它們會疊在同一張畫布上，實務上會各自開一張圖（例如每次先 plt.figure()）。散佈圖有 5 個點。cat 裡 x 有 3 列、y 有 2 列，次數圖就是這兩根長條。corr 排除 group 與 cat，剩下 a、b、value，熱圖是 3×3。

scikit-learn 的片段先看左邊接到哪四個變數。train_test_split 的順序是訓練集的 X、測試集的 X、訓練集的 y、測試集的 y。test_size=0.2 是測試集所佔的列比例，stratify=y 讓兩邊的類別比例跟原資料一樣，random_state=42 把抽取固定下來。

import pandas as pd
from sklearn.model_selection import train_test_split

df = pd.DataFrame({
    'a': [1, 2, 3, 5, 10, 1, 2, 3, 5, 10],
    'y': [0, 0, 0, 0, 0, 1, 1, 1, 1, 1],
})
X = df[['a']]
y = df['y']
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=42
)
print(len(X_train), len(X_test))

輸出長什麼樣：10 列 × 0.2 = 2 列進測試集，訓練集是 10 - 2 = 8 列。y 兩類各 10 / 2 = 5 列；比例要保持，測試集 2 列就是一類 1 列，訓練集每類剩 5 - 1 = 4 列。X 用雙層方括號，所以 X_train 仍是 DataFrame。

縮放器接在切分之後。fit_transform 用訓練集計算參數並轉換訓練集；transform 用同一組參數轉換測試集，不再重算。

X_train_s = scaler.fit_transform(X_train)
X_test_s = scaler.transform(X_test)

輸出長什麼樣：兩行都是縮放後的訓練特徵與測試特徵，列數分別跟 X_train、X_test 相同。參數來自訓練集那一次 fit。測試集若改呼叫 fit_transform，參數會改用測試集重算，兩邊的尺度基準就不同了。