pandas로 자료 다루기¶

"""표를 만들어 크기·자료형·요약통계를 훑어보는 첫 단계를 보인다."""
import numpy as np
import pandas as pd

# 실제 작업에서는 df = pd.read_csv("data.csv")로 파일을 읽는다.
# 여기서는 결과를 바로 볼 수 있도록 작은 표를 직접 만든다.
rng = np.random.default_rng(0)
n = 12
demo = pd.DataFrame({
    "treatment": rng.choice(["control", "drug"], size=n),
    "x": rng.normal(10, 2, size=n).round(2),
    "outcome": rng.normal(50, 8, size=n).round(1),
})
demo.loc[[2, 7], "x"] = np.nan        # 결측값 두 개를 일부러 넣는다

print(demo.head())        # 앞 다섯 행
print(demo.shape)         # (행 수, 열 수)
print(demo.dtypes)        # 열마다의 자료형
print(demo.describe().round(2))   # 개수·평균·표준편차·최솟값·사분위수·최댓값

  treatment      x  outcome
0      drug  12.61     53.3
1      drug  11.89     58.3
2      drug    NaN     49.0
3   control   7.47     60.9
4   control   8.75     44.7
(12, 3)
treatment     object
x            float64
outcome      float64
dtype: object
           x  outcome
count  10.00    12.00
mean    9.05    50.98
std     2.13     5.90
min     5.35    42.60
25%     7.77    45.90
50%     8.83    51.30
75%     9.90    54.28
max    12.61    60.90

print(demo.isna().sum())              # 열마다 결측이 몇 개인지
print(len(demo.dropna()))             # 결측이 하나라도 있는 행을 버린다
print(len(demo.dropna(subset=["x"]))) # x 의 결측만 기준으로 버린다

# 중앙값으로 메우면 평균보다 이상치에 덜 흔들린다. 다만 메운 값에는
# 불확실성이 없는 것처럼 되므로 이후 표준오차가 과소추정된다.
filled = demo.fillna(demo.median(numeric_only=True))
print(filled["x"].isna().sum(), filled["x"].median())

# 메우기가 퍼짐에 무슨 일을 하는지 수로 본다.
print(f"메우기 전: n = {demo['x'].count()}, 평균 = {demo['x'].mean():.4f}, "
      f"s = {demo['x'].std():.4f}, SE = {demo['x'].sem():.4f}")
print(f"메운  뒤: n = {filled['x'].count()}, 평균 = {filled['x'].mean():.4f}, "
      f"s = {filled['x'].std():.4f}, SE = {filled['x'].sem():.4f}")

treatment    0
x            2
outcome      0
dtype: int64
10
10
0 8.83
메우기 전: n = 10, 평균 = 9.0480, s = 2.1299, SE = 0.6735
메운  뒤: n = 12, 평균 = 9.0117, s = 1.9285, SE = 0.5567

# 분할(treatment 로 나누고) — 적용(집계 함수를 걸고) — 결합(하나의 표로 모은다)
summary = demo.groupby("treatment")["outcome"].agg(["count", "mean", "std"]).round(2)
print(summary)

# 두 집단 평균의 차이를 그 표준오차와 견주어 본다.
diff = summary.loc["control", "mean"] - summary.loc["drug", "mean"]
se = np.sqrt(summary.loc["control", "std"] ** 2 / 6 + summary.loc["drug", "std"] ** 2 / 6)
print(f"차이 = {diff:.2f}, SE = {se:.2f}, 차이/SE = {diff / se:.2f}")

# agg 는 그룹당 한 행으로 줄이고, transform 은 원래 행 수를 그대로 돌려준다.
centered = demo["outcome"] - demo.groupby("treatment")["outcome"].transform("mean")
print(f"agg 행 수 = {len(summary)}, transform 행 수 = {len(centered)}, 원래 행 수 = {len(demo)}")

# 행 수가 같으니 transform 결과는 원래 표에 열로 바로 붙는다.
print(demo.assign(centered=centered.round(2))[["treatment", "outcome", "centered"]].head(3))

           count   mean   std
treatment
control        6  51.75  6.69
drug           6  50.22  5.52
차이 = 1.53, SE = 3.54, 차이/SE = 0.43
agg 행 수 = 2, transform 행 수 = 12, 원래 행 수 = 12
  treatment  outcome  centered
0      drug     53.3      3.08
1      drug     58.3      8.08
2      drug     49.0     -1.22

import math

import numpy as np
import pandas as pd

rng = np.random.default_rng(42)

# 범주형과 수치형을 섞은 자료틀을 만든다
df = pd.DataFrame({
    "group": rng.choice(["A", "B", "C"], size=200),
    "value": rng.normal(50, 10, size=200),
    "score": rng.integers(0, 100, size=200),
})

# 집단별 요약
summary = df.groupby("group")["value"].agg(["count", "mean", "std"]).round(2)
print(summary)

# 집단 평균이 참값 50 에서 벗어난 폭을 표준오차 10/sqrt(n) 로 나누어 본다.
z = (summary["mean"] - 50) / (10 / np.sqrt(summary["count"]))
print("\n(집단평균 - 50) / SE:")
print(z.round(2))

# 불리언으로 걸러내기. P(X > 60) = P(Z > 1) 이므로 기대 개수를 함께 적는다.
high = df[df["value"] > 60]
p_tail = math.erfc(1 / math.sqrt(2)) / 2
print(f"\n60 초과: {len(high)} / {len(df)}  (이론 기대 {200 * p_tail:.1f})")

# 수치형 열 사이의 상관. 두 열을 독립으로 만들었으므로 참 상관은 0 이다.
print("\n상관행렬:")
print(df.corr(numeric_only=True).round(3))
r = df["value"].corr(df["score"])
t = r * np.sqrt((len(df) - 2) / (1 - r ** 2))
print(f"r = {r:.3f},  t = {t:.2f}  (자유도 198)")

# 피벗: 집단과 점수 사분위별 평균
df["score_q"] = pd.qcut(df["score"], 4, labels=["Q1", "Q2", "Q3", "Q4"])
print("\n피벗 — 칸마다의 평균:")
print(df.pivot_table(values="value", index="group", columns="score_q",
                     aggfunc="mean", observed=False).round(1))
print("\n피벗 — 칸마다의 개수:")
print(df.pivot_table(values="value", index="group", columns="score_q",
                     aggfunc="count", observed=False))

       count   mean    std
group
A         58  50.17  10.20
B         72  49.72   9.83
C         70  49.24   9.98

(집단평균 - 50) / SE:
group
A    0.13
B   -0.24
C   -0.64
dtype: float64

60 초과: 31 / 200  (이론 기대 31.7)

상관행렬:
       value  score
value  1.000 -0.111
score -0.111  1.000
r = -0.111,  t = -1.56  (자유도 198)

피벗 — 칸마다의 평균:
score_q    Q1    Q2    Q3    Q4
group
A        55.4  50.1  48.6  46.9
B        50.5  53.6  48.0  48.0
C        48.8  48.0  50.1  50.0

피벗 — 칸마다의 개수:
score_q  Q1  Q2  Q3  Q4
group
A        12  19  16  11
B        23  12  19  18
C        15  19  16  20

import pandas as pd
df = pd.DataFrame({
    "name":   ["Alice", "Bob", "Carol", "Dave", "Eve"],
    "score":  [92, 65, 88, 73, 95],
    "passed": [True, False, True, False, True],
})
print(df[df["passed"] & (df["score"] > 80)])

    name  score  passed
0  Alice     92    True
2  Carol     88    True
4    Eve     95    True

summary = df.groupby("group")["x"].agg(
    n="count",
    mean="mean",
    var="var",
    range=lambda s: s.max() - s.min(),
)
print(summary)

       n  mean  var  range
group
A      2   2.0  2.0      2
B      3   5.0  9.0      6

df = pd.DataFrame({"A": [10, 20, 30]}, index=[2, 0, 1])
print(df.loc[0])    # row labeled 0   → A = 20
print(df.iloc[0])   # row at position 0 → A = 10

A    20
Name: 0, dtype: int64
A    10
Name: 2, dtype: int64

from io import StringIO
csv = """x,y,z
1.0,2.0,3.0
2.0,,4.0
3.0,6.0,
4.0,8.0,6.0
5.0,10.0,7.0"""

df = pd.read_csv(StringIO(csv))
df = df.fillna(df.median(numeric_only=True))
print(df.corr().round(3))

       x      y      z
x  1.000  0.906  1.000
y  0.906  1.000  0.906
z  1.000  0.906  1.000

import numpy as np
import pandas as pd
s = pd.Series([2, 4, 4, 4, 5])
print("pandas s.var()  :", s.var())            # ddof=1, divides by n-1=4
print("numpy  np.var() :", np.var(s.values))   # ddof=0, divides by n=5

pandas s.var()  : 1.2
numpy  np.var() : 0.96

import pandas as pd

df1 = pd.DataFrame({"id": [1, 2, 3, 4], "x": [10, 20, 30, 40]})
df2 = pd.DataFrame({"id": [2, 3, 5], "y": ["b", "c", "e"]})

assert df2["id"].is_unique, "right-side join key not unique — row count will inflate"
merged = df1.merge(df2, on="id", how="left", indicator=True)
print(merged)
print(merged["_merge"].value_counts())   # left_only / both / right_only

   id   x    y     _merge
0   1  10  NaN  left_only
1   2  20    b       both
2   3  30    c       both
3   4  40  NaN  left_only
_merge
left_only     2
both          2
right_only    0
Name: count, dtype: int64

import pandas as pd
import warnings

df = pd.DataFrame({"g": ["a", "a", "b"], "x": [1., 2., 3.]})

with warnings.catch_warnings(record=True) as caught:
    warnings.simplefilter("always")
    sub = df[df.g == "a"]        # 걸러낸 결과 — 복사본일 수도, 뷰일 수도
    sub["x"] = 0                 # 여기서 경고
    print("발생한 경고:", [w.category.__name__ for w in caught])

print("\n원본은 바뀌지 않았다:")
print(df.to_string(index=False))

발생한 경고: ['SettingWithCopyWarning']

원본은 바뀌지 않았다:
g   x
a 1.0
a 2.0
b 3.0

import pandas as pd

df = pd.DataFrame({"g": ["a", "a", "b"], "x": [1., 2., 3.]})

# (1) 원본을 정말로 고치려는 경우 — .loc 으로 한 번에
df.loc[df.g == "a", "x"] = 0
print("원본을 고친 경우:")
print(df.to_string(index=False))

# (2) 부분집합만 따로 다루려는 경우 — 복사본임을 명시
df2 = pd.DataFrame({"g": ["a", "a", "b"], "x": [1., 2., 3.]})
sub = df2[df2.g == "a"].copy()
sub["x"] = 0
print("\n복사본을 고친 경우 — 원본은 그대로:")
print(df2.to_string(index=False))

원본을 고친 경우:
g   x
a 0.0
a 0.0
b 3.0

복사본을 고친 경우 — 원본은 그대로:
g   x
a 1.0
a 2.0
b 3.0

import pandas as pd

df = pd.DataFrame(
    [("A", "작은 결석",  81,  87),
     ("A", "큰 결석",   192, 263),
     ("B", "작은 결석", 234, 270),
     ("B", "큰 결석",    55,  80)],
    columns=["치료법", "결석 크기", "성공", "전체"])
df["성공률"] = df["성공"] / df["전체"]

print("층별 성공률")
print(df.to_string(index=False))

total = df.groupby("치료법")[["성공", "전체"]].sum()
total["성공률"] = total["성공"] / total["전체"]
print("\n전체 성공률")
print(total.to_string())

층별 성공률
치료법 결석 크기  성공  전체      성공률
  A 작은 결석  81  87 0.931034
  A  큰 결석 192 263 0.730038
  B 작은 결석 234 270 0.866667
  B  큰 결석  55  80 0.687500

전체 성공률
      성공   전체       성공률
치료법
A    273  350  0.780000
B    289  350  0.825714

import pandas as pd

d = pd.DataFrame({"g": list("aabbb"), "x": [1., 3., 2., 8., 5.]})

print("agg — 그룹당 한 행:")
print(d.groupby("g")["x"].agg(["mean", "std"]).to_string())

d["z"] = d.groupby("g")["x"].transform(lambda s: (s - s.mean()) / s.std(ddof=1))
print("\ntransform — 원래 행 수를 유지하며 그룹별로 표준화:")
print(d.to_string(index=False))

agg — 그룹당 한 행:
   mean       std
g
a   2.0  1.414214
b   5.0  3.000000

transform — 원래 행 수를 유지하며 그룹별로 표준화:
g   x         z
a 1.0 -0.707107
a 3.0  0.707107
b 2.0 -1.000000
b 8.0  1.000000
b 5.0  0.000000

import numpy as np
import pandas as pd

wide = pd.DataFrame({"id": [1, 2, 3],
                     "t0": [5., 6., 7.],
                     "t1": [6., 8., 7.],
                     "t2": [9., 9., 8.]})
print("넓은 형식 — 시점마다 열 하나")
print(wide.to_string(index=False))

long = wide.melt(id_vars="id", var_name="시점", value_name="측정")
print(f"\n긴 형식 — 관측마다 행 하나  {wide.shape} → {long.shape}")
print(long.to_string(index=False))

back = long.pivot(index="id", columns="시점", values="측정")
print(f"\n되돌리기 성공: {np.allclose(back.values, wide.set_index('id').values)}")

넓은 형식 — 시점마다 열 하나
 id  t0  t1  t2
  1 5.0 6.0 9.0
  2 6.0 8.0 9.0
  3 7.0 7.0 8.0

긴 형식 — 관측마다 행 하나  (3, 4) → (9, 3)
 id 시점  측정
  1 t0 5.0
  2 t0 6.0
  3 t0 7.0
  1 t1 6.0
  2 t1 8.0
  3 t1 7.0
  1 t2 9.0
  2 t2 9.0
  3 t2 8.0

되돌리기 성공: True

import numpy as np
import pandas as pd

s = pd.Series([1., np.nan, 3.])
print(f"NaN == NaN 인가: {np.nan == np.nan}")
print(f"count {s.count()}   mean {s.mean()}   sum {s.sum()}   (결측을 건너뛴다)")
print(f"mean(skipna=False): {s.mean(skipna=False)}")

all_nan = pd.Series([np.nan, np.nan])
print(f"\n전부 결측일 때  sum = {all_nan.sum()}   mean = {all_nan.mean()}")

g = pd.DataFrame({"k": ["a", None, "a"], "v": [1., 2., 3.]})
print(f"\ngroupby 기본값(dropna=True):\n{g.groupby('k')['v'].sum().to_string()}")
print(f"\ngroupby(dropna=False):\n{g.groupby('k', dropna=False)['v'].sum().to_string()}")

NaN == NaN 인가: False
count 2   mean 2.0   sum 4.0   (결측을 건너뛴다)
mean(skipna=False): nan

전부 결측일 때  sum = 0.0   mean = nan

groupby 기본값(dropna=True):
k
a    4.0

groupby(dropna=False):
k
a      4.0
NaN    2.0

import numpy as np
import pandas as pd

rng = np.random.default_rng(0)
s = pd.Series(rng.choice(["서울", "부산", "대구"], 100_000))

mb_object = s.memory_usage(deep=True) / 1e6
mb_category = s.astype("category").memory_usage(deep=True) / 1e6
print(f"object   {mb_object:.3f} MB")
print(f"category {mb_category:.3f} MB   ({mb_object / mb_category:.0f}배 절약)")

object   7.000 MB
category 0.100 MB   (70배 절약)