막대그림¶

import matplotlib.pyplot as plt
import pandas as pd

plt.rcParams["font.family"] = "Apple SD Gothic Neo"   # 한글 글꼴
plt.rcParams["axes.unicode_minus"] = False            # 음수 기호가 네모가 되지 않게

data = {
    '과목': ('국어', '역사', '기하', '화학', '물리'),
    '교사 수': (7, 3, 9, 1, 2)
}
df = pd.DataFrame(data).set_index('과목')

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

# x           막대의 가로 위치 (0, 1, 2, ... 로 두고 눈금에 이름을 붙인다)
# height      막대의 높이 = 나타내려는 값
# tick_label  각 위치에 표시할 범주 이름
# width       막대 폭. 1.0이면 서로 붙고, 0.5면 절반 간격이 생긴다
bars = ax.bar(x=range(len(df)), height=df["교사 수"],
              tick_label=df.index, width=0.5)
ax.set_xlabel('과목')
ax.set_ylabel('교사 수')
ax.set_title("교사들이 좋아하는 과목")
# 위·오른쪽 테두리를 지우면 자료 자체에 눈이 집중된다
ax.spines['right'].set_visible(False)
ax.spines['top'].set_visible(False)
plt.show()

# (1) 기준선이 0 이면 막대 길이의 비가 값의 비와 같다.
v = df["교사 수"].to_numpy(float)
T = v.sum()
print(f"총 교사 {T:.0f}명")
print(f"{'과목':>6}{'개수':>7}{'비율':>9}{'백분율':>9}{'막대 높이':>11}")
for name, x, b in zip(df.index, v, bars):
    print(f"{name:>6}{x:>7.0f}{x/T:>9.4f}{100*x/T:>9.2f}{b.get_height():>11.2f}")

print("\n눈금을 바꾸어도 길이의 비는 그대로다 (기하 / 국어)")
for lab, w in [("개수", v), ("비율", v/T), ("백분율", 100*v/T)]:
    print(f"  {lab:>4}: {w[2]:.4f} / {w[0]:.4f} = {w[2]/w[0]:.6f}")

# (2) 영점이 임의인 변수는 막대로 그릴 수 없다.
print("\n영점이 임의인 변수 — 섭씨와 화렌하이트")
for c1, c2 in [(10.0, 20.0), (15.0, 25.0)]:
    f1, f2 = c1 * 9 / 5 + 32, c2 * 9 / 5 + 32
    print(f"  섭씨 {c1:.0f} 대 {c2:.0f}  비 {c2/c1:.4f}"
          f"   →  화렌하이트 {f1:.0f} 대 {f2:.0f}  비 {f2/f1:.4f}")

총 교사 22명
    과목     개수       비율      백분율      막대 높이
    국어      7   0.3182    31.82       7.00
    역사      3   0.1364    13.64       3.00
    기하      9   0.4091    40.91       9.00
    화학      1   0.0455     4.55       1.00
    물리      2   0.0909     9.09       2.00

눈금을 바꾸어도 길이의 비는 그대로다 (기하 / 국어)
    개수: 9.0000 / 7.0000 = 1.285714
    비율: 0.4091 / 0.3182 = 1.285714
   백분율: 40.9091 / 31.8182 = 1.285714

영점이 임의인 변수 — 섭씨와 화렌하이트
  섭씨 10 대 20  비 2.0000   →  화렌하이트 50 대 68  비 1.3600
  섭씨 15 대 25  비 1.6667   →  화렌하이트 59 대 77  비 1.3051

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from itertools import permutations

plt.rcParams["font.family"] = "Apple SD Gothic Neo"   # 한글 글꼴
plt.rcParams["axes.unicode_minus"] = False            # 음수 기호가 네모가 되지 않게

df = pd.DataFrame({'과목': ['국어', '역사', '기하', '화학', '물리'],
                   '교사 수': [7, 3, 9, 1, 2]})

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 3.5))

# 왼쪽: 자료에 적힌 순서 그대로
ax1.bar(df['과목'], df['교사 수'], width=0.5, color='steelblue')
ax1.set_title("정렬하지 않음")
ax1.set_ylabel("교사 수")

# 오른쪽: 값이 큰 순서로 정렬
df_sorted = df.sort_values('교사 수', ascending=False)
ax2.bar(df_sorted['과목'], df_sorted['교사 수'], width=0.5, color='steelblue')
ax2.set_title("값 순으로 정렬")

for ax in (ax1, ax2):
    ax.spines[['top', 'right']].set_visible(False)
plt.tight_layout()
plt.show()

# (1) 이웃 막대의 높이 차를 모두 더해 본다.
def tv(v):
    return np.abs(np.diff(v)).sum()

v = df['교사 수'].to_numpy(float)
span = v.max() - v.min()
print(f"자료 순서  {v.astype(int).tolist()}   이웃 차의 합 {tv(v):.0f}")
vs = np.sort(v)[::-1]
print(f"큰 순 정렬 {vs.astype(int).tolist()}   이웃 차의 합 {tv(vs):.0f}   범위 {span:.0f}")

# 5! = 120 가지 배열을 모두 훑어 최소가 정렬된 것인지 확인한다.
sums = sorted(tv(np.array(p)) for p in permutations(v))
print(f"\n120 가지 배열의 이웃 차 합: 최소 {sums[0]:.0f}, 최대 {sums[-1]:.0f}")
print(f"최소를 내는 배열의 개수 {sum(1 for s in sums if s == sums[0])}")

# 순서가 있는 범주에서는 그 총변동 자체가 읽을 정보다.
sales = np.array([80, 75, 85, 90, 95, 110, 130, 125, 100, 92, 88, 140], float)
print(f"\n월별 매출 12개월: 이웃 차의 합 {tv(sales):.0f}, 범위 {sales.max()-sales.min():.0f}")
print(f"  크기 순으로 정렬하면 {tv(np.sort(sales)[::-1]):.0f} 로 줄어든다 — 범위와 같다")

자료 순서  [7, 3, 9, 1, 2]   이웃 차의 합 19
큰 순 정렬 [9, 7, 3, 2, 1]   이웃 차의 합 8   범위 8

120 가지 배열의 이웃 차 합: 최소 8, 최대 25
최소를 내는 배열의 개수 2

월별 매출 12개월: 이웃 차의 합 154, 범위 65
  크기 순으로 정렬하면 65 로 줄어든다 — 범위와 같다

import numpy as np

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

df_sorted = df.sort_values('교사 수')       # 가로 막대는 아래에서 위로 쌓이므로
                                           # 오름차순으로 정렬해야 위가 가장 크다
bars = ax.barh(df_sorted['과목'], df_sorted['교사 수'],
               color='steelblue', height=0.6)
ax.set_xlabel("교사 수")
ax.set_title("가로 막대그림")
ax.spines[['top', 'right']].set_visible(False)
plt.tight_layout()
plt.show()

# (1) 회전은 길이의 비를 바꾸지 않는다. 막대의 실제 길이와 자리를 재어 본다.
print(f"{'자리':>5}{'과목':>6}{'교사 수':>9}{'막대 길이':>11}{'y 중심':>9}")
for k, (name, x, b) in enumerate(zip(df_sorted['과목'], df_sorted['교사 수'], bars)):
    print(f"{k:>5}{name:>6}{x:>9}{b.get_width():>11.2f}"
          f"{b.get_y() + b.get_height()/2:>9.2f}")

v = df_sorted['교사 수'].to_numpy(float)
w = np.array([b.get_width() for b in bars])
print(f"\n길이의 비 (맨 위 / 맨 아래): 값 {v[-1]/v[0]:.6f},  막대 {w[-1]/w[0]:.6f}")
print(f"맨 위 막대 = {df_sorted['과목'].iloc[-1]} ({df_sorted['교사 수'].iloc[-1]}명)"
      f",  맨 아래 = {df_sorted['과목'].iloc[0]} ({df_sorted['교사 수'].iloc[0]}명)")

# (2) 이름표에 드는 가로 공간의 어림셈
names = df['과목'].tolist()
print(f"\n범주 {len(names)}개,  이름 글자 수 {[len(s) for s in names]}")
print(f"  세로 막대: 이름이 가로로 나란히 →  약 {sum(len(s) for s in names)}자 폭")
print(f"  가로 막대: 이름이 세로로 쌓임  →  약 {max(len(s) for s in names)}자 폭")

   자리    과목     교사 수      막대 길이     y 중심
    0    화학        1       1.00     0.00
    1    물리        2       2.00     1.00
    2    역사        3       3.00     2.00
    3    국어        7       7.00     3.00
    4    기하        9       9.00     4.00

길이의 비 (맨 위 / 맨 아래): 값 9.000000,  막대 9.000000
맨 위 막대 = 기하 (9명),  맨 아래 = 화학 (1명)

범주 5개,  이름 글자 수 [2, 2, 2, 2, 2]
  세로 막대: 이름이 가로로 나란히 →  약 10자 폭
  가로 막대: 이름이 세로로 쌓임  →  약 2자 폭

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd

plt.rcParams["font.family"] = "Apple SD Gothic Neo"   # 한글 글꼴
plt.rcParams["axes.unicode_minus"] = False            # 음수 기호가 네모가 되지 않게

data = {
    '학생': ['Brandon', 'Vanessa', 'Daniel', 'Kevin', 'William'],
    '중간고사': [85, 60, 60, 65, 100],
    '기말고사': [90, 90, 65, 80, 95]
}
df = pd.DataFrame(data).set_index('학생')

positions = np.arange(len(df))   # 학생마다 기준 위치 0, 1, 2, 3, 4
width = 0.3                      # 막대 하나의 폭

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

# 묶음 막대의 요령: 기준 위치에서 좌우로 반 폭씩 밀어 놓는다.
#   중간고사는 왼쪽(-width/2), 기말고사는 오른쪽(+width/2)
# 이렇게 하면 두 막대가 겹치지 않으면서 같은 학생끼리 붙어 있게 된다.
b1 = ax.bar(positions - width / 2, df['중간고사'], width=width, label="중간고사")
b2 = ax.bar(positions + width / 2, df['기말고사'], width=width, label="기말고사")
ax.set_xticks(positions)
ax.set_xticklabels(df.index)
ax.set_xlabel("학생")
ax.set_ylabel("점수")
ax.set_title("중간고사와 기말고사 점수")
ax.legend(title="시험 종류")
ax.spines['right'].set_visible(False)
ax.spines['top'].set_visible(False)
plt.show()

# (2) 모든 막대가 0 에서 출발한다. 아래끝을 재어 확인한다.
bottoms = [b.get_y() for b in list(b1) + list(b2)]
print(f"막대 {len(bottoms)}개의 아래끝: 최소 {min(bottoms):.2f}, 최대 {max(bottoms):.2f}")

# (1) 배치 공식이 맞는지 중심 위치를 재어 본다.
m, w = 2, width
print(f"\n{'학생':>9}{'중간':>7}{'기말':>7}{'중심(중간)':>12}{'중심(기말)':>12}")
for name, a, b, p1, p2 in zip(df.index, df['중간고사'], df['기말고사'], b1, b2):
    print(f"{name:>9}{a:>7}{b:>7}"
          f"{p1.get_x() + p1.get_width()/2:>12.2f}{p2.get_x() + p2.get_width()/2:>12.2f}")
print(f"배치 공식 p + (k - (m-1)/2) * w,  m = {m}, w = {w}:  "
      f"{-(m-1)/2*w:+.2f}, {(1-(m-1)/2)*w:+.2f}")
print(f"겹치지 않을 조건 m*w <= 1:  {m} * {w} = {m*w:.2f}")

# (2) 묶음 막대는 '변화'를 담지 않는다.
a = df['중간고사'].to_numpy(float)
b = df['기말고사'].to_numpy(float)
print(f"\n{'학생':>9}{'변화':>8}{'비':>9}")
for name, dd, q in zip(df.index, b - a, b / a):
    print(f"{name:>9}{dd:>+8.0f}{q:>9.4f}")
print(f"\n가장 긴 막대: {df.index[np.argmax(np.maximum(a, b))]}"
      f" ({max(a.max(), b.max()):.0f}점)")
print(f"가장 크게 변한 학생: {df.index[np.argmax(np.abs(b - a))]}"
      f" ({(b - a)[np.argmax(np.abs(b - a))]:+.0f}점)")
print(f"평균 변화 {np.mean(b - a):+.1f}점")

막대 10개의 아래끝: 최소 0.00, 최대 0.00

       학생     중간     기말      중심(중간)      중심(기말)
  Brandon     85     90       -0.15        0.15
  Vanessa     60     90        0.85        1.15
   Daniel     60     65        1.85        2.15
    Kevin     65     80        2.85        3.15
  William    100     95        3.85        4.15
배치 공식 p + (k - (m-1)/2) * w,  m = 2, w = 0.3:  -0.15, +0.15
겹치지 않을 조건 m*w <= 1:  2 * 0.3 = 0.60

       학생      변화        비
  Brandon      +5   1.0588
  Vanessa     +30   1.5000
   Daniel      +5   1.0833
    Kevin     +15   1.2308
  William      -5   0.9500

가장 긴 막대: William (100점)
가장 크게 변한 학생: Vanessa (+30점)
평균 변화 +10.0점

import matplotlib.pyplot as plt
import numpy as np

plt.rcParams["font.family"] = "Apple SD Gothic Neo"   # 한글 글꼴
plt.rcParams["axes.unicode_minus"] = False            # 음수 기호가 네모가 되지 않게

labels = ("있음", "없음")
counts = (np.array([95, 90, 40]), np.array([5, 10, 60]))
age_groups = ("성인", "어린이", "영아")

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

# 누적 막대의 요령: bottom 인자로 "이 막대가 어디서부터 시작할지"를 준다.
# 첫 막대는 0에서 시작하고, 다음 막대는 앞선 막대들의 합에서 시작한다.
bottom = np.zeros(3)
patches = {}

for label, count in zip(labels, counts):
    patches[label] = ax.bar(np.arange(3), count, width=0.5, bottom=bottom,
                            tick_label=age_groups, label=label)
    bottom += count          # 다음 막대의 출발점을 위로 올린다

ax.set_title("항체를 가지고 있는가?")
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
# bbox_to_anchor로 범례를 그림 바깥 오른쪽에 내보낸다
ax.legend(title="응답", loc="center left", bbox_to_anchor=(1.0, 0.5))
plt.tight_layout()
plt.show()

# (1) 조각의 아래끝과 위끝. 맨 아래 조각만 0 에서 출발한다.
print(f"{'집단':>7}{'조각':>7}{'길이':>7}{'아래끝':>9}{'위끝':>7}")
for label in labels:
    for g, b in zip(age_groups, patches[label]):
        print(f"{g:>7}{label:>7}{b.get_height():>7.0f}{b.get_y():>9.0f}"
              f"{b.get_y() + b.get_height():>7.0f}")
for label in labels:
    ys = np.array([b.get_y() for b in patches[label]])
    print(f"'{label}' 조각의 아래끝 {ys.astype(int).tolist()}  "
          f"퍼짐 {ys.max() - ys.min():.0f}")

# (2) 조각이 둘이고 합이 일정하면 둘째 조각은 첫째에서 복원된다.
T = counts[0] + counts[1]
print(f"\n세 집단의 합 {T.tolist()}")
print(f"둘째 조각 {counts[1].tolist()} = 합 - 첫째 {(T - counts[0]).tolist()}"
      f"   같은가 {np.array_equal(counts[1], T - counts[0])}")

# 조각이 셋이면 가운데 조각의 양 끝이 모두 제각각이다.
three = np.array([[95, 90, 40],     # 있음
                  [3, 6, 25],       # 모름
                  [2, 4, 35]], float)
tops = np.cumsum(three, axis=0)
bots = tops - three
print(f"\n조각 셋 (있음 / 모름 / 없음), 합 {tops[-1].astype(int).tolist()}")
for j, nm in enumerate(["있음", "모름", "없음"]):
    print(f"  {nm}: 길이 {three[j].astype(int).tolist()}  "
          f"아래끝 {bots[j].astype(int).tolist()}  퍼짐 {bots[j].max()-bots[j].min():.0f}")
print(f"가운데 조각의 길이 비 (영아 / 성인) = {three[1,2]/three[1,0]:.2f} 배"
      f" — 그런데 두 조각이 높이 {bots[1,0]:.0f} 와 {bots[1,2]:.0f} 에 떠 있다")

     집단     조각     길이      아래끝     위끝
     성인     있음     95        0     95
    어린이     있음     90        0     90
     영아     있음     40        0     40
     성인     없음      5       95    100
    어린이     없음     10       90    100
     영아     없음     60       40    100
'있음' 조각의 아래끝 [0, 0, 0]  퍼짐 0
'없음' 조각의 아래끝 [95, 90, 40]  퍼짐 55

세 집단의 합 [100, 100, 100]
둘째 조각 [5, 10, 60] = 합 - 첫째 [5, 10, 60]   같은가 True

조각 셋 (있음 / 모름 / 없음), 합 [100, 100, 100]
  있음: 길이 [95, 90, 40]  아래끝 [0, 0, 0]  퍼짐 0
  모름: 길이 [3, 6, 25]  아래끝 [95, 90, 40]  퍼짐 55
  없음: 길이 [2, 4, 35]  아래끝 [98, 96, 65]  퍼짐 33
가운데 조각의 길이 비 (영아 / 성인) = 8.33 배 — 그런데 두 조각이 높이 95 와 40 에 떠 있다

import matplotlib.pyplot as plt
import numpy as np

plt.rcParams["font.family"] = "Apple SD Gothic Neo"   # 한글 글꼴
plt.rcParams["axes.unicode_minus"] = False            # 음수 기호가 네모가 되지 않게

# 같은 자료를 y축만 달리해 두 번 그린다. 숫자는 하나도 건드리지 않는다.
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 3.5))

# 최대와 최소의 차이가 6%쯤 되는, 사실상 고만고만한 네 값이다.
vals = [102, 105, 103, 108]
names = ['A', 'B', 'C', 'D']

ax1.bar(names, vals, color='indianred')
ax1.set_ylim(0, 120)                      # 0에서 시작 — 정직한 그림
ax1.set_title("y축이 0에서 시작 — 정직한 그림")

ax2.bar(names, vals, color='indianred')
ax2.set_ylim(100, 110)                    # 축을 잘라 냄 — 차이가 과장된다
ax2.set_title("y축을 잘라 냄 — 차이가 과장된다")

for ax in (ax1, ax2):
    ax.spines[['top', 'right']].set_visible(False)
plt.tight_layout()
plt.show()

# (1)(2) 기준선 b 를 올릴 때 길이비가 어떻게 커지는가. y1 = 102, y2 = 100.
y1, y2 = 102.0, 100.0
print(f"참 비 y1/y2 = {y1/y2:.4f}")
print(f"{'기준선 b':>10}{'길이 y1-b':>11}{'길이 y2-b':>11}{'길이비':>10}{'왜곡 배율':>11}")
for b in [0.0, 50.0, 95.0, 99.0, 99.9, 99.99]:
    r = (y1 - b) / (y2 - b)
    print(f"{b:>10.2f}{y1-b:>11.2f}{y2-b:>11.2f}{r:>10.4f}{r/(y1/y2):>11.4f}")

# 네 값 자료에서도 같은 일이 일어난다.
v = np.array(vals, float)
for b in [0.0, 100.0]:
    L = v - b
    print(f"\n기준선 {b:.0f}: 막대 길이 {L.astype(int).tolist()}"
          f"   D/A = {L[3]/L[0]:.4f}   (참 비 {v[3]/v[0]:.4f})")

# (3) 선그림은 왜 예외인가. 기울기는 기준선에 무관하다.
print("\n선그림의 기울기 (이웃 값의 차) — 기준선을 바꿔도 같다")
for b in [0.0, 100.0, 101.9]:
    print(f"  b = {b:>5.1f}:  {np.diff(v - b).astype(int).tolist()}")

참 비 y1/y2 = 1.0200
     기준선 b    길이 y1-b    길이 y2-b       길이비      왜곡 배율
      0.00     102.00     100.00    1.0200     1.0000
     50.00      52.00      50.00    1.0400     1.0196
     95.00       7.00       5.00    1.4000     1.3725
     99.00       3.00       1.00    3.0000     2.9412
     99.90       2.10       0.10   21.0000    20.5882
     99.99       2.01       0.01  201.0000   197.0588

기준선 0: 막대 길이 [102, 105, 103, 108]   D/A = 1.0588   (참 비 1.0588)

기준선 100: 막대 길이 [2, 5, 3, 8]   D/A = 4.0000   (참 비 1.0588)

선그림의 기울기 (이웃 값의 차) — 기준선을 바꿔도 같다
  b =   0.0:  [3, -2, 5]
  b = 100.0:  [3, -2, 5]
  b = 101.9:  [3, -2, 5]

import numpy as np
import matplotlib.pyplot as plt

plt.rcParams["font.family"] = "Apple SD Gothic Neo"   # 한글 글꼴
plt.rcParams["axes.unicode_minus"] = False            # 음수 기호가 네모가 되지 않게

labels = ["A", "B", "C", "D", "E"]
values = np.array([23, 21, 19, 19, 18], float)      # 서로 매우 가깝다

print("실제 비율")
for l, v in zip(labels, values / values.sum()):
    print(f"  {l}: {v:.4f}")
print(f"\n최댓값/최솟값 비 {values.max() / values.min():.4f}")
print(f"각도로는 {values.max() / values.sum() * 360:.1f}도 대 "
      f"{values.min() / values.sum() * 360:.1f}도 — 눈으로 구별하기 어렵다")

fig, axes = plt.subplots(1, 2, figsize=(11, 4.5))
axes[0].pie(values, labels=labels, autopct=None, startangle=90)
axes[0].set_title("원그림 — 순위를 읽기 어렵다", fontsize=10)
axes[1].barh(labels[::-1], values[::-1])
axes[1].set_title("가로 막대 — 순위가 즉시 보인다", fontsize=10)
axes[1].set_xlabel("값")
fig.tight_layout()
plt.show()

실제 비율
  A: 0.2300
  B: 0.2100
  C: 0.1900
  D: 0.1900
  E: 0.1800

최댓값/최솟값 비 1.2778
각도로는 82.8도 대 64.8도 — 눈으로 구별하기 어렵다

import numpy as np
import matplotlib.pyplot as plt

plt.rcParams["font.family"] = "Apple SD Gothic Neo"   # 한글 글꼴
plt.rcParams["axes.unicode_minus"] = False            # 음수 기호가 네모가 되지 않게

groups = ["1분기", "2분기", "3분기"]
seg = np.array([[30, 20, 15], [45, 18, 14], [20, 22, 16]], float)  # 행=막대, 열=층

print(f"1층 값 {seg[:, 0]}  → 바닥이 모두 0 이라 비교가 쉽다")
print(f"2층 값 {seg[:, 1]}  → 시작 높이가 {seg[:, 0]} 로 제각각")
print(f"\n2층의 실제 크기 순위     {np.argsort(-seg[:, 1]) + 1}")
print(f"2층 '윗변 높이' 순위     {np.argsort(-(seg[:, 0] + seg[:, 1])) + 1}   ← 눈이 읽는 것")

fig, axes = plt.subplots(1, 2, figsize=(11, 4))
bottom = np.zeros(3)
for j, name in enumerate(["층 1", "층 2", "층 3"]):
    axes[0].bar(groups, seg[:, j], bottom=bottom, label=name)
    bottom += seg[:, j]
axes[0].legend(fontsize=8)
axes[0].set_title("누적 — 2층·3층 비교가 어렵다", fontsize=10)

w = 0.26
xs = np.arange(3)
for j, name in enumerate(["층 1", "층 2", "층 3"]):
    axes[1].bar(xs + (j - 1) * w, seg[:, j], width=w, label=name)
axes[1].set_xticks(xs); axes[1].set_xticklabels(groups)
axes[1].legend(fontsize=8)
axes[1].set_title("묶음 — 모든 층이 같은 바닥에서 출발", fontsize=10)
fig.tight_layout()
plt.show()

1층 값 [30. 45. 20.]  → 바닥이 모두 0 이라 비교가 쉽다
2층 값 [20. 18. 22.]  → 시작 높이가 [30. 45. 20.] 로 제각각

2층의 실제 크기 순위     [3 1 2]
2층 '윗변 높이' 순위     [2 1 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(0)
groups = {
    "대칭":  rng.normal(50, 10, 300),
    "치우침": 50 + (rng.exponential(10, 300) - 10),
    "이봉":  np.concatenate([rng.normal(35, 4, 150), rng.normal(65, 4, 150)]),
    "이상치": np.concatenate([rng.normal(48, 3, 297), [150, 160, 170]]),
}

print(f"{'집단':>8}{'평균':>9}{'표준편차':>10}{'중앙값':>9}{'IQR':>9}")
for name, v in groups.items():
    q1, q3 = np.percentile(v, [25, 75])
    print(f"{name:>8}{v.mean():>9.2f}{v.std(ddof=1):>10.2f}{np.median(v):>9.2f}{q3 - q1:>9.2f}")

fig, axes = plt.subplots(1, 2, figsize=(11, 4), sharey=True)
names = list(groups)
axes[0].bar(names, [v.mean() for v in groups.values()])
axes[0].set_title("막대(평균) — 넷이 똑같아 보인다", fontsize=10)
for i, v in enumerate(groups.values()):
    axes[1].scatter(np.full(len(v), i) + rng.normal(0, 0.07, len(v)), v, s=4, alpha=0.25)
axes[1].set_xticks(range(4)); axes[1].set_xticklabels(names)
axes[1].set_title("원자료 — 전혀 다르다", fontsize=10)
axes[1].set_ylim(0, 100)
fig.tight_layout()
plt.show()

      집단       평균      표준편차      중앙값      IQR
      대칭    49.64     10.20    49.23    13.86
     치우침    49.85     10.01    47.21    10.55
      이봉    49.89     15.62    50.06    30.04
     이상치    48.95     11.59    47.89     3.96

import numpy as np

rng = np.random.default_rng(3)
K, n = 10, 40
true_rate = 0.30                                   # 열 지점의 참 비율이 모두 같다
counts = rng.binomial(n, true_rate, K)
rates = counts / n
order = np.argsort(-rates)

print(f"참 비율은 열 지점 모두 {true_rate}")
print(f"관측 비율(정렬 후) {np.round(rates[order], 3)}")
print(f"\n1위 {rates[order][0]:.3f}   꼴찌 {rates[order][-1]:.3f}   차이 {rates[order][0] - rates[order][-1]:.3f}")
se = np.sqrt(true_rate * (1 - true_rate) / n)
print(f"단일 비율의 표준오차 {se:.4f}  → 차이는 표준오차 {(rates[order][0] - rates[order][-1]) / (se * np.sqrt(2)):.2f} 배")

참 비율은 열 지점 모두 0.3
관측 비율(정렬 후) [0.35  0.35  0.325 0.3   0.275 0.25  0.225 0.225 0.2   0.2  ]

1위 0.350   꼴찌 0.200   차이 0.150
단일 비율의 표준오차 0.0725  → 차이는 표준오차 1.46 배

import numpy as np
import matplotlib.pyplot as plt

plt.rcParams["font.family"] = "Apple SD Gothic Neo"   # 한글 글꼴
plt.rcParams["axes.unicode_minus"] = False            # 음수 기호가 네모가 되지 않게

years = ["2021", "2022", "2023", "2024"]
a = np.array([200, 260, 340, 430], float)      # 성분 A
b = np.array([600, 700, 820, 960], float)      # 성분 B
total = a + b

print(f"{'연도':>6}{'A':>8}{'B':>8}{'합계':>9}{'A 비율':>10}")
for y, x, z, t in zip(years, a, b, total):
    print(f"{y:>6}{x:>8.0f}{z:>8.0f}{t:>9.0f}{x / t:>10.4f}")
print(f"\nA 는 {a[0]:.0f} → {a[-1]:.0f} 로 {a[-1] / a[0]:.2f}배 늘었다")
print(f"그런데 A 비율은 {a[0] / total[0]:.3f} → {a[-1] / total[-1]:.3f} 로 거의 그대로다")

fig, axes = plt.subplots(1, 2, figsize=(11, 4))
axes[0].bar(years, a / total, label="A")
axes[0].bar(years, b / total, bottom=a / total, label="B")
axes[0].set_title("100% 누적 — 아무 변화도 없어 보인다", fontsize=10)
axes[0].legend(fontsize=8)
axes[1].bar(years, a, label="A")
axes[1].bar(years, b, bottom=a, label="B")
axes[1].set_title("절대량 누적 — 둘 다 크게 늘었다", fontsize=10)
axes[1].legend(fontsize=8)
fig.tight_layout()
plt.show()

    연도       A       B       합계      A 비율
  2021     200     600      800    0.2500
  2022     260     700      960    0.2708
  2023     340     820     1160    0.2931
  2024     430     960     1390    0.3094

A 는 200 → 430 로 2.15배 늘었다
그런데 A 비율은 0.250 → 0.309 로 거의 그대로다

departments = [("A 부서", 120, 900), ("B 부서", 60, 300)]

print("승진 인원과 승진율")
total_p = total_n = 0
for name, promoted, eligible in departments:
    print(f"  {name}: 승진 {promoted}명 / 대상 {eligible}명 = {promoted / eligible:.4f}")
    total_p += promoted
    total_n += eligible
print(f"  전체:   {total_p}/{total_n} = {total_p / total_n:.4f}")

승진 인원과 승진율
  A 부서: 승진 120명 / 대상 900명 = 0.1333
  B 부서: 승진 60명 / 대상 300명 = 0.2000
  전체:   180/1200 = 0.1500

import numpy as np
import matplotlib.pyplot as plt

plt.rcParams["font.family"] = "Apple SD Gothic Neo"   # 한글 글꼴
plt.rcParams["axes.unicode_minus"] = False            # 음수 기호가 네모가 되지 않게

labels = ["A", "B", "C", "D"]
values = np.array([97.2, 98.1, 97.6, 98.4])

fig, axes = plt.subplots(1, 3, figsize=(13, 3.8))
axes[0].bar(labels, values, color="steelblue")
axes[0].set_ylim(97, 98.6)
axes[0].set_title("① 축 자르기", fontsize=9)

axes[1].bar(labels, values, color="steelblue")
axes[1].set_ylim(0, 100)
axes[1].set_title("② 정직한 축", fontsize=9)

diff = values - values.mean()
axes[2].bar(labels, diff, color=np.where(diff >= 0, "steelblue", "indianred"))
axes[2].axhline(0, color="black", lw=0.8)
axes[2].set_title("③ 평균 대비 편차 — 정직하게 강조", fontsize=9)
fig.tight_layout()
plt.show()

print(f"값의 범위 {values.min()} ~ {values.max()}  (차이 {values.ptp():.1f})")
print(f"평균 대비 상대적 차이 {values.ptp() / values.mean() * 100:.2f}%")

값의 범위 97.2 ~ 98.4  (차이 1.2)
평균 대비 상대적 차이 1.23%