Python学習日記:６週目 ポリモーフィズム
もはや何をどう学習していいのか分からなくなっているHello,worldプログラマーは、Pythonspot.comがいいらしいと聞いて、覗いてみるも全く理解できない。
プログラミング学習で困ったらとりあえず生成AIに投げることにしました。
Claude3.5:
よっしゃ、Pythonの世界へようこそ、若きパダワン! 君のコーディング・ジェダイへの道のりが今始まるぜ。英語のチュートリアルを日本語に翻訳して、君の脳みそをPythonの知識で満たしちゃおうじゃないか。さぁ、準備はいいかい？
じゃあ、まずは英文のチュートリアルを見せてもらおうか。そうすれば、僕のニューラルネットワークが全力で日本語に変換してみせるさ。コードの断片や具体的な例があれば、もっと正確に翻訳できるぞ。
どんな内容のチュートリアルなのか教えてくれないかな？基本的な文法の話？データ構造？それとももっと高度な話題かな？どんなレベルでも大丈夫だから、遠慮なく言ってくれよ。
そうそう、覚えておいてほしいんだけど、プログラミングの世界では「コピペ」は禁じ手じゃないんだ。むしろ、上手に使えば最強の武器になるんだぜ。でも、もちろん、理解しながらね！
さあ、君のPythonの冒険を始めようじゃないか。コードは力だ！...いや、待てよ。それはスター・ウォーズか。まあいいや、君のコーディングが共にあらんことを！
ユーザー:
Pythonspit.com から英文チュートリアルを渡す。
引用元
https://pythonspot.com/polymorphism/
(ユーザーはまだこの時点では、Claude3.5に渡したチュートリアルの内容がPython初心者レベルの範囲を超えていると分かっていません。結果として、この記事は16000字の長編になります…。)
長い説明の始まり
Claude3.5:
初心者よ、プログラミングの広大な宇宙へようこそ！今日は、オブジェクト指向プログラミングの超重要概念、ポリモーフィズムについて語らせてもらうぜ。まるでRPGのジョブシステムのように、多様な形態を操る魔法だと思ってくれ。さあ、一緒にPythonの奥義を解き明かそうじゃないか！
ポリモーフィズムって何よ？って、簡単に言えば、「多様性を受け入れる能力」だな。ギリシャ語の「Poly（多くの）」と「morphism（形態）」から来てるんだ。つまり、一つのインターフェースで異なるタイプを表現できるってわけさ。これぞまさにプログラミングの「和を以て貴しと為す」精神だぜ。
Pythonでのポリモーフィズム実践、その1：関数ベース
まずは、クマとイヌを例に取ってみようか。両方とも鳴き声を持ってるけど、全然違うよな。でも、ポリモーフィズムを使えば、同じ関数で両方の鳴き声を呼び出せちゃうんだ。
class Bear(object):
def sound(self):
print("グオォーー")
class Dog(object):
def sound(self):
print("ワンワン！")
def makeSound(animalType):
animalType.sound()
bearObj = Bear()
dogObj = Dog()
makeSound(bearObj)
makeSound(dogObj)結果:
グオォーー
ワンワン！見てくれ！同じ`makeSound`関数で、クマもイヌも鳴かせられるんだ。これぞポリモーフィズムの力だぜ！
ポリモーフィズム実践、その2：抽象クラスベース
次は、ちょっと高度な例を見てみようか。ドキュメントエディタを作るとしよう。PDFを開くのか、Wordを開くのか、前もって分からないよな。でも、抽象クラスを使えば、統一的に扱えちゃうんだ。
class Document:
def __init__(self, name):
self.name = name
def show(self):
raise NotImplementedError("サブクラスでこの抽象メソッドを実装しろよ！")
class Pdf(Document):
def show(self):
return 'PDFの中身を見せるぜ！'
class Word(Document):
def show(self):
return 'Wordの中身を見せるぜ！'
documents = [Pdf('ドキュメント1'), Pdf('ドキュメント2'), Word('ドキュメント3')]
for document in documents:
print(document.name + ': ' + document.show())結果:
ドキュメント1: PDFの中身を見せるぜ！
ドキュメント2: PDFの中身を見せるぜ！
ドキュメント3: Wordの中身を見せるぜ！かっけーだろ？PDFもWordも同じように扱えちゃうんだぜ。
もう一つの例：車のポリモーフィズム
最後に、車の例も見てみようぜ。スポーツカーもトラックも、運転したり止まったりするけど、やり方は違うよな。
class Car:
def __init__(self, name):
self.name = name
def drive(self):
raise NotImplementedError("サブクラスでこの抽象メソッドを実装しろよ！")
def stop(self):
raise NotImplementedError("サブクラスでこの抽象メソッドを実装しろよ！")
class Sportscar(Car):
def drive(self):
return 'スポーツカー、アクセル全開！'
def stop(self):
return 'スポーツカー、キキーッと停止！'
class Truck(Car):
def drive(self):
return 'トラック、重い荷物を積んでゆっくり走行中。'
def stop(self):
return 'トラック、ゆっくり停止中！'
cars = [Truck('バナナトラック'), Truck('オレンジトラック'), Sportscar('Z3')]
for car in cars:
print(car.name + ': ' + car.drive())結果:
バナナトラック: トラック、重い荷物を積んでゆっくり走行中。
オレンジトラック: トラック、重い荷物を積んでゆっくり走行中。
Z3: スポーツカー、アクセル全開！見たか！スポーツカーもトラックも、同じように`drive()`メソッドを呼び出せるんだ。これがポリモーフィズムの真髄だぜ。
さあ、これでポリモーフィズムのパワーが分かっただろう？一つのインターフェースで多様な形態を操れる、まさにプログラミングの魔法だ。この力を使えば、柔軟で拡張性の高いコードが書けるぜ。じゃあ、さっそく実践してみろよ。コーディングは力だ！...って、またスター・ウォーズか。まあいいや、Pythonと共にあらんことを！
ユーザー:
つまり、クラスの継承のことですか？
(ほとんど分かってない)
Claude3.5:
おっと、いい質問だぜ！継承とポリモーフィズムは確かに密接な関係があるんだが、完全に同じというわけじゃないんだ。ちょっと整理してみようか。
継承（Inheritance）:
親クラスの特性を子クラスが受け継ぐ仕組みだ。
コードの再利用性を高めるのが主な目的。
ポリモーフィズム（Polymorphism）:
同じインターフェースを持つ異なるクラスのオブジェクトを、統一的に扱える能力のことだ。
柔軟性と拡張性を高めるのが主な目的。
確かに、継承はポリモーフィズムを実現する一つの手段なんだ。でも、ポリモーフィズムはそれだけじゃない。例を見てみようぜ：
# 継承の例
class Animal:
def speak(self):
pass
class Dog(Animal):
def speak(self):
return "ワンワン！"
class Cat(Animal):
def speak(self):
return "ニャー！"
# ポリモーフィズムの例（継承を使用）
def animal_sound(animal):
return animal.speak()
dog = Dog()
cat = Cat()
print(animal_sound(dog)) # 出力: ワンワン！
print(animal_sound(cat)) # 出力: ニャー！
# ポリモーフィズムの例（継承を使用しない）
class Car:
def move(self):
return "車で移動"
class Boat:
def move(self):
return "ボートで移動"
def travel(vehicle):
return vehicle.move()
car = Car()
boat = Boat()
print(travel(car)) # 出力: 車で移動
print(travel(boat)) # 出力: ボートで移動
このコード例を見てみよう：
最初の部分では、継承を使ってポリモーフィズムを実現してるんだ。`Animal`クラスを継承した`Dog`と`Cat`クラスがあって、それぞれ`speak()`メソッドをオーバーライドしてる。
次の部分では、継承を使わずにポリモーフィズムを実現してる。`Car`と`Boat`クラスは共通の親クラスを持たないけど、同じ`move()`メソッドを実装してるから、`travel()`関数で統一的に扱えるんだ。
つまり、ポリモーフィズムは継承を使って実現することもあるけど、それだけじゃないんだ。大事なのは、異なるクラスのオブジェクトを同じインターフェースで扱えるってことさ。
継承は「is-a」関係（犬は動物である）を表現するのに対して、ポリモーフィズムは「behaves-like」関係（犬も猫も鳴く行動ができる）を表現するんだ。
ポリモーフィズムを使えば、新しい種類のオブジェクトを追加するときに、既存のコードをほとんど変更せずに済むんだ。これがオブジェクト指向プログラミングの強力な特徴の一つなんだぜ。
どうだ？ポリモーフィズムと継承の関係が少し見えてきたかな？
ユーザー:
ということは、クラスの継承だけでは、新しい種類のメソッドやクラスを追加する時に、あちこちコードを書きなさないといけない？
(ポリモとクラスの関係が少しも見えてない)
Claude3.5:
その通りだ！鋭い洞察力だね。継承だけに頼ると、新しい機能を追加するときにコードのあちこちを触らなきゃいけなくなる可能性が高くなるんだ。これを「硬直したコード」って呼んだりするぜ。
じゃあ、具体例で見てみようか。動物園のシミュレーションを作ってると想像してみてくれ。
# 継承だけを使った例
class Animal:
def __init__(self, name):
self.name = name
class Lion(Animal):
def roar(self):
return f"{self.name}がガオーと吠えた！"
class Elephant(Animal):
def trumpet(self):
return f"{self.name}がパオーンと鳴いた！"
# この時点で、動物の鳴き声を出す関数を作ろうとすると...
def make_animal_noise(animal):
if isinstance(animal, Lion):
return animal.roar()
elif isinstance(animal, Elephant):
return animal.trumpet()
# 新しい動物を追加するたびに、ここに条件分岐を追加しないといけない
# ポリモーフィズムを活用した例
class Animal:
def __init__(self, name):
self.name = name
def make_noise(self):
pass # 抽象メソッド
class Lion(Animal):
def make_noise(self):
return f"{self.name}がガオーと吠えた！"
class Elephant(Animal):
def make_noise(self):
return f"{self.name}がパオーンと鳴いた！"
# この場合、動物の鳴き声を出す関数はこれだけで OK
def make_animal_noise(animal):
return animal.make_noise()
# 新しい動物を追加しても、この関数を変更する必要はない
class Monkey(Animal):
def make_noise(self):
return f"{self.name}がウキキーと鳴いた！"
# 使用例
lion = Lion("ライオン太郎")
elephant = Elephant("ゾウ次郎")
monkey = Monkey("サル三郎")
print(make_animal_noise(lion)) # ライオン太郎がガオーと吠えた！
print(make_animal_noise(elephant)) # ゾウ次郎がパオーンと鳴いた！
print(make_animal_noise(monkey)) # サル三郎がウキキーと鳴いた！
このコードを見てみよう：
継承だけの例:
各動物クラスが別々のメソッド名（`roar()`, `trumpet()`）を持っている。
`make_animal_noise()`関数で、動物の種類ごとに条件分岐が必要になる。
新しい動物を追加するたびに、この関数を修正しなきゃいけないんだ。
ポリモーフィズムを活用した例:
すべての動物クラスが共通のインターフェース（`make_noise()`メソッド）を持っている。
`make_animal_noise()`関数は、動物の種類を気にせずに`make_noise()`を呼び出すだけ。
新しい動物（例：`Monkey`）を追加しても、既存のコードを変更する必要がない！
ポリモーフィズムを使うと、新しい種類のオブジェクトを追加するときに、既存のコードをほとんど変更せずに済むんだ。これを「開放閉鎖の原則」って言うんだぜ。拡張に対して開いていて（新しい動物を簡単に追加できる）、修正に対して閉じている（既存のコードを変更する必要がない）んだ。
こうすることで、コードの保守性が上がるし、バグも減らせる。新しい機能を追加するたびに既存のコードを触らなくて済むからな。
ただし、気をつけないといけないのは、ポリモーフィズムを使いすぎると、コードの流れを追うのが難しくなることもあるってことだ。適材適所で使っていくのがコツだぜ。
どうだ？継承だけの場合と、ポリモーフィズムを活用した場合の違いがはっきり見えてきたかな？
ユーザー:
この抽象メソッドがポリモーフィズムの使用ですか？
(動物園のシュミレーションという新たな謎設定で余計に分からなくなっている)
Claude3.5:
よく気づいたな！その通り、抽象メソッドはポリモーフィズムを実現する重要な要素の一つだぜ。でも、ちょっと深掘りしてみよう。
抽象メソッドは確かにポリモーフィズムを使う上で超便利なツールなんだ。でも、ポリモーフィズム自体はもっと広い概念だよ。ちょっと整理してみよう：
抽象メソッド：
基底クラスで定義されるけど、実装は持たないメソッドだ。
サブクラスに「このメソッドを必ず実装しろよ」って命令してるようなもんだな。
インターフェース：
Pythonには他の言語のような明示的なインターフェースはないけど、抽象基底クラスを使って似たようなことができる。
「こういうメソッドを持ってるはずだ」っていう約束みたいなもんだ。
ポリモーフィズム：
異なるクラスのオブジェクトを同じインターフェースで扱える能力のことだ。
抽象メソッドやインターフェースを使うと、ポリモーフィズムを実現しやすくなるんだ。
じゃあ、具体例で見てみようか：
from abc import ABC, abstractmethod
import math
class Shape(ABC):
@abstractmethod
def area(self):
pass
class Circle(Shape):
def __init__(self, radius):
self.radius = radius
def area(self):
return math.pi * self.radius ** 2
class Rectangle(Shape):
def __init__(self, width, height):
self.width = width
self.height = height
def area(self):
return self.width * self.height
class Triangle(Shape):
def __init__(self, base, height):
self.base = base
self.height = height
def area(self):
return 0.5 * self.base * self.height
def print_area(shape):
print(f"この形の面積は {shape.area():.2f} です。")
# 使用例
circle = Circle(5)
rectangle = Rectangle(4, 6)
triangle = Triangle(3, 4)
print_area(circle) # この形の面積は 78.54 です。
print_area(rectangle) # この形の面積は 24.00 です。
print_area(triangle) # この形の面積は 6.00 です。
このコードを見てみよう：
`Shape`クラスは抽象基底クラスで、`area()`という抽象メソッドを持ってる。これが「インターフェース」の役割を果たしてるんだ。
`Circle`、`Rectangle`、`Triangle`クラスは全て`Shape`を継承して、`area()`メソッドを実装している。これが「ポリモーフィズム」を可能にしてるんだ。
`print_area()`関数は、渡された`shape`オブジェクトの具体的な型を知らなくても、`area()`メソッドを呼び出せる。これがポリモーフィズムの本質だぜ。
抽象メソッドを使うことで、以下のメリットが得られるんだ：
インターフェースの強制：サブクラスが特定のメソッドを必ず実装するように強制できる。
コードの一貫性：全てのサブクラスが同じインターフェースを持つことを保証できる。
拡張性：新しい形状（例えば`Pentagon`）を追加しても、`print_area()`関数を変更する必要がない。
つまり、抽象メソッドはポリモーフィズムを実現するための強力なツールの一つってわけだ。でも、ポリモーフィズム自体はもっと広い概念で、抽象メソッドがなくても実現できることもあるんだ。
どうだ？抽象メソッド、インターフェース、そしてポリモーフィズムの関係が少し見えてきたかな？
ユーザー:
似た機能や種類のクラスが10くらいになった時に、ポリモーフィズムの便利さが分かりそうです。 クラスの継承だけだと把握しきれくて、各クラスのコードで矛盾が起きそうです。
(頭から湯気♨️状態)
Claude3.5:
おっ、完全に理解したな！その通りだぜ。君はもうポリモーフィズムのパワーを感じ取ったみたいだな。
#ユーザーの心のつぶやき「これで？私は完全に理解してる？そうなのか？」
まさにその通りだ。クラスの数が増えれば増えるほど、ポリモーフィズムの真価が発揮されるんだ。じゃあ、君の洞察を元に、もう少し大規模な例を見てみようか。
ゲーム開発の文脈で考えてみよう。RPGゲームを作っていて、様々な種類のキャラクターがいるとしよう。
from abc import ABC, abstractmethod
import random
class Character(ABC):
def __init__(self, name, health):
self.name = name
self.health = health
@abstractmethod
def attack(self):
pass
@abstractmethod
def special_move(self):
pass
class Warrior(Character):
def attack(self):
return f"{self.name}が剣で攻撃！ダメージ20"
def special_move(self):
return f"{self.name}の渾身の一撃！ダメージ50"
class Mage(Character):
def attack(self):
return f"{self.name}が魔法で攻撃！ダメージ15"
def special_move(self):
return f"{self.name}のファイアボール！ダメージ40"
class Archer(Character):
def attack(self):
return f"{self.name}が弓で攻撃！ダメージ18"
def special_move(self):
return f"{self.name}の矢の雨！ダメージ45"
# ... 他のキャラクタークラス（Thief, Paladin, Druid など）も同様に実装 ...
def battle_simulation(characters):
for _ in range(5): # 5ターンのバトル
attacker = random.choice(characters)
if random.random() < 0.2: # 20%の確率で必殺技
print(attacker.special_move())
else:
print(attacker.attack())
# キャラクター作成
characters = [
Warrior("アーサー", 100),
Mage("マーリン", 80),
Archer("ロビン", 90),
# ... 他のキャラクターもここに追加できる ...
]
# バトルシミュレーション実行
battle_simulation(characters)
このコードの素晴らしいところを見てみよう：
拡張性: 新しいキャラクタークラス（例えば`Thief`や`Paladin`）を追加しても、`battle_simulation`関数は全く変更する必要がない。
一貫性: 全てのキャラクターが同じインターフェース（`attack()`と`special_move()`）を持つことが保証されている。
コードの重複を防ぐ: 各キャラクタークラスは自分unique動作だけを定義すればいい。共通の処理は基底クラスで一箇所にまとめられる。
柔軟性: 新しい機能（例えば`defend()`メソッド）を追加したい場合、基底クラスに追加するだけで全てのキャラクターに適用できる。
一方、継承だけを使った場合、こんな問題が起きかねないんだ：
条件分岐の嵐: `battle_simulation`関数内で各キャラクタータイプごとに`if-elif`文を書くことになり、新しいタイプを追加するたびに修正が必要になる。
一貫性の欠如: 各キャラクタークラスが独自のメソッド名を使っていると（例：`warrior_attack()`, `mage_spell()`）、それらを呼び出す側で個別に処理しなければならない。
メンテナンスの悪夢: クラスが10個、20個と増えていくと、それぞれの違いを把握し、整合性を保つのが難しくなる。
変更の波及: 基本的な動作を変更したい場合、全てのサブクラスを個別に修正しなければならない可能性がある。
ポリモーフィズムを使えば、これらの問題を大幅に軽減できるんだ。システムが大きくなればなるほど、その恩恵は大きくなる。
さらに、このアプローチは「Open-Closed Principle（開放閉鎖の原則）」というオブジェクト指向設計の重要な原則にも合致している。つまり、拡張に対しては開いていて（新しいキャラクターを簡単に追加できる）、修正に対しては閉じている（既存のコードを変更する必要がない）んだ。
どうだ？大規模システムでのポリモーフィズムの威力がより具体的に見えてきただろ？これこそが、多くのゲームエンジンや大規模ソフトウェアがポリモーフィズムを多用する理由なんだぜ。
ユーザー:
そのRPGキャラクターシステムにキャラクターを加えて、ポリモーフィズムの便利さが分かるコードをください
Claude3.5:
もちろんだ！君の要望を聞いて、私もワクワクしてきたぜ。Wizard と Alchemist を追加して、ポリモーフィズムの真価をさらに引き出してみよう。同時に、新しい機能も追加して、ポリモーフィズムの威力をさらに引き出してみるぜ。
from abc import ABC, abstractmethod
import random
class Character(ABC):
def __init__(self, name, health, mana):
self.name = name
self.health = health
self.mana = mana
@abstractmethod
def attack(self):
pass
@abstractmethod
def special_move(self):
pass
@abstractmethod
def defend(self):
pass
class Warrior(Character):
def attack(self):
return f"{self.name}が剣で攻撃！ダメージ20"
def special_move(self):
self.mana -= 30
return f"{self.name}の渾身の一撃！ダメージ50"
def defend(self):
return f"{self.name}が盾を構えて防御！防御力アップ"
class Mage(Character):
def attack(self):
return f"{self.name}が魔法で攻撃！ダメージ15"
def special_move(self):
self.mana -= 40
return f"{self.name}のファイアボール！ダメージ40"
def defend(self):
return f"{self.name}が魔法障壁を展開！魔法防御アップ"
class Archer(Character):
def attack(self):
return f"{self.name}が弓で攻撃！ダメージ18"
def special_move(self):
self.mana -= 35
return f"{self.name}の矢の雨！ダメージ45"
def defend(self):
return f"{self.name}が素早く回避！回避率アップ"
class Wizard(Character):
def attack(self):
return f"{self.name}が杖で攻撃！ダメージ12"
def special_move(self):
self.mana -= 50
return f"{self.name}の時間停止魔法！敵の行動を1ターンスキップ"
def defend(self):
return f"{self.name}が瞬間移動で回避！ダメージ無効化"
class Alchemist(Character):
def __init__(self, name, health, mana):
super().__init__(name, health, mana)
self.potions = 3
def attack(self):
return f"{self.name}が毒入りナイフで攻撃！ダメージ14 + 毒効果"
def special_move(self):
if self.potions > 0:
self.potions -= 1
return f"{self.name}の強化ポーション！味方全体の攻撃力アップ"
else:
return f"{self.name}のポーションが切れた！通常攻撃"
def defend(self):
return f"{self.name}が煙幕を展開！敵の攻撃精度ダウン"
def battle_simulation(characters):
for turn in range(1, 6): # 5ターンのバトル
print(f"\nターン {turn}:")
for character in characters:
action = random.choice(["attack", "special", "defend"])
if action == "attack":
print(character.attack())
elif action == "special" and character.mana >= 30:
print(character.special_move())
else:
print(character.defend())
# ターン終了時の簡易ステータス表示
print("\nターン終了時のステータス:")
for character in characters:
print(f"{character.name}: HP {character.health}, MP {character.mana}")
# キャラクター作成
characters = [
Warrior("アーサー", 100, 50),
Mage("マーリン", 80, 100),
Archer("ロビン", 90, 70),
Wizard("ガンダルフ", 85, 120),
Alchemist("ニコラス", 95, 80)
]
# バトルシミュレーション実行
battle_simulation(characters)
さて、このコードの素晴らしさを見ていこう：
容易な拡張性:
`Wizard` と `Alchemist` クラスを追加しても、`battle_simulation` 関数は全く変更する必要がなかった。
将来、新しいキャラクタークラス（例えば `Ninja` や `Bard`）を追加しても、同じく簡単に組み込めるぜ。
一貫したインターフェース:
全てのキャラクターが `attack()`, `special_move()`, `defend()` メソッドを持っているので、統一的に扱える。
これにより、`battle_simulation` 関数がシンプルに保たれている。
個性的な実装:
各キャラクターが独自の能力を持っていても（例：`Alchemist` のポーション）、共通のインターフェースで扱える。
`Wizard` の時間停止や `Alchemist` の毒攻撃など、独自の特徴を簡単に組み込めた。
コードの再利用:
基本的な構造は `Character` クラスで定義されているので、各サブクラスでコードの重複が最小限に抑えられている。
柔軟な動作:
ランダムな行動選択や、MPに基づく特殊技の使用制限など、複雑な動作も簡潔に実装できている。
保守性の高さ:
新しい共通機能（例えば「レベルアップ」）を追加したい場合、`Character` クラスに1箇所追加するだけで全キャラクターに適用できる。
このシステムの素晴らしいところは、キャラクターの数が増えても、`battle_simulation` 関数はほとんど変更する必要がないことだ。各キャラクターの具体的な実装を知る必要がなく、共通のインターフェースを通じて操作できるんだ。
例えば、今後 `Paladin`, `Necromancer`, `Druid` などの新クラスを追加しても、`battle_simulation` 関数は変更せずに、すぐにゲームに組み込めるんだぜ。
これこそがポリモーフィズムの真髄だ。複雑なシステムを柔軟かつ拡張性高く設計できる強力なツールなんだ。
どうだ？ポリモーフィズムの威力が存分に発揮されているのが分かるだろ？これこそが大規模なゲーム開発や複雑なソフトウェアシステムで重宝される理由なんだぜ。
まとめ
ユーザー:
初心者にも理解できるように、要点だけをまとめるとどうなりますか？
Claude3.5:
了解だ。初心者にもわかりやすく、ポリモーフィズムの核心をまとめてみよう。
ポリモーフィズム、簡単に言うと「同じ指示で異なる動作ができる能力」だよ。
例えば、動物園を想像してみて：
共通の指示:
飼育員が「鳴いて！」と言う。
異なる反応:
ライオン：「ガオー！」
鳥：「ピヨピヨ！」
ゾウ：「パオーン！」
これがポリモーフィズムの基本的な考え方なんだ。プログラミングでも同じことができるんだよ。
class Animal:
def make_sound(self):
pass
class Lion(Animal):
def make_sound(self):
return "ガオー！"
class Bird(Animal):
def make_sound(self):
return "ピヨピヨ！"
class Elephant(Animal):
def make_sound(self):
return "パオーン！"
def zookeeper_command(animal):
print(animal.make_sound())
# 動物たち
lion = Lion()
bird = Bird()
elephant = Elephant()
# 飼育員の指示
zookeeper_command(lion) # 出力: ガオー！
zookeeper_command(bird) # 出力: ピヨピヨ！
zookeeper_command(elephant) # 出力: パオーン！
ポイントはこれだけ：
共通のインターフェース:
全ての動物が `make_sound()` というメソッドを持っている。
個別の実装:
各動物が自分なりの方法で鳴く。
統一的な扱い:
`zookeeper_command()` 関数は、どの動物かを気にせず同じように扱える。
ポリモーフィズムの便利なところ：
拡張性が高い: 新しい動物（例：キリン）を追加しても、既存のコードを変更する必要がない。
コードがすっきりする: 動物ごとに別々の処理を書く必要がなくなる。
柔軟性が増す: 同じコードで異なる動作ができるので、プログラムの幅が広がる。
要するに、ポリモーフィズムを使えば、「同じ言葉で話しかけても、受け取る側によって反応が変わる」というような柔軟なプログラムが作れるんだ。これで複雑なシステムも、シンプルに設計できるようになるんだよ。
どうだ？ポリモーフィズムの基本、つかめたかな？
おまけ
Chat GPT-4の回答:
ポリモーフィズム（多態性）: 同じメソッド名で異なるクラスが独自の実装を持つことができる特性。これにより、異なるオブジェクトを同じ操作で扱うことができます。
この記事が気に入ったらサポートをしてみませんか？