🔖 キーワード索引

「オブジェクト指向プログラミング」を取り巻く中核キーワード群です。 検索やインデックス作成で参照する際の手がかりにしてください。 各キーワードは関連する概念・手法・道具立てを含み、 文献検索や学習計画の起点になります。

🎨 直感で掴む

「車」というクラスを考えます：

• 属性（データ）：色、 メーカー、 速度
• メソッド（処理）：加速する、 停止する、 警笛を鳴らす

「私の車」は車クラスの インスタンス。 「スポーツカー」は車を 継承 した子クラス。 「加速する」を「ターボ加速する」に オーバーライド できる — これがポリモーフィズム。

🎨 概念図で押さえる — OOP の3つの視点

OOP の理解には、 (1) クラス継承の木構造、 (2) インスタンスの集約とクラスタリング、 (3) クラス比較によるポリモーフィズム判定 の 3 点を同時に把握する必要があります。 ここでは html/glossary/figures/ にある既存図を借りて、 OOP 設計のキャンバスを描き出します。

読み取るポイント:

• 木の深さ → 継承階層数、 4 以上は危険信号
• 分岐数 → サブクラス数、 SOLID 原則の S (単一責任) で判定
• リーフの粒度 → 具体クラスが具体的すぎないか確認

読み取るポイント:

• クラスタの分離 → クラス分割の妥当性、 明瞭ならクラス抽出 OK
• 境界のあいまいさ → サブクラス化やインターフェース分離の必要性
• 外れ値の存在 → 特殊ケース処理、 別クラス・例外的ふるまいを検討

読み取るポイント:

• 結果の違い → 各実装の責務、 ポリモーフィズムの効果
• 共通インターフェース → 抽象基底クラスの設計指針
• 切替の容易さ → 戦略パターン適用の有効性

この 3 枚を順に追うと、 「継承階層の設計 → クラス抽出 → ポリモーフィズム活用」 という OOP 設計の三本柱が体系化される。 関連用語 NumPy / API / scikit-learn へ進むと、 各図の理論背景を深掘りできる。

🧠 理解度チェック

1分で答えられる確認問題。 まず自分で答えを書き出してから解答を開きましょう。 SSDSE-B-2026 を扱う場面に当てはめて考えると定着しやすい。

🎮 インタラクティブ体感 — クラス／インスタンス／継承／多態性

OOP の4つの核 — クラス（設計図）・インスタンス（実体）・継承・多態性（ポリモーフィズム） — を、 実際に ブラウザ内で動く簡易クラス で体感します。 下のデモの描画やふるまいは、 このページの <script> 内に定義した本物の JavaScript クラス（class Shape / class Circle extends Shape …）が動かしています。 CDN も外部ライブラリも一切使わず、 オフラインで完結します。

① クラスからインスタンスを量産 — 状態は各自で独立

「Cat クラス」という 1枚の設計図 から、 猫（インスタンス）を何匹でも生成できます。 設計図は 属性（データ） と メソッド（操作） を定義するだけ。 生成された各インスタンスは name / x / energy といった 状態を個別に 持ち、 1匹に feed() しても他の猫は太りません。 これが「クラスは共有、 状態は独立」という OOP の骨格です。

② 継承 — 親クラスの資産を子が受け継ぎ、 拡張・上書きする

Animal（親）は name 属性と move()・speak() メソッドを持ちます。 Dog・Cat（子）は extends Animal で 親の資産を丸ごと継承 し、 さらに speak() を各自の鳴き声に 上書き（override）、 Dog は独自メソッド fetch() を 拡張 します。 下の親子図でボタンを押すと、 どのメソッドが「継承」「上書き」「新規」なのかが色分けで光ります。

③ 多態性 — 同じ draw()・area() で違うふるまい

Shape を継承した Circle（円）・Square（四角）・Triangle（三角）は、 すべて同じ名前のメソッド draw() と area() を持ちます。 呼ぶ側は種類を気にせず for (const s of shapes) s.draw(ctx) と 一律に呼ぶだけ。 中身は各クラスが自分の流儀で実装しているので、 描かれる形も面積の公式も自動で切り替わります。 これが多態性（ポリモーフィズム）— 「同じ命令、 違う結果」です。

体感のまとめ: ①で「設計図と実体は別物・状態は独立」、 ②で「継承は資産の再利用＋上書き＋拡張」、 ③で「同じインターフェースに違う実装を差せる（多態）」を掴めたはず。 コード側で fit() / predict() を持つ scikit-learn の推定器も、 まさにこの③の多態性で「どのモデルでも同じ呼び方」を実現しています。 内部でデータ配列を扱う NumPy や、 外部に操作を公開する API の設計思想も、 この体感が土台になります。

📐 数式または定義

OOP は「データ（属性）と、 それを操作する処理（メソッド）を オブジェクト という 1 つの単位に束ねる」設計パラダイムである。 特定の数式で定義される計算手法ではなく、 プログラムをどう構造化するかという考え方を指す点が、 統計量や機械学習アルゴリズムのような他の用語と大きく異なる。

あえて最小限の形式で表すなら、 オブジェクトは「状態（属性の集まり）」と「振る舞い（メソッドの集まり）」の組と見なせる：

$$\text{オブジェクト} = (\text{状態},\ \text{振る舞い})$$

ここで状態はそのオブジェクトが保持するデータ、 振る舞いはそのデータに対して定義された操作を指す。 同じクラスから作られたインスタンスは、 状態は個別に持つが振る舞い（メソッド）を共有する。 これ以上の数式化は不要で、 OOP の本質は「何をひとまとまりの単位として設計するか」という設計上の判断にある。

🔬 記号・要素の読み解き

🔬 数式を言葉で読み解く

オブジェクト指向プログラミング（OOP）は、 データ（属性）とそれに対する操作（メソッド）を「オブジェクト」に統合する設計パラダイム。 SSDSE-B-2026 のような表データを扱うとき、 Pandas DataFrame そのものがオブジェクトで、 .head()、 .groupby()、 .merge() がメソッドです。 OOP の理解は Python データ分析の中核。

① 4 つの柱（4 Pillars）

OOP の 4 本柱は、 いずれも「オブジェクト＝状態（属性）＋ 振る舞い（メソッド）」という 1 単位を軸に整理できる。 同じクラスから作られたインスタンスは、 状態（属性値）は個別に持つが、 振る舞い（メソッド）はクラスで共有する — この「まとめ方」の工夫こそが OOP の要点であり、 数式で定義されるものではない。

② SOLID 原則

③ Python の OOP 構文

SSDSE-B-2026 を OOP で扱う

オブジェクト指向プログラミング を含むデータ分析は、 分野によって使われ方が違います。 下の表は分野ごとの代表的な用途で、 オブジェクト指向プログラミング だけの用途一覧ではありません。 自分の分野の行を見て、 どんな問いにデータを使うのかを掴んでください。

🏭 産業界での活用事例（6 件）

⚖️ プログラミングパラダイムの比較表

💥 失敗例から学ぶ

📝 演習問題（5 問・解答付き）

1. 問題：SSDSE-B-2026 の各都道府県を Prefecture クラスのインスタンスに変換せよ。
   ▼ 解答

   📥 入力例（SSDSE-B-2026 の 2023 年・47 都道府県から 3 行） 都道府県 SSDSE-B-2026(年度) Prefecture(都道府県) A1101(総人口) A4101(出生数) 北海道 2,023 北海道 5,092,000 24,430 東京都 2,023 東京都 14,086,000 86,348 沖縄県 2,023 沖縄県 1,468,000 12,549 …（全 47 行）

   📋 コピー

   1 2 3 4 5 6 7 8 9 10 11 12

   import pandas as pd class Prefecture: def __init__(self, name, pop, births): self.name, self.pop, self.births = name, pop, births def birth_rate(self): return self.births / self.pop * 1000 df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=1) # 日本語の列名で読む（2 行目を見出しにする） d = df[df['年度']==2023] prefs = [Prefecture(r['都道府県'], r['総人口'], r['出生数']) for _, r in d.iterrows()] print(f"{prefs[0].name}: 人口{prefs[0].pop:,}, 出生率{prefs[0].birth_rate():.2f}‰") # 北海道: 人口5,092,000, 出生率4.80‰

   📤 実行例（実測） 北海道: 人口5,092,000, 出生率4.80‰
2. 問題：Prefecture を継承して BigCity（人口 500 万超）クラスを作れ。
   ▼ 解答

   📋 コピー

   1 2 3 4 5 6 7 8

   class BigCity(Prefecture): THRESHOLD = 5_000_000 def is_megacity(self): return self.pop > self.THRESHOLD big = BigCity('東京都', 14086000, 86348) print(big.is_megacity()) # True print(big.birth_rate()) # 継承で利用可

   📤 実行例（実測） True 6.130058213829335
3. 問題：__str__ メソッドで Prefecture をきれいに print できるようにせよ。
   ▼ 解答

   📋 コピー

   1 2 3 4 5

   class Prefecture: def __init__(self, name, pop): self.name, self.pop = name, pop def __str__(self): return f"<Prefecture {self.name}: {self.pop:,}人>" p = Prefecture('東京都', 14086000) print(p) # <Prefecture 東京都: 14,086,000人>

   📤 実行例（実測） <Prefecture 東京都: 14,086,000人>
4. 問題：クラスメソッド from_csv_row を使って Prefecture を生成せよ。
   ▼ 解答

   📥 入力例（SSDSE-B-2026 の 2023 年・47 都道府県から 3 行） 都道府県 Prefecture(都道府県) A1101(総人口) A4101(出生数) 北海道 北海道 5,092,000 24,430 東京都 東京都 14,086,000 86,348 沖縄県 沖縄県 1,468,000 12,549 …（全 47 行）

   📋 コピー

   1 2 3 4 5 6 7 8 9

   class Prefecture: def __init__(self, name, pop, births): self.name, self.pop, self.births = name, pop, births @classmethod def from_csv_row(cls, row): return cls(row['都道府県'], row['総人口'], row['出生数']) import pandas as pd df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=1) # 日本語の列名で読む（2 行目を見出しにする） p = Prefecture.from_csv_row(df.iloc[0]) print(p.name, p.pop)

   📤 実行例（実測） 北海道 5092000
5. 問題：ポリモーフィズムで「単独県」と「複数県集計」を同じ population() メソッドで扱え。
   ▼ 解答

   class Single:
       def __init__(self, p): self.p = p
       def population(self): return self.p.pop
   class Multi:
       def __init__(self, ps): self.ps = ps
       def population(self): return sum(p.pop for p in self.ps)
   # 両方とも .population() で呼べる = ポリモーフィズム

📖 関連用語辞典（10 語）

クラス（class）

オブジェクトの設計図。 属性とメソッドを定義。

インスタンス（instance）

クラスから生成された具体的オブジェクト。

継承（inheritance）

親クラスの属性・メソッドを子が引き継ぐ。

ポリモーフィズム

同じインタフェースで型に応じた異なる動作。

カプセル化

内部状態を隠蔽、 公開メソッド経由で操作。

抽象クラス

直接インスタンス化せず、 派生クラスのインタフェース定義。 Python は abc.ABC。

メタクラス

クラスを生成するクラス。 通常は type。

ダックタイピング

「アヒルのように鳴くならアヒル」。 Python の型システムの基本。

デコレータ

クラス・メソッドの振る舞いを修飾。 @property, @classmethod, @staticmethod。

データクラス

@dataclass で __init__/__repr__/__eq__ を自動生成。 Python 3.7+。

🔬 SSDSE-B-2026 で OOP 総合実習

実習：地方ブロック単位の集計を OOP で実装

🎯 やること：47 都道府県を「北海道・東北・関東・中部・近畿・中国・四国・九州」の 8 ブロックに分け、 各ブロックの人口・出生数を Composite パターンで集計。 各レベルで同じ .population() インタフェースが動く（ポリモーフィズム）。

📥 入力：SSDSE-B-2026 の 2023 年データ 47 行。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

import pandas as pd
from abc import ABC, abstractmethod
from dataclasses import dataclass, field

# 抽象基底
class Region(ABC):
    @abstractmethod
    def population(self) -> int: ...
    @abstractmethod
    def name(self) -> str: ...

# 葉ノード：個別都道府県
@dataclass
class Prefecture(Region):
    _name: str
    _pop:  int
    def population(self) -> int: return self._pop
    def name(self) -> str:      return self._name

# 複合ノード：地方ブロック
@dataclass
class Block(Region):
    _name: str
    members: list = field(default_factory=list)
    def population(self) -> int: return sum(m.population() for m in self.members)
    def name(self) -> str:      return self._name

# 地方区分
BLOCKS = {
    '北海道': ['北海道'],
    '東北':   ['青森県','岩手県','宮城県','秋田県','山形県','福島県'],
    '関東':   ['茨城県','栃木県','群馬県','埼玉県','千葉県','東京都','神奈川県'],
    '中部':   ['新潟県','富山県','石川県','福井県','山梨県','長野県','岐阜県','静岡県','愛知県'],
    '近畿':   ['三重県','滋賀県','京都府','大阪府','兵庫県','奈良県','和歌山県'],
    '中国':   ['鳥取県','島根県','岡山県','広島県','山口県'],
    '四国':   ['徳島県','香川県','愛媛県','高知県'],
    '九州':   ['福岡県','佐賀県','長崎県','熊本県','大分県','宮崎県','鹿児島県','沖縄県'],
}

# データ取得
df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=1)
d  = df[df['年度']==2023]
pop_map = dict(zip(d['都道府県'], d['総人口']))

# Composite 構築
blocks = [
    Block(b, [Prefecture(p, pop_map[p]) for p in prefs])
    for b, prefs in BLOCKS.items()
]
nation = Block('日本', blocks)

# レポート出力（ポリモーフィズム）
for b in blocks:
    print(f"{b.name():4s}: {b.population():>11,} 人 ({len(b.members)} 県)")
print('-' * 40)
print(f"{nation.name():4s}: {nation.population():>11,} 人")

📤 実行結果：

💬 結果の読み方：Composite パターンで「個別県」と「ブロック」と「全国」を同じインタフェース（population()）で扱える。 関東が 4,350 万人（全国の 35%）と圧倒的、 東京一極集中を構造的に示す。 OOP の真価は「データ階層を自然に反映できる」こと。

🧮 実値で計算してみる

機械学習推定器の典型的 OOP 設計：

• 共通基底クラス Estimator が fit() と predict() を約束
• LinearRegression, RandomForest, SVM がそれを 継承
• 使う側は model.fit(X, y); model.predict(X_new) と 同じインタフェースで呼べる
• これが ポリモーフィズム。 アルゴリズムを差し替えてもコード変更は最小限

🧮 数式に値を入れて手で計算する: クラスのメンバーカウント

合成データで 3 クラスのインスタンス数と継承階層を集計する。

Step 1: クラス階層

Step 2: 継承で増えるメソッド

🐍 Python で再現

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

class Animal:
    def eat(self): pass
    def sleep(self): pass
    def breathe(self): pass

class Dog(Animal):
    def bark(self): pass
    def fetch(self): pass

class Puppy(Dog):
    def play(self): pass

print(f"Puppy メソッド (継承含む): {len([m for m in dir(Puppy) if not m.startswith('_')])}")

📤 実行結果

💬 手計算 (Step 2) 6 と Python 出力が完全一致。

🐍 Python での扱い

最小再現コード。 SSDSE-B のような実データを前提に、 4〜8 行で動く例です：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

class Estimator:
    def fit(self, X, y):  raise NotImplementedError
    def predict(self, X): raise NotImplementedError

class MeanRegressor(Estimator):
    def fit(self, X, y):  self.mu = sum(y)/len(y); return self
    def predict(self, X): return [self.mu]*len(X)

m = MeanRegressor().fit([[1],[2],[3]], [10,20,30])
print(m.predict([[1],[2]]))  # [20.0, 20.0]

補足：ライブラリのバージョンや前処理状態によって出力は変わります。 自分の環境で動かすときは pip list でバージョンを確認し、 入力 CSV のパス・列名を実態に合わせてください。

🐍 Python 完全コード（4 要素ナレーション付き）

コード 1：SSDSE-B-2026 を Prefecture クラス群に変換

🎯 このコードでやること：CSV を読み込み、 47 都道府県（2023 年）を Prefecture クラスのインスタンスリストに変換。 各インスタンスは name / population / birth_count 属性と birth_rate() メソッドを持つ。

📥 入力データ：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

import pandas as pd
from dataclasses import dataclass

@dataclass
class Prefecture:
    name: str
    population: int
    births: int
    tfr: float  # 合計特殊出生率

    def birth_rate(self) -> float:
        return self.births / self.population * 1000

    def __repr__(self) -> str:
        return f"<{self.name}: 人口{self.population:,} 出生率{self.birth_rate():.2f}‰>"

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=1)
d  = df[df['年度']==2023]
prefs = [
    Prefecture(r['都道府県'], r['総人口'], r['出生数'], r['合計特殊出生率'])
    for _, r in d.iterrows()
]
for p in prefs[:3]:
    print(p)
print(f"最大: {max(prefs, key=lambda x: x.population).name}")

📤 実行結果：

💬 結果の読み方：47 都道府県が Prefecture オブジェクトとして表現され、 各オブジェクトに .name, .population, .birth_rate() が紐づく。 dataclass で __init__ 自動生成、 __repr__ をカスタムして読みやすく。 人口最大は東京都 14,086,000 人。 OOP の利点：「データ＋振る舞い」を 1 箇所に統合。

コード 2：継承で BigCity / Prefecture 階層

🎯 このコードでやること：500 万人超を「大都市圏（BigCity）」として継承クラスで表現、 ポリモーフィズムで統一処理。

📥 入力データ：上記 prefs 47 件。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

import pandas as pd
from dataclasses import dataclass, field

@dataclass
class Prefecture:
    name: str
    population: int
    def category(self) -> str:
        return '一般県'

@dataclass
class BigCity(Prefecture):
    THRESHOLD = 5_000_000
    def category(self) -> str:
        return '大都市圏' if self.population > self.THRESHOLD else '一般県'

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=1)
d  = df[df['年度']==2023]
prefs = [BigCity(r['都道府県'], r['総人口']) for _, r in d.iterrows()]
big = [p for p in prefs if p.category() == '大都市圏']
print(f"大都市圏: {len(big)} 県")
for p in big:
    print(f"  {p.name} {p.population:,}")

📤 実行結果：

💬 結果の読み方：500 万人超の都道府県は 9 件（北海道・関東 4 都県・愛知・大阪・兵庫・福岡）。 category() をオーバーライドすることで、 Prefecture と BigCity を同じ for ループで処理できる（ポリモーフィズム）。

コード 3：クラスメソッド・プロパティ・コンテキストマネージャの統合

🎯 このコードでやること：Prefecture に @classmethod from_csv() でファクトリ、 @property で計算属性、 __enter__/__exit__ でリソース管理を実装。

📥 入力データ：CSV ファイルパス。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

import pandas as pd

class PrefectureDataset:
    def __init__(self, df):
        self.df = df
    @classmethod
    def from_csv(cls, path, year=2023):
        df = pd.read_csv(path, encoding='cp932', skiprows=1)
        return cls(df[df['年度']==year].copy())
    @property
    def n(self):
        return len(self.df)
    @property
    def total_population(self):
        return self.df['総人口'].sum()
    def __enter__(self):
        print(f"データセット開始: {self.n} 県")
        return self
    def __exit__(self, *a):
        print("データセット終了")

with PrefectureDataset.from_csv('data/raw/SSDSE-B-2026.csv', 2023) as ds:
    print(f"全国人口合計: {ds.total_population:,}人")
    print(f"平均人口: {ds.total_population / ds.n:,.0f}人")

📤 実行結果：

💬 結果の読み方：3 つの OOP 機能を一度に活用。 @classmethod で「CSV からインスタンス化」する別コンストラクタ、 @property で計算結果を属性アクセスで取得、 with 文でリソース取得・解放を自動化。 全国合計人口 1.26 億人、 平均約 269 万人/県。

❓ FAQ 20 問

📖 オブジェクト指向プログラミングの包括ガイド（追補編）

📜 OOP 進化の年表

⚙️ Python OOP の特殊機能

__slots__

インスタンス属性を固定し、 メモリ消費を 40〜50% 削減。 1 万件以上のインスタンスを扱う SSDSE-B-2026 拡張（市区町村レベル）では効く。

class Prefecture:
    __slots__ = ('name', 'population', 'births')
    def __init__(self, name, pop, births):
        self.name, self.population, self.births = name, pop, births

__init_subclass__

サブクラス作成時に自動で呼ばれるフック。 クラス階層の検証や登録に使う。

Descriptors

@property、 @cached_property の背後にある仕組み。 __get__/__set__/__delete__ で属性アクセスを完全制御。

ABC（Abstract Base Class）

1
2
3
4
5
6
7
8

from abc import ABC, abstractmethod
class DataSource(ABC):
    @abstractmethod
    def load(self) -> "pd.DataFrame": ...
class SSDSESource(DataSource):
    def load(self):
        import pandas as pd
        return pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])

Protocol（PEP 544, Structural Subtyping）

1
2
3
4

from typing import Protocol
class Sortable(Protocol):
    def __lt__(self, other) -> bool: ...
# クラスが __lt__ を実装すれば自動で Sortable とみなされる（duck typing の型版）

🎯 SOLID 原則を SSDSE-B-2026 解析で実践

S — 単一責任原則

悪い例：SSDSEAnalyzer 1 クラスで読込・前処理・可視化・保存。 良い例：SSDSELoader + SSDSEPreprocessor + SSDSEPlotter + SSDSEExporter に分離。

O — 開閉原則

新しいデータソース（SSDSE-A、 SSDSE-C）を追加する際、 既存コード修正なし。 抽象基底 SSDSESource に対し SSDSEBSource, SSDSEASource を派生。

L — リスコフ置換原則

SSDSESource 型変数に SSDSEBSource インスタンスを代入しても、 .load() 呼出しが期待通り動作。 違反例：「子クラスが特定条件で例外を投げる」のは LSP 違反。

I — インタフェース分離原則

Readable, Writable, Plottable を分けて、 必要なものだけ実装。

D — 依存性逆転原則

具象 SSDSEBSource に依存せず、 抽象 DataSource に依存。 テストでモックに差し替え可。

🧩 GoF デザインパターンと SSDSE-B-2026

🔧 SSDSE-B-2026 を OOP で完全モデル化する例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

from dataclasses import dataclass, field
from abc import ABC, abstractmethod
from typing import Iterator
import pandas as pd

# 抽象データソース
class DataSource(ABC):
    @abstractmethod
    def load(self) -> pd.DataFrame: ...

# SSDSE-B-2026 実装
@dataclass
class SSDSEBSource(DataSource):
    path: str = 'data/raw/SSDSE-B-2026.csv'
    encoding: str = 'cp932'
    skiprows: int = 1
    def load(self) -> pd.DataFrame:
        return pd.read_csv(self.path, encoding=self.encoding, skiprows=self.skiprows)

# 都道府県エンティティ
@dataclass
class Prefecture:
    code: str
    name: str
    year: int
    population: int
    births: int
    @property
    def birth_rate(self) -> float:
        return self.births / self.population * 1000
    def __repr__(self) -> str:
        return f"<{self.name}({self.year}) 人口{self.population:,} 出生率{self.birth_rate:.2f}‰>"

# データセットコレクション
class PrefectureDataset:
    def __init__(self, source: DataSource):
        self.source = source
        self._df = None
    @property
    def df(self) -> pd.DataFrame:
        if self._df is None:
            self._df = self.source.load()
        return self._df
    def __iter__(self) -> Iterator[Prefecture]:
        for _, r in self.df.iterrows():
            yield Prefecture(r['地域コード'], r['都道府県'], r['年度'], r['総人口'], r['出生数'])
    def __len__(self) -> int:
        return len(self.df)

# 使用例
ds = PrefectureDataset(SSDSEBSource())
for p in list(ds)[:3]:
    print(p)
print(f"全 {len(ds)} レコード")

🎯 設計原則 + OOP の融合：DDD（ドメイン駆動設計）

SSDSE-B-2026 をドメインモデルとして捉える：

• エンティティ：Prefecture（一意 ID = 地域コード + 年度）
• 値オブジェクト：BirthRate, PopulationDensity（不変、 ID なし）
• 集約：RegionalBlock（北海道・東北など、 複数県を束ねる）
• リポジトリ：PrefectureRepository.find_by_year(2023)
• サービス：PopulationTrendService（時系列分析ロジック）
• ドメインイベント：「ある県の出生率が閾値を下回った」

🐍 Python 特有の OOP イディオム

1. EAFP（Easier to Ask Forgiveness than Permission）：例外で制御フロー
2. Duck Typing：型でなく振る舞いで判定
3. Properties over getters/setters：p.population で済む
4. Special Methods：__add__, __len__, __iter__ で組込み関数と統合
5. Context Manager：with open(...) as f: のリソース管理
6. Descriptor：属性アクセスの完全カスタマイズ
7. Metaclass：クラス生成の制御（高度）

📊 OOP vs 関数型 vs データクラス：使い分け

⚠️ よくある落とし穴

OOP の落とし穴は「設計を抽象化しすぎる」「継承の階層が深くてデバッグできない」「データ分析タスクで OOP を強引に使う」の 3 系統に集約される。 SSDSE 分析を例にすると、 Prefecture クラスを 5 階層継承で表現するより、 pd.DataFrame に集計関数を渡す方が読みやすい — OOP は状態を持つドメイン (GUI・ゲーム・シミュレータ) で真価を発揮し、 ステートレスな ETL では関数型の方が適合する。

特に Python では _attr のアンダースコア接頭辞が「公開しない」という規約に過ぎず実際にはアクセス可能な点、 __attr の name mangling もリフレクションで突破可能な点を理解しておくと、 過度な隠蔽設計の罠を避けられる。

🌐 関連手法・派生

• SOLID 原則：5つの設計指針
• デザインパターン：Factory, Singleton, Observer 等の定型解
• 抽象基底クラス (ABC)：Python の abc モジュール
• dataclass：データ保持専用クラスを簡潔に
• 関数型との融合：高階関数、 不変オブジェクト

❓ よくある質問

🔗 関連用語 — 前提・並列・発展

「オブジェクト指向プログラミング」をより深く理解するには、 周辺の用語を セットで 押さえるのが効率的です。 以下は前提（先に知っておくべき）、 並列（兄弟概念）、 発展（次に学ぶべき）の関係にある用語群：

クリックで各用語の詳細ページへ移動します。 全用語の体系は 用語集トップ または 概念マップ から俯瞰できます。

📚 関連グループ教材

「オブジェクト指向プログラミング」は単独で完結する概念ではなく、 より大きな分野の一部です。 上位カテゴリの教材を読むことで、 この用語の 位置づけ が立体的に見えてきます：

• 📚 機械学習の基礎 — このカテゴリの体系的解説

📚 参考文献・出典

• Gamma, E., Helm, R., Johnson, R., Vlissides, J. (1994). Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley.
• Martin, R. C. (2002). Agile Software Development, Principles, Patterns, and Practices. Prentice Hall（SOLID 原則の出所）.
• Liskov, B. (1987). Data Abstraction and Hierarchy. OOPSLA.
• Python Documentation. Classes.
• Real Python. Object-Oriented Programming. URL
• 独立行政法人統計センター. SSDSE-B-2026 (CC BY 4.0).
• Lutz, M. (2013). Learning Python (5th ed.). O'Reilly.

🗺 概念マップ

オブジェクト指向プログラミング (OOP) を中心に、 4 本柱 (カプセル化・継承・多態性・抽象化)、 対照パラダイム (関数型・手続き型)、 データサイエンス応用 (scikit-learn Estimator API・PyTorch nn.Module)、 設計原則 (SOLID・GoF パターン) を配置した SVG マップ。

本セクションではオブジェクト指向の カプセル化・継承・多態性 (ポリモーフィズム) を補足する。 データ分析でも `sklearn` の `BaseEstimator` を継承して fit/predict を実装したり、 pandas の DataFrame を拡張する自作クラスを作ったり — OOP は「共通インターフェースで拡張する」設計力として実務に直結する。

🔗 隣接手法への橋渡し

「オブジェクト指向プログラミング」は単独で完結せず、 前後の手法と組み合わさって価値が発揮される。 入力データの準備 (上流)・同目的の代替手法との比較 (並列)・結果の活用 (下流) という 3 軸で隣接領域を整理する。

• 上流 (入力の準備): Python 基礎、 関数・モジュール の理解、 データ型 の概念
• 並列 (同目的の代替): 関数型プログラミング、 手続き型プログラミング、 宣言型 (SQL) が他のパラダイム
• 下流 (結果の活用): デザインパターン (Strategy・Factory)、 scikit-learn Estimator API、 DS でのクラス設計 に発展

この上流・並列・下流の対応を地図化することで、 「オブジェクト指向プログラミング」を中核に据えた分析パイプライン (データ準備 → 手法選択 → 結果の検証と展開) の全体像が見えてくる。

🌳 手法選択フロー

「オブジェクト指向プログラミング」を実際に使うとき、 何をどう選ぶかを順に判断する。 上から順に答えていくと、 使うべき手法と評価の仕方が決まる。

1. 状態を持ち回る必要があるか
   設定・接続・学習済みモデルのように「作ってから何度も使うもの」はクラスにすると素直。 入力から出力を返すだけの処理は、 関数のままのほうが読みやすい。
2. 同じ形の処理が複数あるか
   「読み込む・整形する・書き出す」を対象ごとに実装するなら、 共通の型を決めて差し替えられるようにする。 1 種類しか無いなら、 抽象化は早すぎる。
3. 継承が本当に要るか
   「A は B の一種」と言い切れるときだけ継承にする。 コードの再利用が目的なら、 継承より合成（部品として持つ）のほうが壊れにくい。
4. テストしやすくなるか
   外部との接続を差し替えられる設計にすると、 テストで偽物に置き換えられる。 クラスにしてもテストが書きにくいままなら、 分け方を間違えている。

分析スクリプトのように 1 回書いて捨てるコードでは、 クラス化は手間が増えるだけのことが多い。 同じ処理を何度も呼ぶ、 状態を持つ、 差し替えたい — このどれかが出てから導入する。

🎨 直感をもう一段深める — 「オブジェクト＝主語」で世界を書く

手続き型で書くと、 コードは「動詞（関数）」が主役になります。 calc_density(pop, area) のように、 データはただ関数へ渡される材料にすぎません。 一方 OOP では 「主語（オブジェクト）」が先に立ち、 tokyo.density() のように「そのオブジェクト自身が振る舞う」形で書きます。 これが「データ（属性）と操作（メソッド）を一体にまとめる」という OOP の核心です。

🧩 クラス＝設計図 / インスタンス＝実体 の腑に落とし方

クラスは「たい焼きの型」、 インスタンスは「焼き上がったたい焼き」という比喩が定番です。 型（クラス）は 1 枚で、 そこから中身（あんこ・カスタード）の違う実体（インスタンス）を何個でも量産できます。 このページ上部の 🎮 インタラクティブ体感 で「new Cat() を押すたびに独立した状態を持つ猫が増える」のは、 まさにこの「型は共有・中身は個別」を目で見る仕掛けです。 SSDSE-B-2026 なら Prefecture が型、 Prefecture('東京都', 14086000, ...) が 47 個の実体にあたります。

🏛 三本柱を一言で — カプセル化・継承・多態性

ただし「継承」は三本柱の中で最も誤用されやすい柱です。 「共通部分があるから継承しよう」は早計で、 多くの場合は次節で述べる合成（コンポジション）の方が安全です。 三本柱は「必ず全部使う」ものではなく、 カプセル化と多態性が主役、 継承は控えめにが現代的な感覚です。

⚠️ 落とし穴を深掘る — 「継承の誘惑」と関数型への回帰

OOP の失敗は、 文法ミスよりも設計判断の誤りで起きます。 とくに「継承を使いたくなる衝動」と「なんでもクラスにしたくなる衝動」の 2 つが、 コードを静かに腐らせます。 ここでは既存の よくある落とし穴 を踏まえ、 「なぜダメか」と「代わりに何をするか」をセットで深掘りします。

🚀 発展 — SOLID・パターン・fit/transform・関数型の使い分け

ここまでの三本柱と落とし穴を土台に、 実務で効く 4 テーマへ橋渡しします。 いずれも既存セクション（SOLID の一覧・デザインパターン表）を前提に、 「なぜそれが効くか」の角度で補足します。

① SOLID 原則 — 一言で覚える 5 つ

SOLID は「継承を安全に使うための制約集」とも読めます。 とくに L（リスコフ置換）は「その継承、 本当に is-a か？」の検問所。 ここを通れないなら、 前節の合成に切り替えるサインです。

② デザインパターン — まず 4 つだけ

23 個の GoF パターンを暗記する必要はありません。 「差し替えたい＝Strategy」「生成を隠したい＝Factory」「木＝Composite」「変換＝Adapter」の 4 語感覚があれば、 分析コードの設計はほぼ回ります。

③ pandas / scikit-learn のオブジェクト設計 — fit / transform / predict

ライブラリを「使える」だけの人と「読める」人の差は、 この規約を知っているかどうかです。 scikit-learn は全推定器が同じ 3 メソッドを約束しています：

• fit(X, y) … データから状態（学習済みパラメータ）を内部に持つ。 まさに OOP の「状態＋振る舞い」
• transform(X) … 学習済み状態を使ってデータを変換（前処理・特徴量エンジニアリング）
• predict(X) … 学習済み状態で予測

「fit で状態を仕込み、 transform/predict で使う」という統一 I/F があるおかげで、 StandardScaler も LinearRegression も RandomForest も Pipeline に一列に並べて差し替え可能になります。 これは前節の Strategy パターン＋多態性そのもの。 pandas の DataFrame も、 データ（値）と操作（.groupby()／.merge()）を束ねた巨大なオブジェクトで、 DataFrame を触ること自体が OOP の実践です。

④ データクラス と 関数型 の使い分け

データクラス（@dataclass）は「データ保持が主・振る舞いは少し」という中間解。 __init__/__repr__/__eq__ を自動生成し、 ボイラープレートを消します。 frozen=True にすれば不変となり、 前節の「可変状態の副作用」を根本から断てます（値オブジェクトに最適）。

結論：OOP・関数型・データクラスは対立ではなく道具箱。 現代 Python の定石は「データは frozen dataclass、 変換は純粋関数、 状態を持つ学習器・接続だけをクラス」というハイブリッド。 「クラスを何個書いたか」ではなく「状態の在りかを最小に保てたか」で設計の良し悪しが決まります。

さらに深掘りするなら：scikit-learn（Estimator 設計）／pandas・DataFrame（オブジェクトとしての表データ）／特徴量エンジニアリング（transform の実務）／MLOps（学習器の管理・再学習）／API（外部への操作公開）へ。 なお本ページで「プログラミング」「Python」「関数」「クラス」「データ構造」の各基礎に言及していますが、 これらは独立ページが未整備のためテキストのみの参照です。