{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ch03-000",
   "metadata": {},
   "source": [
    "# 03장 실습. 표 데이터 다루기: pandas\n",
    "\n",
    "**목표:** 이름표와 위치를 구분하고, 결측·범주를 처리하고, 표를 묶고 합쳐서 모델에 넣을 숫자 표를 만든다. 그 과정에서 오류 없이 틀리는 함정을 점검으로 확인한다.\n",
    "\n",
    "- 빈칸(`# 작성하세요`)을 채우고 바로 아래 점검 셀을 실행하면 \"통과\"가 나온다.\n",
    "- 함수 문제는 **입력 표를 바꾸지 않고** 새 표를 돌려준다. 점검 셀이 입력이 바뀌었는지도 본다.\n",
    "- 막히면 `힌트`를 연다. 다 푼 뒤 `실습/해설/`의 같은 파일과 비교한다.\n",
    "- 끝나면 **커널 재시작 후 모두 실행**(Restart & Run All)으로 처음부터 통과하는지 확인한다.\n",
    "\n",
    "권장 시간: 1시간 30분. 내려받기 없이 CPU로 1분 안에 끝난다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch03-001",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "import hashlib\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.rcParams[\"font.family\"] = \"Malgun Gothic\"     # Windows 한글 글꼴\n",
    "plt.rcParams[\"axes.unicode_minus\"] = False\n",
    "\n",
    "def check(name, value, digest):\n",
    "    assert value is not None, f\"{name}: 답을 적으세요\"\n",
    "    got = hashlib.sha256(str(value).strip().upper().encode()).hexdigest()[:12]\n",
    "    assert got == digest, f\"{name}: 다시 생각해 보세요\"\n",
    "    print(name, \"통과\")\n",
    "\n",
    "# 가상의 쇼핑몰 데이터: 고객 300명, 주문 2000건\n",
    "rng = np.random.default_rng(0)\n",
    "n = 300\n",
    "customers = pd.DataFrame({\n",
    "    \"고객ID\": np.arange(1001, 1001 + n),\n",
    "    \"도시\": rng.choice([\"서울\", \"부산\", \"대구\", \"인천\", \"광주\"], size=n, p=[0.4, 0.2, 0.15, 0.15, 0.1]),\n",
    "    \"등급\": rng.choice([\"브론즈\", \"실버\", \"골드\"], size=n, p=[0.5, 0.35, 0.15]),\n",
    "    \"나이\": rng.integers(20, 70, size=n).astype(float),\n",
    "    \"방문수\": rng.poisson(12, size=n),\n",
    "})\n",
    "customers.loc[rng.random(n) < 0.12, \"나이\"] = np.nan\n",
    "\n",
    "# 고객 표 원본: 주소를 바꾼 고객 8명이 새 줄로 한 번 더 들어 있다(아래쪽 줄이 최신)\n",
    "moved = customers.sample(8, random_state=1).copy()\n",
    "moved[\"도시\"] = np.where(moved[\"도시\"] == \"서울\", \"부산\", \"서울\")\n",
    "customers_raw = pd.concat([customers, moved], ignore_index=True)\n",
    "\n",
    "m = 2000\n",
    "orders = pd.DataFrame({\n",
    "    \"주문ID\": np.arange(1, m + 1),\n",
    "    \"고객ID\": rng.choice(np.r_[customers[\"고객ID\"].to_numpy(), [9001, 9002, 9003]], size=m),\n",
    "    \"금액\": (rng.lognormal(mean=9.8, sigma=0.5, size=m) // 100 * 100).astype(int),\n",
    "})\n",
    "orders.loc[[17, 640, 1500], \"금액\"] = [2_500_000, 1_800_000, 3_000_000]   # 큰 주문 몇 건\n",
    "\n",
    "print(\"customers\", customers.shape, \"/ customers_raw\", customers_raw.shape, \"/ orders\", orders.shape)\n",
    "print(customers.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch03-002",
   "metadata": {},
   "source": [
    "## 문제 1. 이름표와 위치 (개념)\n",
    "\n",
    "```python\n",
    "t = pd.DataFrame({\"점수\": [70, 95, 80, 60, 85]})      # index 0~4\n",
    "top = t.sort_values(\"점수\", ascending=False)\n",
    "```\n",
    "\n",
    "아래 결과를 **실행하지 말고** 예측해 (a)~(f) 순서대로 리스트 `q1`에 적으세요. 리스트 결과는 리스트로 적습니다.\n",
    "\n",
    "(a) `top.loc[0, \"점수\"]`\n",
    "(b) `top[\"점수\"].iloc[0]`\n",
    "(c) `top.loc[1:2, \"점수\"].tolist()`\n",
    "(d) `top[\"점수\"].iloc[1:2].tolist()`\n",
    "(e) `top[\"점수\"].idxmin()`\n",
    "(f) `top[\"점수\"].argmin()`\n",
    "\n",
    "예: `q1 = [1, 2, [3, 4], [5], 6, 7]`\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "먼저 `top`의 행 순서와 각 행의 이름표를 종이에 적으세요. `loc` 슬라이스는 **지금 순서에서** 이름표 1이 있는 곳부터 이름표 2가 있는 곳까지(끝 포함)입니다. `idx…`는 이름표, `arg…`는 위치를 줍니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch03-003",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "q1 = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch03-004",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q1\", q1, \"09b9207d3436\")\n",
    "t = pd.DataFrame({\"점수\": [70, 95, 80, 60, 85]})\n",
    "top = t.sort_values(\"점수\", ascending=False)\n",
    "print(top)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch03-005",
   "metadata": {},
   "source": [
    "## 문제 2. 조건 필터와 대입 (코드)\n",
    "\n",
    "두 함수를 쓰세요. 둘 다 **입력 표를 바꾸지 않습니다.**\n",
    "\n",
    "1. `select_targets(df)`: 도시가 서울 또는 부산이고 방문수가 10 이상 20 이하인 고객의 `[\"고객ID\", \"도시\", \"방문수\"]` 열. 방문수가 많은 순, 같으면 고객ID가 작은 순으로 정렬하고 index는 0부터 다시 매깁니다.\n",
    "2. `give_coupon(df)`: `df`의 복사본에 `쿠폰` 열을 더해 돌려줍니다. 기본 0, 등급이 골드**이거나** 방문수가 25 이상이면 3000.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "조건마다 괄호, `isin`, `between`. 정렬은 `sort_values([\"방문수\", \"고객ID\"], ascending=[False, True])`, 다시 매기기는 `reset_index(drop=True)`. 대입은 `out.loc[조건, \"쿠폰\"] = 3000` 한 번으로 씁니다. `out[조건][\"쿠폰\"] = 3000`은 원본을 바꾸지 않습니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch03-006",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def select_targets(df):\n",
    "    pass   # 작성\n",
    "\n",
    "def give_coupon(df):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch03-007",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "before = customers.copy()\n",
    "shuffled = customers.sample(frac=1, random_state=2)                # 섞은 표를 넣어 본다\n",
    "shuffled_before = shuffled.copy()\n",
    "sel = select_targets(shuffled)\n",
    "assert sel is not None, \"select_targets: 결과를 return 하세요\"\n",
    "assert shuffled.equals(shuffled_before), \"입력 표가 바뀌었습니다(inplace=True 등을 쓰지 마세요)\"\n",
    "assert list(sel.columns) == [\"고객ID\", \"도시\", \"방문수\"], f\"열이 {list(sel.columns)}입니다\"\n",
    "assert set(sel[\"도시\"]) <= {\"서울\", \"부산\"}, \"서울·부산 외 도시가 있습니다\"\n",
    "assert sel[\"방문수\"].between(10, 20).all(), \"방문수 10~20 밖의 행이 있습니다(between은 양 끝 포함)\"\n",
    "ref = customers[customers[\"도시\"].isin([\"서울\", \"부산\"]) & customers[\"방문수\"].between(10, 20)]\n",
    "assert len(sel) == len(ref), f\"행 수가 {len(sel)}입니다. {len(ref)}여야 합니다\"\n",
    "assert list(sel.index) == list(range(len(sel))), \"index를 0부터 다시 매기세요\"\n",
    "key = list(zip(-sel[\"방문수\"], sel[\"고객ID\"]))\n",
    "assert key == sorted(key), \"정렬이 다릅니다. 방문수 내림차순, 같으면 고객ID 오름차순\"\n",
    "\n",
    "cp = give_coupon(customers)\n",
    "assert cp is not None, \"give_coupon: 결과를 return 하세요\"\n",
    "assert customers.equals(before), \"입력 표가 바뀌었습니다. 복사본에 열을 더하세요\"\n",
    "assert \"쿠폰\" in cp.columns, \"쿠폰 열이 없습니다\"\n",
    "want = np.where((customers[\"등급\"] == \"골드\") | (customers[\"방문수\"] >= 25), 3000, 0)\n",
    "assert (cp[\"쿠폰\"].to_numpy() == want).all(), \"쿠폰 값이 다릅니다. 연쇄 대입(out[조건][\\\"쿠폰\\\"] = ...)은 값을 바꾸지 않습니다\"\n",
    "print(sel.head(), \"\\n쿠폰 대상\", int((cp[\"쿠폰\"] > 0).sum()), \"명\")\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch03-008",
   "metadata": {},
   "source": [
    "## 문제 3. 결측 채우기는 훈련 기준으로 (코드)\n",
    "\n",
    "`fill_age(train, test)`를 쓰세요. `(train_결과, test_결과)` 두 표를 돌려줍니다.\n",
    "\n",
    "- 두 표 모두 `나이_결측` 열(결측이면 1, 아니면 0, 정수)을 더합니다.\n",
    "- 두 표 모두 `나이`의 결측을 **train의 나이 중앙값**으로 채웁니다.\n",
    "- 입력 표는 바꾸지 않습니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "결측 표시를 **먼저** 만들고 나서 채워야 합니다. 채운 뒤에는 결측이 없으니까요. 중앙값은 `train[\"나이\"].median()` 한 번만 구합니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch03-009",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def fill_age(train, test):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch03-010",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "tr = pd.DataFrame({\"나이\": [20, np.nan, 30, 70]})\n",
    "te = pd.DataFrame({\"나이\": [np.nan, 70, 80]})            # 훈련 중앙값 30, 훈련 평균 40, 테스트 중앙값 75\n",
    "tr0, te0 = tr.copy(), te.copy()\n",
    "res = fill_age(tr, te)\n",
    "assert res is not None, \"결과를 return 하세요\"\n",
    "a, b = res\n",
    "assert tr.equals(tr0) and te.equals(te0), \"입력 표가 바뀌었습니다\"\n",
    "assert \"나이_결측\" in a.columns and \"나이_결측\" in b.columns, \"나이_결측 열이 없습니다\"\n",
    "assert a[\"나이_결측\"].tolist() == [0, 1, 0, 0] and b[\"나이_결측\"].tolist() == [1, 0, 0], \"결측 표시가 다릅니다. 채우기 전에 만들었나요?\"\n",
    "assert pd.api.types.is_integer_dtype(b[\"나이_결측\"]), \"나이_결측은 정수(astype(int))로 만드세요\"\n",
    "assert b[\"나이\"].tolist()[0] == 30, f\"테스트 결측을 {b['나이'].tolist()[0]}로 채웠습니다. 훈련 중앙값(30)이어야 합니다\"\n",
    "assert a[\"나이\"].tolist() == [20, 30, 30, 70], \"훈련 결측도 훈련 중앙값으로 채우세요\"\n",
    "c_tr, c_te = customers.iloc[:200], customers.iloc[200:]\n",
    "A, B = fill_age(c_tr, c_te)\n",
    "assert A[\"나이\"].isna().sum() == 0 and B[\"나이\"].isna().sum() == 0, \"결측이 남았습니다\"\n",
    "assert B[\"나이_결측\"].sum() == c_te[\"나이\"].isna().sum(), \"결측 표시 개수가 다릅니다\"\n",
    "print(\"훈련 중앙값\", c_tr[\"나이\"].median(), \"/ 테스트 결측\", int(B[\"나이_결측\"].sum()), \"개 채움\")\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch03-011",
   "metadata": {},
   "source": [
    "## 문제 4. 기술 통계 참/거짓 (개념)\n",
    "\n",
    "`x = pd.Series([3, 5, 5, 6, 8, 9, 100])`일 때 맞으면 `O`, 틀리면 `X`. (a)~(e) 순서대로 이어 쓴 문자열을 `q4`에 적으세요. 예: `\"OXXOX\"`\n",
    "\n",
    "(a) 100을 1000으로 바꿔도 `x.median()`은 그대로다.\n",
    "(b) `x.std()`와 `np.std(x.to_numpy())`는 같은 값이다.\n",
    "(c) `x.quantile(0.5)`와 `x.median()`은 같은 값이다.\n",
    "(d) 평균이 중앙값보다 훨씬 크면 큰 값 쪽으로 꼬리가 길거나 큰 이상치가 있을 수 있다.\n",
    "(e) 결측(`NaN`)이 하나라도 있는 열의 `mean()`은 `NaN`이 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch03-012",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "q4 = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch03-013",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q4\", q4, \"9861f5c5fe42\")\n",
    "x = pd.Series([3, 5, 5, 6, 8, 9, 100])\n",
    "print(\"(a)\", x.median(), x.replace(100, 1000).median())\n",
    "print(\"(b)\", round(x.std(), 3), round(np.std(x.to_numpy()), 3))\n",
    "print(\"(c)\", x.quantile(0.5), x.median())\n",
    "print(\"(d) 평균\", round(x.mean(), 2), \"중앙값\", x.median())\n",
    "print(\"(e)\", pd.Series([1, np.nan, 3]).mean())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch03-014",
   "metadata": {},
   "source": [
    "## 문제 5. 훈련 범주 기준 원-핫 (코드)\n",
    "\n",
    "`one_hot(train_col, test_col)`을 쓰세요. 두 Series를 받아 `(train_결과, test_결과)` 두 DataFrame을 돌려줍니다.\n",
    "\n",
    "- 열 이름은 **train에 나온 범주**를 가나다순으로 정렬한 것(접두어 없음). 두 결과의 열이 같아야 합니다.\n",
    "- 값은 정수 0/1. train에 없던 범주는 모든 열이 0입니다.\n",
    "- 각 결과의 index는 입력 Series의 index와 같습니다.\n",
    "\n",
    "`pd.get_dummies` + `reindex`나 sklearn `OneHotEncoder(handle_unknown=\"ignore\")` 중 편한 것을 쓰세요.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`cols = pd.get_dummies(train_col, dtype=int).columns`로 열 목록을 정하고, test는 `pd.get_dummies(test_col, dtype=int).reindex(columns=cols, fill_value=0)`. `get_dummies`는 열을 정렬해서 만듭니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch03-015",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def one_hot(train_col, test_col):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch03-016",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "s_tr = pd.Series([\"서울\", \"부산\", \"서울\", \"대구\"], index=[10, 11, 12, 13])\n",
    "s_te = pd.Series([\"광주\", \"부산\", \"제주\"], index=[20, 21, 22])\n",
    "res = one_hot(s_tr, s_te)\n",
    "assert res is not None, \"결과를 return 하세요\"\n",
    "a, b = res\n",
    "assert list(a.columns) == [\"대구\", \"부산\", \"서울\"], f\"훈련 열이 {list(a.columns)}입니다\"\n",
    "assert list(a.index) == [10, 11, 12, 13], \"훈련 index가 입력과 다릅니다\"\n",
    "assert a.to_numpy().tolist() == [[0, 0, 1], [0, 1, 0], [0, 0, 1], [1, 0, 0]], \"훈련 결과 값이 다릅니다\"\n",
    "assert list(b.columns) == list(a.columns), f\"테스트 열 {list(b.columns)}이 훈련 열과 다릅니다. 열 목록은 훈련에서 정하세요\"\n",
    "assert list(b.index) == [20, 21, 22], \"테스트 index가 입력과 다릅니다\"\n",
    "assert b.loc[20].sum() == 0 and b.loc[22].sum() == 0, \"처음 보는 범주(광주·제주)는 모든 열이 0이어야 합니다\"\n",
    "assert b.loc[21, \"부산\"] == 1, \"부산 행은 부산 열이 1이어야 합니다\"\n",
    "assert all(pd.api.types.is_integer_dtype(t) for t in list(a.dtypes) + list(b.dtypes)), \"값을 정수 0/1로 만드세요(dtype=int)\"\n",
    "from sklearn.preprocessing import OneHotEncoder\n",
    "c_tr, c_te = customers[\"도시\"].iloc[:200], customers[\"도시\"].iloc[200:]\n",
    "A, B = one_hot(c_tr, c_te)\n",
    "enc = OneHotEncoder(handle_unknown=\"ignore\", sparse_output=False).fit(c_tr.to_frame())\n",
    "assert np.array_equal(A.to_numpy(), enc.transform(c_tr.to_frame())), \"훈련 결과가 OneHotEncoder 결과와 다릅니다\"\n",
    "assert np.array_equal(B.to_numpy(), enc.transform(c_te.to_frame())), \"테스트 결과가 OneHotEncoder 결과와 다릅니다\"\n",
    "assert A.index.equals(c_tr.index) and B.index.equals(c_te.index), \"결과 index가 입력과 다릅니다\"\n",
    "print(b)\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch03-017",
   "metadata": {},
   "source": [
    "## 문제 6. 그룹 집계와 transform (코드)\n",
    "\n",
    "1. `city_summary(df)`: 도시별 `고객수`(행 수), `평균나이`(결측 제외 평균), `방문수합`을 열로 갖는 DataFrame. index는 도시(가나다순), 열 순서는 `[\"고객수\", \"평균나이\", \"방문수합\"]`.\n",
    "2. `visit_gap(df)`: 고객마다 `방문수 − 같은 도시 고객의 평균 방문수`인 Series. index는 `df`와 같습니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`df.groupby(\"도시\").agg(고객수=(\"고객ID\", \"size\"), 평균나이=(\"나이\", \"mean\"), 방문수합=(\"방문수\", \"sum\"))`. 행마다 그룹 평균을 붙이려면 `groupby(...)[\"방문수\"].transform(\"mean\")`.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch03-018",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def city_summary(df):\n",
    "    pass   # 작성\n",
    "\n",
    "def visit_gap(df):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch03-019",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "summ = city_summary(customers)\n",
    "assert summ is not None, \"city_summary: 결과를 return 하세요\"\n",
    "assert list(summ.columns) == [\"고객수\", \"평균나이\", \"방문수합\"], f\"열이 {list(summ.columns)}입니다\"\n",
    "assert list(summ.index) == sorted(customers[\"도시\"].unique()), \"index가 도시 가나다순이 아닙니다\"\n",
    "seoul = customers[customers[\"도시\"] == \"서울\"]\n",
    "assert summ.loc[\"서울\", \"고객수\"] == len(seoul), \"고객수는 결측을 포함한 행 수(size)입니다\"\n",
    "assert np.isclose(summ.loc[\"서울\", \"평균나이\"], seoul[\"나이\"].dropna().mean()), \"평균나이가 다릅니다(결측 제외 평균)\"\n",
    "assert summ.loc[\"서울\", \"방문수합\"] == seoul[\"방문수\"].sum(), \"방문수합이 다릅니다\"\n",
    "assert summ[\"고객수\"].sum() == len(customers), \"고객수 합이 전체 고객 수와 다릅니다\"\n",
    "shuffled = customers.sample(frac=1, random_state=3)\n",
    "gap = visit_gap(shuffled)\n",
    "assert gap is not None, \"visit_gap: 결과를 return 하세요\"\n",
    "assert gap.index.equals(shuffled.index), \"visit_gap 결과의 index가 입력과 다릅니다\"\n",
    "ref = shuffled[\"방문수\"] - shuffled[\"도시\"].map(shuffled.groupby(\"도시\")[\"방문수\"].mean())\n",
    "assert np.allclose(gap, ref), \"값이 다릅니다. 같은 도시 평균을 뺐나요?\"\n",
    "assert np.allclose(gap.groupby(shuffled[\"도시\"]).mean(), 0), \"도시마다 gap 평균이 0이어야 합니다\"\n",
    "print(summ.round(1))\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch03-020",
   "metadata": {},
   "source": [
    "## 문제 7. 중복 키 정리 후 병합 (코드)\n",
    "\n",
    "`customers_raw`에는 주소를 바꾼 고객이 새 줄로 한 번 더 들어 있습니다(아래쪽 줄이 최신). `orders`의 고객ID 중 몇 개는 고객 표에 없습니다.\n",
    "\n",
    "1. `attach_customer(orders, customers_raw)`: 고객ID마다 **마지막 줄만** 남긴 고객 표의 `도시`·`등급`을 주문에 붙입니다. 주문은 하나도 빠지거나 늘면 안 되고(고객 표에 없는 주문은 도시·등급이 결측), 결과의 index는 0부터, 행 순서는 `orders`와 같습니다. `validate`로 키 중복을 확인하세요.\n",
    "2. `sales_by_city(merged)`: 도시별 금액 합계 Series. 도시가 결측인 주문은 `\"미확인\"`으로 묶습니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`drop_duplicates(\"고객ID\", keep=\"last\")` → `orders.merge(..., on=\"고객ID\", how=\"left\", validate=\"many_to_one\")`. 결측 도시는 `fillna(\"미확인\")` 후 `groupby`하거나 `groupby(..., dropna=False)`를 씁니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch03-021",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def attach_customer(orders, customers_raw):\n",
    "    pass   # 작성\n",
    "\n",
    "def sales_by_city(merged):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch03-022",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "print(\"고객 표 중복 고객ID:\", int(customers_raw[\"고객ID\"].duplicated().sum()), \"개\")\n",
    "mg = attach_customer(orders, customers_raw)\n",
    "assert mg is not None, \"attach_customer: 결과를 return 하세요\"\n",
    "assert len(mg) == len(orders), f\"행 수가 {len(orders)} → {len(mg)}입니다. 중복 키 때문에 늘었거나 inner로 빠졌습니다\"\n",
    "assert mg[\"금액\"].sum() == orders[\"금액\"].sum(), \"금액 합계가 원래 주문과 다릅니다\"\n",
    "assert (mg[\"주문ID\"].to_numpy() == orders[\"주문ID\"].to_numpy()).all(), \"행 순서가 orders와 다릅니다\"\n",
    "assert list(mg.index) == list(range(len(mg))), \"index는 0부터여야 합니다\"\n",
    "assert {\"도시\", \"등급\"} <= set(mg.columns), \"도시·등급 열이 없습니다\"\n",
    "latest = customers_raw.groupby(\"고객ID\").tail(1).set_index(\"고객ID\")\n",
    "known = mg[\"고객ID\"].isin(latest.index)\n",
    "moved_ids = customers_raw.loc[customers_raw[\"고객ID\"].duplicated(), \"고객ID\"]\n",
    "sub = mg[mg[\"고객ID\"].isin(moved_ids)]\n",
    "assert (sub[\"도시\"].to_numpy() == latest.loc[sub[\"고객ID\"], \"도시\"].to_numpy()).all(), \"주소를 바꾼 고객은 마지막 줄(최신) 도시여야 합니다\"\n",
    "for col in (\"도시\", \"등급\"):\n",
    "    assert (mg.loc[known, col].to_numpy() == latest.loc[mg.loc[known, \"고객ID\"], col].to_numpy()).all(), f\"{col} 값이 고객 표(최신 줄)와 다른 주문이 있습니다\"\n",
    "assert (~known).sum() > 0 and mg.loc[~known, [\"도시\", \"등급\"]].isna().all().all(), \"고객 표에 없는 주문은 도시·등급이 결측이어야 합니다\"\n",
    "sales = sales_by_city(mg)\n",
    "assert sales is not None, \"sales_by_city: 결과를 return 하세요\"\n",
    "assert \"미확인\" in sales.index, \"도시 결측 주문이 '미확인'으로 묶이지 않았습니다(groupby는 기본으로 결측을 버립니다)\"\n",
    "ref_city = orders[\"고객ID\"].map(latest[\"도시\"]).fillna(\"미확인\")\n",
    "ref_sales = orders.groupby(ref_city)[\"금액\"].sum()\n",
    "assert sorted(sales.index) == sorted(ref_sales.index), f\"도시 목록이 {sorted(sales.index)}입니다\"\n",
    "assert (sales.reindex(ref_sales.index) == ref_sales).all(), \"도시별 매출이 다릅니다\"\n",
    "print(sales.sort_values(ascending=False))\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch03-023",
   "metadata": {},
   "source": [
    "## 문제 8. IQR 규칙으로 이상치 후보 찾기 (코드)\n",
    "\n",
    "`iqr_outliers(s)`를 쓰세요. 숫자 Series를 받아, Q1 − 1.5×IQR보다 작거나 Q3 + 1.5×IQR보다 큰 값이면 `True`인 불리언 Series를 돌려줍니다(index는 입력과 같음). Q1·Q3는 pandas `quantile` 기본값을 씁니다.\n",
    "\n",
    "점검 셀은 주문 금액에 적용한 뒤 히스토그램과 상자 그림을 그립니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`q1, q3 = s.quantile(0.25), s.quantile(0.75)`, `iqr = q3 - q1`. 두 조건을 `|`로 묶고 각각 괄호를 칩니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch03-024",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def iqr_outliers(s):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch03-025",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "small = pd.Series([-50, 3, 5, 5, 6, 8, 9, 120], index=list(\"abcdefgh\"))\n",
    "o = iqr_outliers(small)\n",
    "assert o is not None, \"결과를 return 하세요\"\n",
    "assert isinstance(o, pd.Series), \"Series로 돌려주세요(.to_numpy() 등으로 바꾸지 않기)\"\n",
    "assert o.index.equals(small.index), \"index가 입력과 다릅니다\"\n",
    "assert o.dtype == bool, f\"dtype이 {o.dtype}입니다. 불리언 Series를 돌려주세요\"\n",
    "assert o.tolist() == [True, False, False, False, False, False, False, True], \"작은 쪽과 큰 쪽 이상치를 모두 찾아야 합니다\"\n",
    "amt = orders[\"금액\"]\n",
    "out = iqr_outliers(amt)\n",
    "q1, q3 = amt.quantile([0.25, 0.75])\n",
    "assert out.equals((amt < q1 - 1.5 * (q3 - q1)) | (amt > q3 + 1.5 * (q3 - q1))), \"주문 금액에서 결과가 다릅니다\"\n",
    "print(\"주문 금액 이상치 후보\", int(out.sum()), \"건 / 평균\", round(amt.mean()), \"중앙값\", amt.median())\n",
    "fig, axes = plt.subplots(1, 2, figsize=(10, 3))\n",
    "amt.plot.hist(bins=50, ax=axes[0], title=\"주문 금액 (전체)\")\n",
    "amt[~out].plot.box(ax=axes[1], title=\"이상치 후보를 뺀 주문 금액\")\n",
    "plt.show()\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch03-026",
   "metadata": {},
   "source": [
    "## 문제 9. 병합 뒤 매출이 부풀었다 (사례)\n",
    "\n",
    "동료가 주문 1000건 표를 고객 표와 `merge(on=\"고객ID\", how=\"left\")`로 합쳐 도시별 매출을 냈습니다. 합친 표는 1092행이고 매출 합계가 원래보다 9% 많습니다. 오류는 없었습니다. 가장 알맞은 진단과 조치를 `q9`에 적으세요.\n",
    "\n",
    "- A. 고객 표에 같은 고객ID가 여러 줄 있어 그 고객의 주문이 복제됐다. `customers[\"고객ID\"].duplicated().sum()`으로 확인하고, 남길 줄을 정해 중복을 정리한 뒤 `validate=\"many_to_one\"`을 걸고 행 수·합계를 다시 확인한다.\n",
    "- B. `how=\"left\"`는 고객 표에 없는 주문을 두 번 넣는다. `how=\"inner\"`로 바꾸면 된다.\n",
    "- C. 금액 열에 결측이 있어서 합계가 커졌다. `fillna(0)`을 하면 된다.\n",
    "- D. `merge`는 행 수를 바꾸지 않으므로 그룹 집계 쪽 버그다. `groupby` 대신 피벗 표를 쓴다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch03-027",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "q9 = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch03-028",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q9\", q9, \"559aead08264\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch03-029",
   "metadata": {},
   "source": [
    "## 문제 10. 열마다 인코딩 고르기 (사례)\n",
    "\n",
    "선형 회귀(4장)로 주문 금액을 예측하려고 합니다. 각 열을 어떻게 할지 고르세요. 원-핫이면 `O`, 순서를 정한 정수 매핑이면 `N`, 특성에서 빼면 `X`. (a)~(d) 순서대로 이어 쓴 문자열을 `q10`에 적으세요.\n",
    "\n",
    "(a) 지역: 서울·부산·대구·광주\n",
    "(b) 옷 사이즈: S·M·L·XL. 지난 자료를 보면 사이즈가 한 단계 커질 때마다 주문 금액이 거의 같은 폭으로 늘었다.\n",
    "(c) 회원번호: 고객마다 다른 정수(1000001, 1000002, …)\n",
    "(d) 결제 수단: 카드·현금·간편결제. 앞으로 훈련 데이터에 없던 \"포인트 결제\"가 들어올 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch03-030",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "q10 = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch03-031",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q10\", q10, \"0b2ad6068e5a\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch03-032",
   "metadata": {},
   "source": [
    "## 마무리\n",
    "\n",
    "- [ ] Restart & Run All로 모든 점검 셀이 \"통과\"를 출력한다.\n",
    "- [ ] 문제 2의 `give_coupon`을 연쇄 대입으로 바꿔 보고 어떤 점검이 실패하는지 확인했다.\n",
    "- [ ] 문제 7에서 `drop_duplicates`를 빼면 행 수가 몇으로 늘고 `validate`가 어떤 오류를 내는지 확인했다.\n",
    "- [ ] 원고 3-11절 선택 기준표의 다섯 줄을 내 말로 다시 적어 두었다.\n",
    "\n",
    "다음 장(04장)에서는 이렇게 만든 숫자 표 `X`와 정답 `y`로 선형 회귀를 직접 학습시킨다."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
