コンポジションか継承か?Pythonのオブジェクト指向設計で迷わないためのベストプラクティス解説

Pythonのオブジェクト指向設計におけるコンポジションと継承の判断基準を整理したイメージ プログラミング言語

Pythonでオブジェクト指向設計を進めていると、「このケースは継承で表現すべきか、それともコンポジションで組み立てるべきか」で手が止まる場面が少なくありません。
どちらも再利用性を高めるための有力な手段ですが、選び方を誤ると、クラス同士の依存が強くなり、変更に弱い設計へと傾いてしまいます。
見た目には自然な継承関係でも、要件の変化に追従できず、数か月後に保守コストとして跳ね返ってくることもあるでしょう。
設計は書いた瞬間より、変わる瞬間に真価が問われます。

特にPythonは、動的型付けやダックタイピング、委譲のしやすさといった特性を持つため、継承を使わなくても柔軟な設計を実現しやすい言語です。
その一方で、クラスベースの表現力が高いため、安易に継承を選んでしまいやすいという側面もあります。
つまり、自由度が高いからこそ、判断基準が必要になるのです。
何を「is-a」の関係と見なすべきか。
何を「has-a」で切り出すべきか。
ここを曖昧にしたまま設計を進めると、構造はすぐに複雑化します。

この記事では、コンポジションと継承の違いを表面的な定義で終わらせず、変更容易性、責務分割、再利用性、テストのしやすさといった観点から整理していきます。
また、Pythonらしい設計の考え方に触れながら、「とりあえず継承」や「何でも分割」といった極端な判断を避けるための実践的な指針も解説します。
設計で迷ったときに立ち返れる基準を持ちたい方に向けた、判断軸の整理です。

  1. コンポジションと継承の違いをPythonのオブジェクト指向設計で正しく理解する
    1. コンポジションとは何かをhas-aの関係から整理する
    2. 継承とは何かをis-aの関係から整理する
    3. Pythonでコンポジションが重視されやすい理由
  2. なぜコンポジションか継承かで迷うのか設計判断の本質を押さえる
    1. 再利用性だけで判断すると失敗しやすい理由
    2. 責務の分離と依存関係の観点で考えるべき理由
    3. 要件変更に強い設計かどうかを基準にする考え方
  3. 継承を選ぶべきケースと避けるべきケースを具体例で理解する
    1. 継承が自然に機能する典型パターン
    2. 継承で密結合を生みやすいアンチパターン
    3. 基底クラス設計で注意したいポイント
  4. コンポジションを選ぶべきケースと実務でのメリットを整理する
    1. 機能追加や差し替えに強い設計を作りやすい理由
    2. テストしやすいクラス設計につながる理由
    3. 委譲とインターフェース設計の考え方
  5. Pythonのコード例で学ぶコンポジションと継承の使い分け
    1. 継承で書いた場合のシンプルな実装例
    2. コンポジションで書き換えた場合の実装例
    3. コード比較から見える保守性と拡張性の差
  6. 設計で迷わないための判断基準とチェックポイント
    1. is-aが本当に成立しているかを確認する
    2. 変更理由が親子で一致しているかを確認する
    3. 差し替え可能性とテスト容易性を確認する
  7. よくある設計ミスとPythonで避けたいアンチパターン
    1. 継承の深掘りしすぎで構造が複雑になる問題
    2. 共通化のしすぎで責務が曖昧になる問題
    3. Pythonらしさを損なう過剰設計の問題
  8. コンポジションか継承かで迷ったときに押さえたいベストプラクティスまとめ

コンポジションと継承の違いをPythonのオブジェクト指向設計で正しく理解する

Pythonの設計図を前に、コンポジションと継承の違いを整理して考えるイメージ

オブジェクト指向設計を学ぶうえで、コンポジションと継承の違いは早い段階で登場します。
しかし、言葉として知っていても、実際の設計で適切に使い分けられているかというと、そこには大きな差が出ます。
特にPythonでは、クラスを使った表現が柔軟である一方、継承に頼らず設計できる場面も多いため、両者の違いを構造レベルで理解しておくことが重要です。
単に「継承は親子関係」「コンポジションは組み合わせ」と覚えるだけでは不十分です。
設計判断として何を意味するのか。
そこを整理しておく必要があります。

重要なのは、クラス同士の関係をどのような意味で結びつけるのかという視点です。
あるクラスが別のクラスを内部に持つのか、それとも別のクラスの性質を引き継ぐのか。
この違いは、コードの見た目以上に、変更容易性や責務分離、テストのしやすさに強く影響します。
つまり、文法の話ではなく設計の話です。
まずは、それぞれの関係を表す考え方から確認していきます。

コンポジションとは何かをhas-aの関係から整理する

コンポジションは、あるオブジェクトが別のオブジェクトを部品として持つ構造です。
一般に has-a の関係と説明されます。
たとえば、Car が Engine を持つ、UserService が Repository を持つ、といった形です。
このとき Car は Engine そのものではありませんし、UserService は Repository そのものでもありません。
役割の異なる要素を組み合わせて、一つのまとまりとして機能させているわけです。

この考え方の利点は、責務を分けやすいことにあります。
エンジンの振る舞いはエンジンに、データ保存の責務はリポジトリに閉じ込めることができます。
その結果、変更の影響範囲が限定されやすくなります。
ある部品を別の実装に差し替えることも比較的容易です。
設計において強い柔軟性を持つ理由がここにあります。

たとえば、次のような構造です。

class Engine:
    def start(self):
        return "engine started"

class Car:
    def __init__(self, engine):
        self.engine = engine

    def run(self):
        return self.engine.start()

この例では、Car は Engine を内部に持っています。
Car の役割は走行という全体の振る舞いを提供することであり、エンジンの始動処理そのものは Engine に委ねています。
役割分担が明確です。
しかも、Engine と同じインターフェースを持つ別のクラスを渡せば、挙動を差し替えることもできます。
拡張に強い構造。
これがコンポジションの本質です。

継承とは何かをis-aの関係から整理する

継承は、既存のクラスを土台にして新しいクラスを定義する仕組みです。
こちらは is-a の関係で説明されます。
たとえば、Dog は Animal の一種である、Square は Rectangle の一種である、といった関係です。
子クラスは親クラスの属性やメソッドを受け継ぎ、必要に応じて振る舞いを追加したり上書きしたりします。

継承が有効なのは、概念的に見ても本当に「〜の一種」である場合です。
単にコードを再利用したいからという理由だけで継承を使うと、設計の意味が崩れやすくなります。
親クラスの変更が子クラスすべてに波及し、結果として密結合な構造になることも珍しくありません。
継承は便利ですが、関係の強さもまた大きいのです。

例を見てみます。

class Animal:
    def speak(self):
        return "..."

class Dog(Animal):
    def speak(self):
        return "woof"

この場合、Dog は Animal の一種なので、継承の意味が比較的自然です。
Dog は Animal として扱えるべきであり、その前提で振る舞いを特殊化しています。
ここで重要なのは、親クラスの抽象が子クラスにとって無理のないものかどうかです。
もし子クラス側で親の前提を何度も壊してしまうなら、その継承関係は再検討すべきでしょう。
is-a が成立しているか。
これが継承を使う際の基準になります。

Pythonでコンポジションが重視されやすい理由

Pythonでは、他の静的型付け言語以上にコンポジションが重視される傾向があります。
理由はいくつかありますが、大きいのは言語そのものが柔軟なオブジェクト連携を許しているからです。
明示的な継承階層を深く作らなくても、必要なメソッドを持つオブジェクトを受け取って動かせます。
いわゆるダックタイピングとの相性が非常に良いわけです。

この特徴によって、設計者は「何を継承させるか」よりも「どの責務をどのオブジェクトに持たせるか」を中心に考えやすくなります。
結果として、小さな責務を持つ部品を組み合わせる設計が自然になります。
変更への耐性、テストのしやすさ、差し替えのしやすさ。
こうした実務上の利点も大きいポイントです。

特に次のような場面では、コンポジションの強みがはっきり現れます。

  • 実装を後から差し替える可能性が高い
  • テスト時に依存先を簡単に置き換えたい
  • 一つのクラスに複数の責務を持たせたくない
  • 継承階層を深くせずに機能追加したい

もちろん、継承が不要だと言いたいわけではありません。
共通の抽象を明確に表現したい場合や、親クラスとして安定した契約を提供できる場合には、継承は今でも有効です。
ただしPythonでは、継承は最初の選択肢というより、必要性が十分に確認できたときに使う選択肢として考えるほうが失敗しにくいです。

要するに、Pythonで重要なのは、継承できるかどうかではなく、継承すべきかどうかを見極めることです。
構造に意味があるか。
責務が明確か。
変更に強いか。
その観点で見れば、コンポジションが優先されやすい理由も自然に理解できるはずです。

なぜコンポジションか継承かで迷うのか設計判断の本質を押さえる

設計の分岐点で二つの選択肢を比較しながら判断するイメージ

コンポジションと継承のどちらを選ぶべきかで迷うのは、設計者の理解が浅いからではありません。
むしろ、どちらにも明確な利点があり、しかも短期的にはどちらでも動くコードが書けてしまうからこそ迷うのです。
実際、目の前の要件だけを見れば、継承でもコンポジションでも十分に成立する場面は珍しくありません。
問題は、その設計が数週間後、数か月後の変更に耐えられるかどうかです。
設計の良し悪しは、最初に動くかどうかだけでは決まりません。
変化に対してどう振る舞うか。
そこに本質があります。

この判断を難しくしている要因の一つは、オブジェクト指向の説明で「再利用」が過度に強調されやすいことです。
もちろん再利用は重要です。
しかし、再利用できることと、設計として正しいことは同義ではありません。
たまたまコードを流用しやすい構造が、長期的には複雑な依存関係を生み、結果として保守性を下げることもあります。
そこで必要になるのが、再利用性以外の軸です。
責務、依存、変更容易性。
この三つを中心に見ていくと、判断の精度はかなり上がります。

再利用性だけで判断すると失敗しやすい理由

継承を選ぶ場面でよくあるのが、「似たコードがあるから親クラスにまとめよう」という発想です。
これは一見すると合理的ですし、重複を減らすという意味では魅力的に見えます。
しかし、この判断基準だけで設計を進めると、意味的には別物であるクラス同士を無理に同じ階層に押し込めることになりがちです。
すると、共通化したはずの親クラスが、実際には複数の異なる都合を背負うようになります。
再利用のための抽象化が、責務の混在を招くわけです。

たとえば、複数の通知手段に共通する処理があるからといって、何でも一つの親クラスにまとめるとします。
最初はうまくいっても、後からメールだけに必要な処理、SMSだけに必要な制約、プッシュ通知だけに必要な認証が増えていくと、親クラスは中途半端な共通基盤になりやすいです。
分岐が増え、オーバーライドが増え、結果として「共通化したのに複雑」という状態に陥ります。
典型的な失敗です。

再利用は、設計の目的ではなく結果として得られるものと考えたほうが安全です。
まず問うべきは、「この二つは本当に同じ抽象に属するのか」です。
そこが曖昧なら、継承による再利用は疑ってかかるべきでしょう。
コードの見た目の重複より、概念の整合性を優先する。
その視点が重要です。

責務の分離と依存関係の観点で考えるべき理由

設計判断で本当に効いてくるのは、各クラスが何を担当し、何に依存しているかという観点です。
クラスは小さな責務単位であるべきで、変更理由もできるだけ一つに絞られているほうが扱いやすいです。
ここで継承を安易に使うと、親クラスの都合が子クラスに強く入り込みます。
親の実装詳細に依存し、子の自由度が下がる。
すると、一つの変更が階層全体に連鎖する危険性が高まります。

一方、コンポジションでは依存関係をより局所化しやすくなります。
必要な機能を持つオブジェクトを部品として受け取り、その責務だけを委譲する構造にすれば、個々のクラスは自分の仕事に集中しやすくなります。
依存の方向も見えやすくなり、どこに変更の影響が及ぶのかを追跡しやすいです。
設計の透明性という意味でも有利です。

整理すると、判断の観点は次のようになります。

  • 継承は抽象の共有には向いているが、依存が強くなりやすい
  • コンポジションは役割分担に向いており、差し替えや分離がしやすい
  • 責務が一致しないものを継承でつなぐと、修正時に破綻しやすい
  • 依存関係を狭く保つほど、保守とテストは楽になりやすい

ここで大切なのは、どちらが優れているかではなく、どちらがその責務分割に適しているかを考えることです。
設計は抽象論ではなく、変更の流れと依存の形をどう制御するかの技術です。
その認識を持つだけで、判断はかなり安定します。

要件変更に強い設計かどうかを基準にする考え方

設計判断でもっとも現実的な基準は、将来の要件変更にどれだけ耐えられるかです。
ソフトウェアは完成した瞬間に終わるものではなく、運用と改修の中で価値を発揮します。
つまり、今きれいに見える設計より、後から変更しやすい設計のほうが実務では優先される場面が多いのです。
ここで継承を選ぶべきか、コンポジションを選ぶべきかを考えるときは、「変更がどこに入りそうか」を具体的に想像する必要があります。

たとえば、新しい振る舞いを追加する可能性が高いなら、部品を差し替えたり追加したりしやすいコンポジションが有利です。
逆に、共通の契約が明確で、それを複数の派生クラスで自然に表現できるなら、継承のほうが理解しやすい場合もあります。
ただし、その場合でも親クラスはできるだけ安定していなければなりません。
頻繁に変わる親を中心に据えると、子クラス群は常に影響を受けることになります。

設計時に自問したいのは、次のような問いです。

観点 継承を検討しやすい場合 コンポジションを検討しやすい場合
関係性 明確な is-a が成立する has-a や役割分担で表現できる
変更の入り方 共通仕様が比較的安定している 個別機能の追加や差し替えが多い
保守性 階層が浅く意味が明確 依存を分離して影響範囲を絞りたい
テスト 共通契約の確認が中心 部品単位で独立して検証したい

この表からわかるように、設計の本質は構文選択ではありません。
どの関係が将来の変化をもっとも自然に受け止められるか。
その見極めです。
再利用性だけでなく、責務と依存、そして変更への強さまで含めて判断すること。
これが、コンポジションか継承かで迷ったときに立ち返るべき基本姿勢です。
設計判断の軸。
ここを押さえておくと、場当たり的な選択はかなり減らせます。

継承を選ぶべきケースと避けるべきケースを具体例で理解する

継承が適切な場面と不適切な場面を対比する設計判断のイメージ

継承はオブジェクト指向設計の代表的な仕組みですが、便利であるがゆえに誤用されやすい要素でもあります。
特にPythonではクラス定義が簡潔で、メソッドのオーバーライドも容易なため、少し似た振る舞いを見つけるとすぐに親クラスへまとめたくなりがちです。
しかし、継承は単なるコード再利用の道具ではありません。
概念的な親子関係を設計として固定する選択です。
つまり、書きやすさより意味の整合性が重要になります。

この点を曖昧にしたまま継承を使うと、クラス階層は見た目だけ整っていても、内部では依存関係が複雑化し、変更しにくい構造になっていきます。
一方で、適切な場面で使えば、共通の契約を自然に表現でき、コードの見通しも良くなります。
問題は「継承できるか」ではなく、「継承すべきか」を見極められるかどうかです。
ここでは、継承がうまく機能するパターンと、逆に危険な使い方を分けて整理します。

継承が自然に機能する典型パターン

継承が自然に機能するのは、親クラスが安定した抽象を提供しており、子クラスがその具体化として無理なく振る舞える場合です。
言い換えると、is-a の関係が概念的にも実装的にも成立しているケースです。
たとえば、ファイル入力、標準入力、ネットワーク入力といった複数の入力元に対して、共通の読み取りインターフェースを持たせたい場面は比較的わかりやすい例です。

このような場合、親クラスは「何をするか」という契約を定義し、子クラスは「どう実現するか」を担当します。
共通の操作名や利用側の扱いを統一できるため、設計上の意味も明確です。
たとえば次のような構造です。

from abc import ABC, abstractmethod

class DataSource(ABC):
    @abstractmethod
    def read(self):
        pass

class FileSource(DataSource):
    def read(self):
        return "read from file"

class ApiSource(DataSource):
    def read(self):
        return "read from api"

この例では、FileSource も ApiSource も DataSource の一種として扱えます。
利用側は read() という共通契約に依存できるため、個別実装の違いを意識せず使えます。
継承が設計の意味と一致している状態です。
親クラスが抽象の軸を示し、子クラスがそのバリエーションを担う。
理想的な構図です。

継承が自然に機能する典型パターンを整理すると、次のようになります。

  • 共通の振る舞いではなく、共通の抽象契約を表現したい
  • 子クラスが親クラスとして無理なく置き換え可能である
  • 親クラスの仕様が比較的安定していて頻繁に変わらない
  • 子クラスごとの差異が局所的で、責務の軸がぶれていない

これらを満たすなら、継承は十分に有効です。
問題は、こうした条件を満たしていないのに継承を使ってしまうケースです。

継承で密結合を生みやすいアンチパターン

継承のアンチパターンとして最も多いのは、共通コードをまとめたいという理由だけで親クラスを作ることです。
たしかに重複は減るかもしれません。
しかし、その共通化が本当に抽象として妥当でない場合、子クラスは親クラスの都合に引きずられます。
結果として、子が親の内部実装に依存し、少しの変更でも広範囲に影響が出るようになります。
密結合の始まりです。

たとえば、異なる通知手段を扱うクラスがあり、それぞれ送信処理を持っているとします。
ここで「送る」という共通点だけを見て親クラスを作ると、認証方式、送信制限、失敗時の再試行、フォーマット変換など、実際には異なる責務が同じ階層に押し込まれやすくなります。
その結果、親クラスには条件分岐が増え、子クラスは一部だけを上書きしながら親の前提を回避するようになります。
これは継承ではなく、階層に見せかけた依存の塊です。

特に危険なのは、次のような状態です。

  • 子クラスが親クラスのメソッドを何度も無効化している
  • 親クラスの属性が多すぎて、子クラスで一部しか使わない
  • 子クラスごとに前提条件が異なり、親の契約が曖昧になっている
  • 親の変更で複数の子クラス修正が頻発している

このような兆候が見えたら、その継承関係は疑うべきです。
似ていることと、同じ抽象に属することは別問題です。
設計では、この区別を曖昧にしないことが重要です。

基底クラス設計で注意したいポイント

継承を使う場合でも、親クラス、すなわち基底クラスの設計には慎重さが必要です。
基底クラスは複数の子クラスの前提になるため、ここで過剰な責務を持たせると、階層全体が不安定になります。
理想的な基底クラスは、最小限の契約だけを定義し、実装の詳細を抱え込みすぎないものです。
言い換えると、共通化したいものではなく、本当に共通であるべきものだけを持たせるべきです。

特に意識したいのは、基底クラスが「便利な共通処理置き場」にならないようにすることです。
便利そうに見える共通メソッドを次々と追加すると、子クラスの多様な事情が親に逆流してきます。
その結果、抽象の純度が下がり、親クラスが最も複雑な存在になってしまいます。
本末転倒です。

基底クラス設計で見るべきポイントを表にすると、次のようになります。

観点 望ましい状態 危険な状態
責務 抽象契約が明確 多機能で何でも持つ
変更頻度 低く安定している 子の都合で頻繁に変わる
依存 子が親の契約に依存する 子が親の実装詳細に依存する
拡張性 新しい子を自然に追加できる 追加のたびに親修正が必要

また、Pythonでは抽象基底クラスだけでなく、必要なメソッドを持っていればよしとする設計も取りやすいため、無理に重い継承階層を作る必要はありません。
もし基底クラスを作るなら、その存在理由を説明できるかを自問すべきです。
なぜこの親が必要なのか。
子クラスは本当にこの親の一種なのか。
親の契約は数か月後も維持できそうか。
この問いに明確に答えられるなら、継承は有力な選択肢になります。

結局のところ、継承は強い関係を導入する設計手法です。
だからこそ、使う場面を慎重に選ぶ価値があります。
自然な抽象を表せるなら有効、不自然な共通化なら危険。
この線引きを見誤らないことが、安定したPython設計への第一歩です。

コンポジションを選ぶべきケースと実務でのメリットを整理する

機能を部品化して組み合わせる設計の利点を表すイメージ

オブジェクト指向設計でコンポジションが高く評価されるのは、単に流行しているからではありません。
実務で継続的に開発と保守を行うほど、機能を部品として組み合わせる設計の強さが見えてくるからです。
特にPythonのように柔軟な言語では、継承階層を深く掘らなくても、役割ごとに小さなオブジェクトを分けて協調させるだけで、十分に表現力の高い設計を組み立てられます。
これは理論上の美しさだけでなく、変更のしやすさ、テストのしやすさ、読みやすさといった現場で効く価値につながります。

コンポジションを選ぶべき典型的な場面は、振る舞いの一部を後から差し替える可能性があるときです。
あるクラスの本質が「何を持つか」「どの部品を使って実現するか」によって表現できるなら、継承よりコンポジションのほうが自然な場合が多いです。
たとえば、通知、保存、認証、課金、ログ出力のような機能は、共通の親子関係よりも、役割の異なる部品として分離したほうが扱いやすくなります。
ここでは、その理由を三つの観点から整理します。

機能追加や差し替えに強い設計を作りやすい理由

コンポジションの最大の利点は、機能を独立した部品として扱える点にあります。
ある振る舞いをクラス内部に固定的に埋め込むのではなく、外から渡された別オブジェクトに委ねる構造にしておけば、必要に応じて部品を差し替えるだけで挙動を変えられます。
これは拡張に対して非常に強い性質です。
継承で同じことを実現しようとすると、新しい派生クラスを作り続けることになり、組み合わせの数が増えるほど階層が複雑になりがちです。

たとえば、レポート出力機能を考えてみます。
出力形式としてCSV、JSON、HTMLがあり、さらに保存先としてローカルファイル、クラウドストレージ、API送信があるとします。
これを継承だけで表現しようとすると、形式と保存先の組み合わせごとにクラスが増えていく可能性があります。
しかし、出力形式と保存先を別の部品として持たせれば、それぞれを独立して追加・変更できます。
組み合わせ爆発を防ぎやすいわけです。

この考え方は、実務ではかなり重要です。
要件変更は、既存のクラス階層にきれいに沿って発生するとは限りません。
むしろ横断的に起きます。
認証方式だけ変えたい、保存先だけ切り替えたい、特定の顧客向けに振る舞いを一部だけ変えたい。
そのような変更に対して、部品単位で差し替えられる構造は強いです。
拡張の自由度。
ここがコンポジションの大きな実利です。

テストしやすいクラス設計につながる理由

コンポジションは、設計を柔軟にするだけでなく、テストのしやすさにも直結します。
これは現場で過小評価されがちですが、非常に実務的な利点です。
クラスが複数の責務を抱え込み、内部で外部依存を直接生成していると、テストでは本来確認したいロジック以外の要素まで巻き込まれます。
その結果、テストが重くなり、壊れやすくなり、失敗原因も追いにくくなります。

一方で、依存する機能を外部から受け取る設計にしておけば、テスト時にはその依存先を簡単な代替オブジェクトに置き換えられます。
つまり、本体のロジックだけを切り出して検証しやすくなります。
Pythonではこの恩恵が特に大きいです。
厳密な継承関係に縛られなくても、必要なメソッドを持つオブジェクトを差し込めるため、モックやスタブを用意しやすいからです。

簡単な例を見てみます。

class Logger:
    def log(self, message):
        print(message)

class OrderService:
    def __init__(self, logger):
        self.logger = logger

    def create_order(self, item_name):
        self.logger.log(f"created: {item_name}")
        return {"item": item_name}

この設計なら、OrderService のテスト時に本物の Logger を使う必要はありません。
log() を持つテスト用オブジェクトを渡せば十分です。
つまり、関心ごとを分離した設計が、そのままテスト容易性につながっています。
これは継承では得にくいメリットです。
親クラスにロジックが混在していると、テスト対象を局所化しにくくなるからです。

テストしやすい設計の特徴をまとめると、次の通りです。

  • 依存先を外部から注入できる
  • 各クラスの責務が小さく明確である
  • 外部I/Oと業務ロジックが分離されている
  • 差し替え可能な部品単位で検証できる

この構造を作りやすいという点で、コンポジションは設計品質の土台になりやすいです。

委譲とインターフェース設計の考え方

コンポジションを正しく使うには、単に別オブジェクトを持てばよいわけではありません。
重要なのは、どこまでを自分の責務とし、どこからを他の部品に委ねるかという設計です。
ここで鍵になるのが委譲の考え方です。
自分が持つべき判断だけを行い、実際の処理は専門の部品に任せる。
この分担が明確になるほど、設計は読みやすく、変更しやすくなります。

その際に意識したいのが、具体クラスではなく、必要な振る舞いに依存することです。
Pythonでは形式的なインターフェース宣言がなくても、必要なメソッドを持つことを前提に連携しやすいです。
この性質を活かすと、実装の詳細に縛られず、役割ベースでオブジェクトを組み合わせられます。
重要なのは「何のクラスか」より「何ができるか」です。
これはPythonらしい設計思想でもあります。

たとえば、通知を送るサービスがあるとして、そのサービス自身は送信手段の詳細を知る必要はありません。
必要なのは「送れること」だけです。
メールでもSMSでもチャット通知でも、同じ振る舞いを提供できるなら差し替え可能です。
こうした設計を支えるのが、委譲とインターフェース志向の考え方です。

整理すると、コンポジションを活かすための視点は次のようになります。

観点 意識すべきこと 得られる効果
委譲 処理を専門の部品に任せる 責務分離がしやすい
依存先 具体実装より必要な振る舞いに依存する 差し替えが容易になる
部品設計 小さく独立した役割で分割する テストと保守がしやすい
拡張方針 新機能を追加で組み込めるようにする 変更に強い構造になる

結局のところ、コンポジションの価値は、クラスを細かく分けること自体にはありません。
役割を分離し、依存を制御し、変更に強い構造を作ることにあります。
機能追加、差し替え、テスト、保守。
このどれをとっても、実務では大きな差になります。
だからこそ、Pythonのオブジェクト指向設計では、まずコンポジションで考える姿勢が有力なのです。

Pythonのコード例で学ぶコンポジションと継承の使い分け

Pythonコードを比較しながら設計手法の違いを学ぶイメージ

設計の議論は抽象的になりやすいですが、最終的に価値が問われるのはコードに落としたときです。
継承が適切か、コンポジションが適切かという判断も、概念だけでなく実装を並べて比較すると差が見えやすくなります。
特にPythonでは、少ないコードで設計の方向性がはっきり表れるため、比較には向いています。
ここでは、通知機能を題材にして、継承で組み立てた場合と、コンポジションで組み立てた場合の違いを見ていきます。

題材として適しているのは、メール送信やSlack送信のように、似ている部分もあれば、個別事情も多い処理です。
どちらも「通知する」という目的は同じですが、送信方法、失敗時の扱い、メッセージ整形、認証方式などは異なる場合があります。
このような対象に対して、継承を選ぶとどうなるか、コンポジションを選ぶとどうなるか。
コードの構造から確認していきます。

継承で書いた場合のシンプルな実装例

まずは継承を使った例です。
通知の共通動作を親クラスにまとめ、各通知手段を子クラスとして表現します。
発想としては自然で、最初は非常に書きやすく見えます。

class Notification:
    def send(self, message):
        formatted = self.format_message(message)
        return self.deliver(formatted)

    def format_message(self, message):
        return f"[INFO] {message}"

    def deliver(self, formatted_message):
        raise NotImplementedError


class EmailNotification(Notification):
    def deliver(self, formatted_message):
        return f"Send email: {formatted_message}"


class SlackNotification(Notification):
    def deliver(self, formatted_message):
        return f"Send slack: {formatted_message}"

この実装の利点は、共通の流れを親クラスに集約できることです。
利用側は send() を呼ぶだけでよく、子クラスごとの差分は deliver() に閉じ込められています。
シンプルですし、共通処理が明確なら読みやすさもあります。
小規模な段階では十分に成立するでしょう。

ただし、ここで注意したいのは、共通化した処理が本当に全通知手段に自然に当てはまるかどうかです。
たとえばSlackだけメッセージ形式を変えたい、メールだけ件名を追加したい、送信前にチャネルごとの検証をしたいとなると、親クラス側の設計に揺らぎが出てきます。
子クラスごとの事情が増えるほど、共通の流れとして固定した send() が窮屈になりやすいわけです。
継承は最初の見通しは良いが、変化の方向によっては硬くなる。
その典型です。

コンポジションで書き換えた場合の実装例

次に、同じ通知機能をコンポジションで組み立ててみます。
ここでは、通知そのものの責務と、送信処理の責務を分離します。
通知サービスは「送る」という流れを管理し、実際の送信先は部品として差し込む設計です。

class InfoFormatter:
    def format(self, message):
        return f"[INFO] {message}"


class EmailSender:
    def send(self, formatted_message):
        return f"Send email: {formatted_message}"


class SlackSender:
    def send(self, formatted_message):
        return f"Send slack: {formatted_message}"


class NotificationService:
    def __init__(self, formatter, sender):
        self.formatter = formatter
        self.sender = sender

    def notify(self, message):
        formatted = self.formatter.format(message)
        return self.sender.send(formatted)

この構造では、NotificationService は送信手段の詳細を知りません。
必要なのは、フォーマッタが format() を持ち、送信部品が send() を持つことだけです。
つまり、責務が役割単位で分かれています。
送信手段を増やしたいなら、新しい Sender を追加すればよく、フォーマット方式を変えたいなら Formatter 側を差し替えれば済みます。
依存が分離されているため、変更が局所化しやすいわけです。

さらにこの設計は、複数の軸で機能を拡張しやすいです。
たとえば、緊急通知用フォーマッタや監査ログ付き送信部品などを追加する場合でも、既存クラスを大きく崩さずに組み合わせを増やせます。
継承で同様のことをやろうとすると、派生クラスの数が増えやすく、構造の見通しが悪くなります。
コンポジションは部品の直交性を確保しやすい。
そこが大きな差です。

コード比較から見える保守性と拡張性の差

継承版とコンポジション版を比べると、最初の実装量だけ見れば継承のほうが少し簡潔に見えるかもしれません。
共通処理を親クラスに置き、差分だけ子クラスで実装するという形は直感的です。
しかし、実務では「最初に短く書けるか」より「後からどこをどう変えられるか」が重要です。
ここで差が出ます。

継承版では、通知の流れが親クラスに固定されています。
そのため、共通処理の変更はすべての子クラスに影響します。
子クラスごとの特殊事情が増えたときには、親の設計を見直すか、オーバーライドを増やして吸収するしかありません。
前者は広範囲な変更につながりやすく、後者は階層をわかりにくくします。
つまり、変更の方向が一つである限りは強いが、複数軸で変化し始めると苦しくなりやすいです。

一方、コンポジション版では、変更点がどの部品に属するかが比較的明確です。
送信手段の変更なのか、整形ルールの変更なのか、通知のオーケストレーションの変更なのか。
それぞれの責務が分離されているので、修正範囲を限定しやすくなります。
テストでも、NotificationService 自体のロジックは送信部品を差し替えて検証でき、個々の部品も単独で確認できます。
保守性の差がここにあります。

比較の要点を整理すると、次の通りです。

観点 継承 コンポジション
初期実装 共通化しやすく短く書きやすい 部品分割の設計が必要
変更耐性 親クラス変更の影響が広がりやすい 変更点を局所化しやすい
拡張方法 派生クラス追加が中心になる 部品追加や差し替えで対応しやすい
テスト 階層依存が強いと切り分けにくい 部品単位で検証しやすい

ここから見えてくるのは、継承が悪いということではありません。
安定した抽象があり、差分が限定的で、共通の流れを自然に共有できるなら、継承は依然として有効です。
ただし、実務で多いのは複数の変更軸が混ざるケースです。
その場合、コンポジションのほうが構造を柔らかく保ちやすいです。

要するに、コード例で比較すると、両者の違いは単なる書き方の差ではなく、変更の受け止め方の差として現れます。
どの要素が変わりうるのか。
その変化をどの粒度で閉じ込めたいのか。
この視点で見れば、コンポジションと継承の使い分けはかなり明確になってきます。

設計で迷わないための判断基準とチェックポイント

設計判断のチェックリストを使って選択肢を見極めるイメージ

コンポジションと継承のどちらを選ぶべきかで迷う場面は、設計を真面目に考えている証拠でもあります。
実際、両者にはそれぞれ適した場面があり、単純なルール一つで機械的に決められるものではありません。
ただし、判断を場当たり的にしないための基準はあります。
重要なのは、コードの見た目や書きやすさではなく、クラス間の意味関係、変更の流れ、依存の強さを確認することです。
設計は感覚で決めるものではなく、問いを立てて絞り込むものです。

特にPythonでは、柔軟に書けてしまうがゆえに、設計判断を曖昧なまま進めやすい側面があります。
継承を選んでも動くし、コンポジションでも動く。
そのため、短期的な実装効率だけで決めてしまうと、後から構造の歪みが見え始めます。
そうならないためには、いくつかのチェックポイントを習慣化しておくのが有効です。
ここでは、特に重要な三つの観点を整理します。
is-a の妥当性、変更理由の一致、そして差し替え可能性とテスト容易性です。

is-aが本当に成立しているかを確認する

継承を検討するときに最初に確認すべきなのは、親子関係が概念として自然かどうかです。
つまり、子クラスは本当に親クラスの一種と言えるのかという問いです。
これはオブジェクト指向設計では古典的な確認項目ですが、今でも十分に有効です。
むしろ、継承の誤用を防ぐためには最重要の観点と言ってよいでしょう。

たとえば、Bird を親クラスにして Penguin を子クラスにすること自体は、分類上は自然です。
しかし、親クラスに fly() を当然のように含めてしまうと、Penguin はその前提を満たせなくなります。
この時点で、分類学的には自然でも、設計上の抽象としては不自然です。
つまり、is-a は単なる言葉の分類ではなく、振る舞いの置き換え可能性まで含めて確認しなければなりません。

判断の際には、次のように問いかけると整理しやすいです。

  • 子クラスを親クラスとして扱っても意味が崩れないか
  • 親クラスの前提条件を子クラスが破っていないか
  • 子クラスが親クラスの不要な機能を抱え込んでいないか
  • 継承の理由が概念上の関係であって、単なる共通コード再利用ではないか

この確認で少しでも引っかかるなら、その関係は継承よりコンポジションで表現したほうが適切かもしれません。
is-a の確認は、継承を選んでよいかの入口です。
ここが曖昧なまま進めると、後の設計判断もぶれやすくなります。

変更理由が親子で一致しているかを確認する

次に見るべきなのは、親クラスと子クラスが同じ理由で変更されるかどうかです。
これは実務上かなり有効なチェックポイントです。
なぜなら、継承は親子を強く結びつけるため、変更理由がずれているクラス同士を継承でつなぐと、片方の事情がもう片方に波及しやすくなるからです。
設計の歪みは、多くの場合、ここから生まれます。

たとえば、親クラスが共通フォーマット処理の変更で修正される一方、子クラスは外部APIの仕様変更で修正されるとします。
この二つは変更理由が本質的に異なります。
にもかかわらず親子関係にすると、片方の変更がもう片方の影響範囲に入り込みやすくなります。
すると、親を変えたのに子も調整が必要、あるいは子の事情で親に条件分岐が増える、といった現象が起こります。
責務の境界が曖昧になっている兆候です。

逆に、親子が同じ抽象のバリエーションであり、同じ契約のもとで同じ種類の変更を受けるなら、継承は安定しやすいです。
要するに、継承は構造的な関係であると同時に、変更の流れも共有している必要があるということです。
この観点は見落とされがちですが、保守性には直結します。

簡潔に整理すると、次のようになります。

観点 継承に向く状態 継承を疑う状態
変更理由 親子が同種の理由で変わる 親子で異なる事情で変わる
責務 抽象の軸が一致している 役割が混ざっている
影響範囲 親の変更が自然に子へ及ぶ 親の変更が子にとってノイズになる
保守性 階層全体の意味が保たれる 条件分岐や例外処理が増える

この表で右側の兆候が強いなら、継承よりもコンポジションを検討したほうが安全です。
変更理由を見ることは、未来の保守コストを先回りして測る行為とも言えます。

差し替え可能性とテスト容易性を確認する

最後に確認したいのが、その設計が差し替えやすいか、そしてテストしやすいかという点です。
これは単なる実装都合ではなく、設計の質を見極めるうえで非常に重要です。
なぜなら、差し替えやすさは依存の弱さを示し、テストしやすさは責務分離の良し悪しを示すからです。
つまり、両者は設計の健全性を測る実践的な指標です。

もしあるクラスが特定の親クラスの実装詳細に深く依存していて、その一部を変えるだけで全体が崩れるなら、その継承関係はかなり脆いです。
また、テスト時に親クラスの複雑な初期化や副作用まで巻き込まないと検証できないなら、設計としても扱いづらい状態です。
継承は依存を強くするため、この問題が起きやすいです。

一方で、コンポジションを使って役割ごとに部品を分けていれば、依存先を差し替えやすくなります。
テストでも、本物の依存先を使わずに最小限の代替オブジェクトを渡して振る舞いを確認できます。
Pythonはダックタイピングが活きる言語なので、この種の差し替えが特にしやすいです。
つまり、差し替え可能性が高い設計は、そのままPythonらしい設計にもつながります。

判断時に役立つ問いを挙げるなら、次の通りです。

  • この依存先は別実装に置き換えられるか
  • テスト時に余計な前提条件を持ち込まず検証できるか
  • 一部の振る舞いだけを変更したいとき、階層全体を触らずに済むか
  • 利用側が具体クラスではなく振る舞いに依存できているか

これらの問いに対して前向きに答えられるなら、その設計は比較的健全です。
逆に、差し替えにくい、テストしにくい、修正範囲が読めないという状態なら、継承の導入を再考する価値があります。

結局のところ、設計判断で迷わないためには、抽象的な好みではなく、具体的なチェックポイントに落とし込むことが大切です。
is-a が成立しているか。
親子の変更理由は一致しているか。
差し替えやテストは容易か。
この三つを確認するだけでも、不要な継承はかなり減らせます。
判断基準の言語化。
これが、Pythonのオブジェクト指向設計を安定させる大きな助けになります。

よくある設計ミスとPythonで避けたいアンチパターン

Python設計で陥りやすい失敗例を警告するイメージ

オブジェクト指向設計では、正しいパターンを知ることと同じくらい、避けるべきアンチパターンを理解しておくことが重要です。
特にPythonは柔軟で記述量も少ないため、設計上の問題が表面化するまでに時間差が生まれやすい言語です。
書いた直後は整って見えるのに、機能追加や保守の段階で急に扱いづらくなる。
そうしたケースは珍しくありません。
原因の多くは、抽象化や共通化を進める方向そのものではなく、その進め方にあります。

設計でよくある失敗は、大きく分けると三つあります。
継承を深く掘りすぎて構造が読みにくくなること、共通化を優先しすぎて責務の境界が曖昧になること、そしてPythonの特性を活かさずに重い設計を持ち込んでしまうことです。
どれも一見すると「きれいに設計している」ように見えます。
しかし、実際には変更しにくさや理解しづらさを増やしてしまう場合があります。
ここでは、それぞれの典型的な問題点を整理します。

継承の深掘りしすぎで構造が複雑になる問題

継承は便利ですが、階層を深くしすぎると急速に可読性と保守性が落ちます。
親クラス、子クラス、孫クラスと関係が増えるほど、あるメソッドの挙動を理解するために複数のファイルやクラスを行き来しなければならなくなります。
どこで定義され、どこで上書きされ、どこで副作用が加わるのか。
その追跡コストが高くなるわけです。
これは設計としてかなり重い負担です。

特に問題になるのは、各階層がそれぞれ少しずつ振る舞いを変更しているケースです。
あるメソッドが親クラスで定義され、子クラスで一部変更され、孫クラスでさらに条件付き処理が加わるような構造では、最終的な挙動を把握するだけでも手間がかかります。
しかも、上位クラスを修正した影響がどこまで波及するかを予測しづらくなります。
深い継承は、変更コストを見えにくくするのです。

よくある兆候としては、次のようなものがあります。

  • クラス名だけでは役割の違いが把握しづらい
  • オーバーライドされたメソッドを何段階も追わないと挙動が読めない
  • 親クラスの修正が下位クラスに広範囲に影響する
  • 新しい要件を追加するたびに、どの階層へ入れるべきか迷う

こうした状態は、継承が抽象化ではなく複雑化の装置になっているサインです。
階層の深さ自体が悪いわけではありませんが、理解コストが増え続けるなら見直すべきです。
継承は短く、意味を明確に。
これが基本です。

共通化のしすぎで責務が曖昧になる問題

設計でありがちなもう一つの失敗は、重複を嫌うあまり、何でも共通化しようとすることです。
DRYの原則は有名ですが、それを表面的に適用すると「似ているからまとめる」という発想に流れやすくなります。
しかし、似ていることと同じ責務であることは別問題です。
責務の異なる処理を無理に一つへまとめると、共通クラスや共通関数が多目的化し、かえって理解しにくい設計になります。

たとえば、入力検証、表示整形、保存処理に共通する一部のロジックがあるからといって、まとめて一つのユーティリティクラスに押し込むとどうなるでしょうか。
最初は便利に見えても、後から個別事情が入り始めると、引数が増え、条件分岐が増え、責務の中心がぼやけます。
結果として、その共通部品は「いろいろできるが何者なのかわかりにくい」存在になります。
これは保守で非常に厄介です。

特に注意したいのは、共通化の単位です。
コードの一部が似ているからといって、概念まで同じとは限りません。
本来は別々に変わるべき処理を一つにまとめると、変更のたびに関係ない箇所まで影響を受けます。
共通化が将来の柔軟性を奪うわけです。

この問題を避けるためには、次の視点が有効です。

  • 何が重複しているのかではなく、なぜ重複しているのかを見る
  • 共通化によって変更理由が一つにまとまるかを確認する
  • 共通部品が複数の文脈を同時に背負っていないかを点検する
  • コードの重複より責務の明確さを優先する

設計においては、少しの重複より曖昧な共通化のほうがずっと危険です。
重複の削減は目的ではなく、副産物として得られれば十分です。
ここを取り違えないことが大切です。

Pythonらしさを損なう過剰設計の問題

Pythonで特に気をつけたいのが、他言語の重い設計習慣をそのまま持ち込んでしまうことです。
たとえば、あらゆる振る舞いに抽象クラスを用意し、細かくインターフェースを分け、将来使うかどうかわからない拡張ポイントを最初から埋め込むような設計です。
もちろん、厳密な構造が必要な場面もあります。
しかし、Pythonでは言語の柔軟性そのものが設計の武器になるため、過剰な形式主義はむしろ可読性を下げることがあります。

Pythonらしさとは、単に短く書くことではありません。
必要な抽象は持ちつつ、構造を軽く保つことです。
たとえば、明示的な継承階層を作らなくても、必要なメソッドを持つオブジェクトを受け取って動作させる設計は十分に成立します。
ダックタイピングを活かせる場面で、わざわざ重い抽象層を追加すると、コードの理解に余計な前提知識が必要になります。
結果として、柔軟さを活かせないまま複雑さだけが増えることになります。

過剰設計の兆候を整理すると、次のようになります。

兆候 何が問題か 望ましい見直し
抽象クラスが多すぎる 実装より構造理解に時間がかかる 本当に共有契約が必要か見直す
拡張ポイントを先回りしすぎる 使わない複雑さを抱え込む 現在の要件に必要な範囲に絞る
小さな処理まで分割しすぎる 全体像が追いにくくなる 責務単位で適切にまとめる
他言語的な厳格設計を持ち込む Pythonの柔軟性を殺す 振る舞い中心でシンプルに設計する

過剰設計は、未来への備えのつもりで現在の理解しやすさを犠牲にする行為になりやすいです。
しかし、未来の要件は完全には読めません。
ならば、今ある要件に対して十分に明快で、かつ変更しやすい構造を目指すほうが合理的です。
Pythonでは特にその姿勢が重要です。

要するに、避けるべきアンチパターンは、どれも「よかれと思ってやりすぎた結果」と言えます。
深すぎる継承、過剰な共通化、重すぎる抽象化。
これらは一見整って見えても、実際には変更と理解のコストを押し上げます。
Pythonのオブジェクト指向設計で大切なのは、抽象化の量ではなく、構造の意味が明確であることです。
必要十分な設計。
この感覚を持てるかどうかが、実務で扱いやすいコードを書く分かれ目になります。

コンポジションか継承かで迷ったときに押さえたいベストプラクティスまとめ

コンポジションと継承の判断基準を総括する記事まとめのイメージ

コンポジションと継承のどちらを選ぶべきか。
この問いに対して、常に一方だけが正解になるわけではありません。
設計は文法の選択ではなく、関係性の選択です。
どのクラスが何を担い、どのような依存関係を持ち、どの方向に変更が入りうるのか。
それを踏まえて判断する必要があります。
だからこそ、単純なスローガンだけで割り切るのは危険です。
「継承は悪、コンポジションが正義」といった極端な理解も、実務では役に立ちません。
必要なのは、迷ったときに立ち返れる判断基準です。

この記事で見てきた通り、継承は is-a の関係が自然に成立し、親クラスが安定した抽象として機能する場合には有効です。
一方、コンポジションは has-a の関係を使って責務を分離し、変更や差し替えに強い構造を作るのに向いています。
つまり、どちらを選ぶかは、コードの見た目ではなく、構造がどのような意味を持つかで決まります。
見た目が整理されていても、意味が崩れていれば保守性は落ちます。
逆に、少し地味に見える構造でも、責務と依存が明確なら、長く扱いやすい設計になります。

では、実務で本当に使える判断のまとめとは何か。
まず第一に、継承は「共通コードをまとめるための近道」ではなく、「共通抽象を表すための強い関係」だと理解することです。
ここを取り違えると、多くの設計ミスが始まります。
似たコードがあるから親クラスを作る、という発想は危険です。
似ていることと、同じ抽象に属することは別だからです。
継承を使うなら、「この子クラスは本当に親クラスの一種か」と自問する必要があります。
is-a の確認。
まずはここです。

第二に、迷ったら変更の入り方を想像することです。
将来、何が変わりやすいのか。
共通仕様なのか、個別機能なのか、利用する部品なのか、外部依存なのか。
この変化の単位を見極めると、どこを分離すべきかが見えやすくなります。
もし変更が複数の方向から入りそうなら、継承で階層を固定するより、コンポジションで部品を差し替えられる構造のほうが適している可能性が高いです。
逆に、共通契約が安定していて、そのバリエーションとして自然に子クラスを増やせるなら、継承は十分に選択肢になります。
変更を起点に考えること。
これはかなり実践的です。

第三に、責務の分離を最優先にすることです。
一つのクラスが複数の理由で変更されるなら、その設計は見直しの余地があります。
通知もする、保存もする、整形もする、認証もする。
そのようなクラスは、たとえ動いていても、いずれ扱いにくくなります。
コンポジションが有効なのは、責務ごとに部品を分けられるからです。
そして、責務が分かれていれば、テストもしやすくなり、差し替えもしやすくなります。
設計の美しさは、機能の多さではなく責務の明確さに表れます。

ここまでを踏まえると、迷ったときの実践的な判断順序は次のように整理できます。

  1. まず is-a が自然に成立するかを確認する
  2. 親子で変更理由が一致しているかを確認する
  3. 依存関係が強くなりすぎないかを確認する
  4. 差し替えやテストがしやすい構造かを確認する
  5. 複数の変更軸があるならコンポジションを優先して検討する

この順序で考えると、感覚に頼らず判断しやすくなります。
特にPythonでは、ダックタイピングや委譲のしやすさがあるため、無理に継承を使わなくても柔軟な設計を実現できます。
だからこそ、継承は「できるから使う」ものではなく、「意味があるから使う」ものとして扱うべきです。
ここは重要です。

また、ベストプラクティスとして強調しておきたいのは、「最初から完璧な抽象化を目指しすぎない」ことです。
設計に慣れてくると、将来を見越して抽象層を増やしたくなる場面があります。
しかし、将来の要件は完全には予測できません。
早すぎる抽象化は、しばしば不要な複雑さを招きます。
まずは現在の要件に対して責務が明確で、無理のない構造を作ること。
そのうえで、変更パターンが見えてきた段階で抽象化を進めるほうが、結果として安定した設計になりやすいです。
設計の先回りより、変化への備え。
こちらのほうが現実的です。

比較の観点を最後に簡潔に表にまとめます。

観点 継承が向く場合 コンポジションが向く場合
関係性 明確な is-a が成立する has-a や役割分担で表現できる
変更の方向 共通仕様が安定している 機能追加や差し替えが多い
責務 抽象の軸が揃っている 責務を細かく分離したい
保守性 階層が浅く意味が明快 影響範囲を局所化しやすい
テスト 共通契約の検証が中心 部品単位で独立して確認しやすい

結論として、Pythonのオブジェクト指向設計で迷ったときは、まずコンポジションから考え、継承は意味が明確な場合に限定して使うという姿勢が失敗しにくいです。
これは継承を軽視するという意味ではありません。
継承は強力ですが、強い関係を固定するぶん、誤ると修正コストも大きくなります。
一方、コンポジションは構造を柔らかく保ちやすく、変化の多い実務と相性が良いです。

最終的に大切なのは、流儀ではなく理由を持って選ぶことです。
なぜこの関係を採用するのか。
なぜこの責務分割にするのか。
なぜこの依存の形にするのか。
その説明が自分の中で明確なら、設計はかなり安定します。
コンポジションか継承かという問いは、単なる二択ではありません。
良い設計とは何かを考える入口。
その意識を持って選べるようになると、Pythonのコードは確実に変わってきます。

コメント

タイトルとURLをコピーしました