점그림과 줄기잎그림¶

import matplotlib.pyplot as plt

# 그림에 한글을 쓰므로 한글 글꼴을 지정한다. 맥이면 'Apple SD Gothic Neo',
# 윈도우면 'Malgun Gothic', 리눅스면 'NanumGothic' 정도가 무난하다.
# 글꼴을 바꾸면 마이너스 기호가 깨지므로 unicode_minus 도 함께 꺼 준다.
plt.rcParams['font.family'] = 'Apple SD Gothic Neo'
plt.rcParams['axes.unicode_minus'] = False

data = [5, 7, 5, 9, 7, 7, 6, 9, 9, 9, 10, 12, 12, 7]

# 값마다 몇 번 나왔는지 센다
age_freq = {}
for age in data:
    age_freq[age] = age_freq.get(age, 0) + 1

fig, ax = plt.subplots(figsize=(12, 3))

# 점그림의 요령: 같은 값을 세로로 쌓는다.
#   x = [age] * freq        가로 위치는 모두 같다
#   y = 1, 2, ..., freq     세로로 한 칸씩 올라간다
for age, freq in age_freq.items():
    ax.plot([age] * freq, range(1, freq + 1), 'ok')

ax.set_xlabel('나이 (세)')
ax.set_ylabel('학생 수')
ax.set_title("학급 학생들의 나이")
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.set_yticks([0, 1, 2, 3, 4])
ax.spines["bottom"].set_position("zero")   # 가로축을 y=0에 붙인다
plt.show()

print(dict(sorted(age_freq.items())))

{5: 2, 6: 1, 7: 4, 9: 4, 10: 1, 12: 2}

import numpy as np

d = np.array(sorted(data))


def hist_bins(d, w, o):
    """경계가 o (mod w) 에 놓이는 구간들의 (왼끝, 도수)."""
    lo = (d.min() - o) // w * w + o
    edges = np.arange(lo, d.max() + w + 1, w)
    cnt, _ = np.histogram(d, bins=edges)
    return [(int(edges[i]), int(cnt[i])) for i in range(len(cnt))]


for w in [2, 3, 4]:
    print(f"구간 폭 w = {w}:  경계의 위치는 {w} 가지뿐이다")
    for o in range(w):
        bins = hist_bins(d, w, o)
        mx = max(c for _, c in bins)
        modes = [f"[{b},{b + w})" for b, c in bins if c == mx]
        body = "  ".join(f"[{b},{b + w}):{c}" for b, c in bins)
        print(f"   경계 ≡ {o} (mod {w}):  {body}")
        print(f"       -> 최빈구간 {', '.join(modes)}   (도수 {mx})")
    print()

vals, cnts = np.unique(d, return_counts=True)
print("점그림이 보여 주는 것 (구간 선택 없음):")
print("   " + "  ".join(f"{v}:{c}" for v, c in zip(vals, cnts)))
print(f"   최빈값 = {list(vals[cnts == cnts.max()])}  (각 {cnts.max()}명, 동점)")

fig, axes = plt.subplots(1, 3, figsize=(13, 3.2), sharey=True)
for v, c in zip(vals, cnts):
    axes[0].plot([v] * c, range(1, c + 1), 'o', color="#1565C0", ms=7)
axes[0].set_title("점그림 — 7세와 9세가 각 4명", fontsize=11)
axes[0].set_ylabel("학생 수")
for ax, o in zip(axes[1:], [0, 1]):
    bins = hist_bins(d, 2, o)
    mx = max(c for _, c in bins)
    ax.bar([b for b, _ in bins], [c for _, c in bins], width=2, align="edge",
           color=["#E65100" if c == mx else "#DCEBFB" for _, c in bins],
           edgecolor="#37474F")
    mode = [b for b, c in bins if c == mx][0]
    ax.set_title(f"히스토그램 (폭 2, 경계 ≡ {o})  최빈 [{mode},{mode + 2})",
                 fontsize=11)
for ax in axes:
    ax.set_xlabel("나이 (세)")
    ax.set_xlim(3.5, 14.5)
    ax.set_xticks(range(4, 15, 2))
    ax.spines[["top", "right"]].set_visible(False)
plt.tight_layout()
plt.show()

구간 폭 w = 2:  경계의 위치는 2 가지뿐이다
   경계 ≡ 0 (mod 2):  [4,6):2  [6,8):5  [8,10):4  [10,12):1  [12,14):2
       -> 최빈구간 [6,8)   (도수 5)
   경계 ≡ 1 (mod 2):  [5,7):3  [7,9):4  [9,11):5  [11,13):2
       -> 최빈구간 [9,11)   (도수 5)

구간 폭 w = 3:  경계의 위치는 3 가지뿐이다
   경계 ≡ 0 (mod 3):  [3,6):2  [6,9):5  [9,12):5  [12,15):2
       -> 최빈구간 [6,9), [9,12)   (도수 5)
   경계 ≡ 1 (mod 3):  [4,7):3  [7,10):8  [10,13):3
       -> 최빈구간 [7,10)   (도수 8)
   경계 ≡ 2 (mod 3):  [5,8):7  [8,11):5  [11,14):2
       -> 최빈구간 [5,8)   (도수 7)

구간 폭 w = 4:  경계의 위치는 4 가지뿐이다
   경계 ≡ 0 (mod 4):  [4,8):7  [8,12):5  [12,16):2
       -> 최빈구간 [4,8)   (도수 7)
   경계 ≡ 1 (mod 4):  [5,9):7  [9,13):7
       -> 최빈구간 [5,9), [9,13)   (도수 7)
   경계 ≡ 2 (mod 4):  [2,6):2  [6,10):9  [10,14):3
       -> 최빈구간 [6,10)   (도수 9)
   경계 ≡ 3 (mod 4):  [3,7):3  [7,11):9  [11,15):2
       -> 최빈구간 [7,11)   (도수 9)

점그림이 보여 주는 것 (구간 선택 없음):
   5:2  6:1  7:4  9:4  10:1  12:2
   최빈값 = [7, 9]  (각 4명, 동점)

from collections import defaultdict

def stem_leaf(data, stem_unit=10):
    """줄기잎그림을 문자열로 만든다.

    stem_unit=10 이면 십의 자리가 줄기, 일의 자리가 잎이 된다.
    예: 65 -> 줄기 6, 잎 5
    """
    buckets = defaultdict(list)
    for v in sorted(data):                 # 잎이 오름차순이 되도록 먼저 정렬
        buckets[int(v) // stem_unit].append(int(v) % stem_unit)

    lines = ["줄기 | 잎", "-----+" + "-" * 20]
    # 값이 없는 줄기도 건너뛰지 않고 빈 줄로 남긴다.
    # 그래야 줄 길이가 도수에 비례해 분포 모양이 제대로 보인다.
    for stem in range(min(buckets), max(buckets) + 1):
        leaves = " ".join(str(leaf) for leaf in buckets.get(stem, []))
        lines.append(f"{stem:4d} | {leaves}")
    lines.append(f"\n줄기 단위 = {stem_unit}   (줄기 6, 잎 5  ->  65)")
    return "\n".join(lines)

scores = [65, 93, 45, 73, 99, 70, 88, 46, 75, 34, 83, 100, 88, 72, 70]
print(stem_leaf(scores))

줄기 | 잎
-----+--------------------
   3 | 4
   4 | 5 6
   5 |
   6 | 5
   7 | 0 0 2 3 5
   8 | 3 8 8
   9 | 3 9
  10 | 0

줄기 단위 = 10   (줄기 6, 잎 5  ->  65)

s = sorted(scores)
lo, hi, R = min(s), max(s), max(s) - min(s)
print(f"n = {len(s)},  최소 {lo},  최대 {hi},  범위 R = {R}")


def stems(data, u):
    """줄기 -> 잎 목록. 빈 줄기도 남긴다."""
    b = defaultdict(list)
    for v in sorted(data):
        b[int(v) // u].append(int(v) % u)
    return list(range(min(b), max(b) + 1)), b


print(f"\n{'단위 u':>7}{'공식 ⌊hi/u⌋-⌊lo/u⌋+1':>22}{'실제 줄 수':>11}"
      f"{'어림 R/u+1':>12}{'한 줄 평균 잎':>14}")
for u in [1, 2, 5, 10, 20, 25, 50]:
    rs, _ = stems(s, u)
    print(f"{u:>7}{hi // u - lo // u + 1:>22}{len(rs):>11}"
          f"{R / u + 1:>12.2f}{len(s) / len(rs):>14.2f}")

ok = [u for u in range(1, R + 1) if 5 <= hi // u - lo // u + 1 <= 15]
print(f"\n줄이 5~15 개가 되는 u = {ok}")
print(f"어림식이 주는 범위:  R/14 = {R / 14:.2f}  ~  R/4 = {R / 4:.2f}")

# 잎에서 원자료를 복원할 수 있는가
u = 10
rs, b = stems(s, u)
restored = sorted(st * u + lf for st in rs for lf in b.get(st, []))
print(f"\n잎에서 복원한 자료 == 원자료(정렬): {restored == s}")
print(f"   {restored}")

n = 15,  최소 34,  최대 100,  범위 R = 66

   단위 u    공식 ⌊hi/u⌋-⌊lo/u⌋+1     실제 줄 수    어림 R/u+1      한 줄 평균 잎
      1                    67         67       67.00          0.22
      2                    34         34       34.00          0.44
      5                    15         15       14.20          1.00
     10                     8          8        7.60          1.88
     20                     5          5        4.30          3.00
     25                     4          4        3.64          3.75
     50                     3          3        2.32          5.00

줄이 5~15 개가 되는 u = [5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 19, 20]
어림식이 주는 범위:  R/14 = 4.71  ~  R/4 = 16.50

잎에서 복원한 자료 == 원자료(정렬): True
   [34, 45, 46, 65, 70, 70, 72, 73, 75, 83, 88, 88, 93, 99, 100]

줄기 | 잎
-----+--------------------
   2 | 3 5 8
   3 | 1 2 4 5 5 7
   4 | 1 3 4
   5 | 2
   6 | 7
   7 |
   8 | 9

    1반  | 줄기 |  2반
  8 5 3  |   6  | 2 7
9 7 5 2  |   7  | 0 3 5 8 8
    4 1  |   8  | 1 4 6 9
      6  |   9  | 2 5

import numpy as np

def stem_options(x):
    """가능한 줄기 단위별 줄기 개수를 보여 준다."""
    x = np.asarray(x, float)
    rng_ = x.max() - x.min()
    print(f"자료 {len(x)}개, 범위 {x.min():.1f} ~ {x.max():.1f} (폭 {rng_:.1f})")
    print(f"{'줄기 단위':>10}{'줄기 개수':>10}{'줄당 평균 잎':>14}{'판정':>8}")
    for unit in (100, 50, 20, 10, 5, 2, 1):
        n_stems = int(np.floor(x.max() / unit) - np.floor(x.min() / unit)) + 1
        verdict = "적절" if 5 <= n_stems <= 15 else ("너무 적음" if n_stems < 5 else "너무 많음")
        print(f"{unit:>10}{n_stems:>10}{len(x) / n_stems:>14.1f}{verdict:>8}")

rng = np.random.default_rng(0)
stem_options(rng.normal(72, 11, 40).round())
print()
stem_options(rng.normal(720, 110, 40).round())

자료 40개, 범위 46.0 ~ 88.0 (폭 42.0)
     줄기 단위     줄기 개수       줄당 평균 잎      판정
       100         1          40.0   너무 적음
        50         2          20.0   너무 적음
        20         3          13.3   너무 적음
        10         5           8.0      적절
         5         9           4.4      적절
         2        22           1.8   너무 많음
         1        43           0.9   너무 많음

자료 40개, 범위 478.0 ~ 940.0 (폭 462.0)
     줄기 단위     줄기 개수       줄당 평균 잎      판정
       100         6           6.7      적절
        50        10           4.0      적절
        20        25           1.6   너무 많음
        10        48           0.8   너무 많음
         5        94           0.4   너무 많음
         2       232           0.2   너무 많음
         1       463           0.1   너무 많음

import numpy as np

rng = np.random.default_rng(3)
a = np.clip(rng.normal(72, 9, 28), 40, 100).round().astype(int)
b = np.clip(rng.normal(78, 6, 28), 40, 100).round().astype(int)

def back_to_back(left, right, unit=10):
    stems = range(min(left.min(), right.min()) // unit,
                  max(left.max(), right.max()) // unit + 1)
    print(f"{'A 반':>28} | 줄기 | B 반")
    for s in stems:
        lv = sorted([v % unit for v in left if v // unit == s], reverse=True)
        rv = sorted([v % unit for v in right if v // unit == s])
        print(f"{' '.join(map(str, lv)):>28} |  {s}   | {' '.join(map(str, rv))}")

back_to_back(a, b)
print(f"\nA: 평균 {a.mean():.2f}  중앙값 {np.median(a):.1f}  표준편차 {a.std(ddof=1):.2f}")
print(f"B: 평균 {b.mean():.2f}  중앙값 {np.median(b):.1f}  표준편차 {b.std(ddof=1):.2f}")

                         A 반 | 줄기 | B 반
                           9 |  4   |
                           4 |  5   |
           9 9 8 8 7 7 6 4 3 |  6   | 1 8
     7 7 6 6 4 2 0 0 0 0 0 0 |  7   | 2 2 2 3 3 5 6 7 7 7 8 8 9 9
                       9 6 1 |  8   | 0 1 1 2 2 2 2 3 4 4 5 6
                           0 |  9   |
                           0 |  10   |

A: 평균 72.21  중앙값 70.0  표준편차 10.39
B: 평균 77.82  중앙값 78.5  표준편차 5.64

import numpy as np

rng = np.random.default_rng(1)
print(f"{'n':>7}{'줄기당 잎':>12}{'점그림 겹침':>14}{'히스토그램 칸당':>16}")
for n in (15, 40, 100, 300, 1000, 10_000):
    x = rng.normal(72, 11, n).round()
    n_stems = int(x.max() // 10 - x.min() // 10) + 1
    leaves = n / n_stems
    unique = len(np.unique(x))
    overlap = n / unique                       # 같은 값에 겹치는 점의 수
    bins = max(1, int(1 + np.log2(n)))
    print(f"{n:>7}{leaves:>12.1f}{overlap:>14.1f}{n / bins:>16.1f}")

      n       줄기당 잎        점그림 겹침        히스토그램 칸당
     15         3.8           1.2             3.8
     40         6.7           1.6             6.7
    100        14.3           2.8            14.3
    300        42.9           5.9            33.3
   1000       111.1          14.9           100.0
  10000      1111.1         122.0           714.3

import numpy as np
import matplotlib.pyplot as plt

# 그림에 한글이 들어가므로 한글 글꼴을 지정한다(지정하지 않으면 네모로 깨진다).
plt.rcParams['font.family'] = 'Apple SD Gothic Neo'
plt.rcParams['axes.unicode_minus'] = False

rng = np.random.default_rng(5)

# (1) 윌킨슨 점그림: 분포를 보여 준다. 같은 값에 점을 쌓는다.
values = rng.integers(1, 8, 40)
uniq, counts = np.unique(values, return_counts=True)

# (2) 클리블랜드 점그림: 범주별 값 하나를 보여 준다. 막대그림의 대안.
cats = ["서울", "부산", "대구", "인천", "광주", "대전"]
vals = np.array([9.4, 3.3, 2.4, 3.0, 1.4, 1.5])

fig, axes = plt.subplots(1, 2, figsize=(11, 4))
for v, c in zip(uniq, counts):
    axes[0].plot([v] * c, np.arange(c) + 1, "o", color="C0", ms=8)
axes[0].set_xlabel("값"); axes[0].set_ylabel("개수")
axes[0].set_title("윌킨슨 점그림 — 분포", fontsize=10)

order = np.argsort(vals)
axes[1].hlines(np.arange(len(cats)), 0, vals[order], color="lightgray")
axes[1].plot(vals[order], np.arange(len(cats)), "o", ms=9)
axes[1].set_yticks(np.arange(len(cats)))
axes[1].set_yticklabels([cats[i] for i in order])
axes[1].set_xlabel("인구 (백만)")
axes[1].set_title("클리블랜드 점그림 — 범주별 값", fontsize=10)
fig.tight_layout()
plt.show()

print(f"윌킨슨: 값 {uniq}, 도수 {counts}  → 분포를 보여 준다")
print(f"클리블랜드: 범주 {len(cats)}개, 각 범주에 값 하나  → 막대그림의 대안")

윌킨슨: 값 [1 2 3 4 5 6 7], 도수 [8 7 4 5 7 5 4]  → 분포를 보여 준다
클리블랜드: 범주 6개, 각 범주에 값 하나  → 막대그림의 대안

import numpy as np

rng = np.random.default_rng(7)
clean = rng.normal(72, 9, 50).round().astype(int)
rounded = (np.round(rng.normal(72, 9, 50) / 5) * 5).astype(int)

def stem(x, unit=10, title=""):
    print(f"{title}")
    for s in range(x.min() // unit, x.max() // unit + 1):
        leaves = sorted(v % unit for v in x if v // unit == s)
        print(f"  {s} | {' '.join(map(str, leaves))}")
    last = x % 10
    print(f"  끝자리 분포: {np.round([np.mean(last == d) for d in range(10)], 3)}")

stem(clean, title="정상 자료")
print()
stem(rounded, title="5 단위로 반올림된 자료")

정상 자료
  4 | 9
  5 | 5 5 8 8
  6 | 0 0 1 1 3 3 4 4 5 5 6 6 7 7 8 8 8 8
  7 | 0 0 0 1 2 2 2 2 3 3 3 3 3 3 3 3 4 5 5 6 8
  8 | 0 0 2 4 4
  9 | 0
  끝자리 분포: [0.16 0.06 0.1  0.2  0.1  0.12 0.06 0.04 0.14 0.02]

5 단위로 반올림된 자료
  5 | 5 5 5
  6 | 0 0 0 0 0 5 5 5
  7 | 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 5 5 5 5 5 5 5
  8 | 0 0 0 0 0 0 0 0 0 0 0 5 5 5
  끝자리 분포: [0.68 0.   0.   0.   0.   0.32 0.   0.   0.   0.  ]

import numpy as np

rng = np.random.default_rng(2)
x = rng.normal(72, 9, 30).round().astype(int)
order = rng.permutation(len(x))               # 원래 기록 순서를 흉내

def stem(x, sort_leaves, title):
    print(title)
    for s in range(x.min() // 10, x.max() // 10 + 1):
        leaves = [v % 10 for v in x if v // 10 == s]
        if sort_leaves:
            leaves = sorted(leaves)
        print(f"  {s} | {' '.join(map(str, leaves))}")

stem(x[order], True, "잎을 정렬한 경우")
print()
stem(x[order], False, "기록 순서 그대로")
print(f"\n중앙값 {np.median(x):.1f}   Q1 {np.percentile(x, 25):.1f}   Q3 {np.percentile(x, 75):.1f}")

잎을 정렬한 경우
  5 | 0 6 7 8
  6 | 3 4 5 7 7 7 8 9 9 9
  7 | 1 3 4 4 5 5 6 6 7 9 9
  8 | 0 1 2 8
  9 | 1

기록 순서 그대로
  5 | 8 0 6 7
  6 | 8 4 5 9 9 7 9 7 7 3
  7 | 5 3 1 7 5 6 4 4 9 6 9
  8 | 1 0 2 8
  9 | 1

중앙값 72.0   Q1 67.0   Q3 76.8

import numpy as np

print(f"{'상황':<34}{'권장':<20}{'이유'}")
rows = [
    ("n < 30, 원자료를 보존해야 함", "줄기잎그림", "값이 그대로 보인다"),
    ("n < 100, 분포 모양", "점그림 / 스트립", "겹침 없이 개별 관측"),
    ("자릿수 쏠림 의심", "줄기잎그림", "끝자리가 직접 보인다"),
    ("범주별 값 비교", "클리블랜드 점그림", "막대보다 정확하고 간결"),
    ("두 집단 비교, n 작음", "등맞댄 줄기잎", "정보 손실 없음"),
    ("n > 500", "히스토그램 / KDE", "줄기잎은 불가능"),
    ("발표·논문 그림", "점그림 / 상자+점", "줄기잎은 고정폭 글꼴 필요"),
]
for a, b, c in rows:
    print(f"{a:<34}{b:<20}{c}")

상황                                권장                  이유
n < 30, 원자료를 보존해야 함               줄기잎그림               값이 그대로 보인다
n < 100, 분포 모양                    점그림 / 스트립           겹침 없이 개별 관측
자릿수 쏠림 의심                         줄기잎그림               끝자리가 직접 보인다
범주별 값 비교                          클리블랜드 점그림           막대보다 정확하고 간결
두 집단 비교, n 작음                     등맞댄 줄기잎             정보 손실 없음
n > 500                           히스토그램 / KDE         줄기잎은 불가능
발표·논문 그림                          점그림 / 상자+점          줄기잎은 고정폭 글꼴 필요