ドラクエによるクラス解説 for Python

### 背景
いくつかの記事を拝見し、断片的な記事があるものの、実用性の観点からあまり見かけなかったため、今までの実務から鑑みてまとめていきます。
### 目的
Pythonクラスを使う時、初心者向けに以下の疑問を解消したい。

1. どうしてクラスを使うの？（使わないとどうなる？）
1. なぜわざわざクラス継承を使うの？（使わないとどうなる？）
1. クラス記述する時に、selfをつけるのって、面倒くさくて、なんのメリットがあるの？
1. ラッパーってなんに？（クラスがあるのになぜラッパー？）
1. インスタンスってなに？（これがないとだめ？）
1. クラスメソッドとクラス変数の違いってなに？
1. 「if ＿name＿ == '＿main＿':」というおまじない？

以下の内容は初心者向けではないので、対象外とする
1. 多重継承
1. イテレータ (iterator)
1. ジェネレータ (generator)
1. スコープと名前空間(global)
※マルチプロセス制御、モーター制御などで使われる
***
### どうしてクラスを使うの？（使わないとどうなる？）

・開発現場において、分業化が進んでいるため、複数人がチームを作って、それぞれ別々の機能の実装を担当している。そのため、共通機能と個別機能の設計書を作成してから実装することになっている場合が多い。
・設計段階では、共通機能設計書と個別機能設計書が、それぞれ、共通クラス、個別クラスとして実装される

<font color="Red"><B>クラスを使わないとどうなるの？

1. <font color="Red"><B>オブジェクト指向プログラミングの機能の欠如</font>: クラスを使用しない場合、オブジェクト指向プログラミングの機能（継承、カプセル化、ポリモーフィズムなど）を利用することができません。これにより、コードの再利用性や保守性が低下し、柔軟性が制限される可能性があります。

1. <font color="Red"><B>コードの分割と整理が難しくなる</font>: クラスを使用しない場合、関連する機能やデータをまとめて管理する方法が制限されます。これにより、大規模なプログラムを管理する際にコードの分割や整理が難しくなり、理解しやすい構造のプログラムを作成することが難しくなります。

1. <font color="Red"><B>変数や関数のグローバルスコープ化</font>: クラスを使用しない場合、変数や関数は通常、グローバルスコープに定義されます。これにより、変数や関数がプログラムのどこからでもアクセス可能になり、コードの依存関係が複雑化し、バグの発生やデバッグが困難になる可能性があります。

1. <font color="Red"><B>コードの再利用性の低下</font>: クラスを使用しない場合、関数や手続きを使って同じ機能を実現する必要があります。これにより、同じ機能を複数の場所で再利用することが難しくなり、コードの冗長性が増加する可能性があります。

1. <font color="Red"><B>プログラムの拡張性の低下</font>: クラスを使用しない場合、新しい機能を追加する際にプログラム全体を修正する必要がある場合があります。これにより、プログラムの拡張性が低下し、変更や修正が容易ではなくなる可能性があります。

総括すると、クラスを使用しない場合、プログラムの保守性、再利用性、拡張性が低下する可能性があります。特に大規模なプロジェクトでは、クラスを使用してオブジェクト指向プログラミングの原則を適用することが推奨されます。

<font color="Red"><B>あまり考えたことがないが、やっかいということは伝わると思います</B></font>
以下は、<font color="SpringGreen">パーティーを表示する</font>事例を示す。
```py
# play_game_04.py
class Hero:
    def __init__(self, name, level, hp):
        self.name = name
        self.level = level
        self.hp = hp

    def show_status(self):
        print(f"名前: {self.name}, レベル: {self.level}, HP: {self.hp}")

# 勇者のパーティーを表現するリスト
party = []

# 勇者のインスタンスを作成してリストに追加
hero1 = Hero("勇者", 1, 100)
hero2 = Hero("戦士", 1, 120)
hero3 = Hero("魔法使い", 1, 70)
hero4 = Hero("僧侶", 1, 90)

party.append(hero1)
party.append(hero2)
party.append(hero3)
party.append(hero4)

# パーティーの勇者のステータスを表示
for hero in party:
    hero.show_status()
```
実行結果
```terminal
$ python play_game_04.py 
名前: 勇者, レベル: 1, HP: 100
名前: 戦士, レベル: 1, HP: 120
名前: 魔法使い, レベル: 1, HP: 70
名前: 僧侶, レベル: 1, HP: 90
```
クラスを使わなくても良い場合はあるよ！
1. スクレイピングなどプログラム機能が単一で、開発規模が小さい場合
1. クラスをテストする業務に携わる場合
1. ちょっとした機能を試す場合
1. 手続き型プログラミングのスタイルにした場合
1. 関数型プログラミングのスタイルにした場合

以下は、Pythonの組み込み関数を使う<font color="SpringGreen">print</font>事例を示す。
```py
print('Dragon Quest‼')  
```

***
### なぜわざわざクラス継承を使うの？（使わないとどうなる？）
まずは、<font color="Red"><B>使わないとどうなるか</B></font>、ChatGPTに聞いてみました。

・Pythonではクラス継承を使わなくてもプログラムを書くことができますが、クラス継承を使用しない場合、以下のようなことが起こります。

1. <font color="Red"><B>コードの再利用性が低下する</font>: クラス継承は、共通の振る舞いや属性を持つオブジェクトのグループを作成し、それらの共通の振る舞いや属性を親クラスに定義することで、コードの再利用性を高めます。継承を使用しない場合、同じ機能を持つオブジェクトを作成するたびに同じコードを再度書く必要があります。

2. <font color="Red"><B>コードの保守性が低下する</font>: 継承を使用しない場合、コードが冗長になり、同じ機能や属性が複数の場所で再定義される可能性があります。これにより、コードの保守性が低下し、変更が必要な場合に全てのコードを手動で更新する必要があります。

3. <font color="Red"><B>オブジェクト指向プログラミングの原則に反する可能性がある</font>: クラス継承は、オブジェクト指向プログラミングの重要な原則の1つである"DRY (Don't Repeat Yourself)" 原則を支援します。継承を使用しない場合、同じコードが複数の場所に存在する可能性があり、これはDRY原則に反することになります。要は<font color="Red"><B>同じコードを書かない原則に反する。

4. <font color="Red"><B>コードの理解が難しくなる</font>: 継承を使用しない場合、同じ機能が複数の場所に分散して定義されるため、コードの理解が難しくなります。継承を使用することで、オブジェクトの階層構造が明確になり、コードの構造を理解しやすくなります。

<font color="SpringGreen"><B>使うメリットを教えて。

1. <font color="SpringGreen"><B>コードの再利用性</font>: 継承を使用することで、既存のクラスの機能を継承し、それを拡張することができます。親クラスに共通の振る舞いや属性を定義することで、子クラスはその機能を再利用することができます。これにより、コードの再利用性が向上し、冗長なコードを減らすことができます。

1. <font color="SpringGreen"><B>コードの簡潔性</font>: 継承を使用することで、新しいクラスを定義する際に親クラスの機能を利用することができます。親クラスで定義された共通の振る舞いや属性は、子クラスで再定義する必要がないため、コードがより簡潔になります。

1. <font color="SpringGreen"><B>拡張性</font>: 継承を使用することで、既存のクラスの機能を拡張し、新しい機能を追加することができます。親クラスの振る舞いを変更する必要がある場合は、親クラスを変更するだけで、すべての子クラスに影響を与えることができます。

1. <font color="SpringGreen"><B>ポリモーフィズムの実現</font>: 継承を使用することで、ポリモーフィズムを実現することができます。異なるクラスが同じインターフェースを持つことで、同じメソッドを使用して異なるクラスのオブジェクトを操作することができます。

1. <font color="SpringGreen"><B>コードの構造化</font>: 継承を使用することで、コードの階層構造を明確にすることができます。親クラスと子クラスの関係が明確になるため、コードの理解やメンテナンスが容易になります。

<font color="Cyan"><B>ゲームの主人公が敵からダメージを受けた場合を考えた事例
```py
# play_game.py 
class Character:
    def __init__(self, name, HP):
        self.name = name
        self.HP = HP

class Player(Character):
    def __init__(self, name, HP, level):
        super().__init__(name, HP)
        self.level = level

class Enemy(Character):
    def __init__(self, name, HP, damage):
        super().__init__(name, HP)
        self.damage = damage

if __name__ == '__main__':
    # キャラクター名：ライアン HP：100 レベル:5 として設定
    laian = Player('ライアン',100,5)
    # モンスター名：スライム HP：20 ダメージ:3 として設定
    slime = Enemy('スライム',20, 3)
    # ライアンが攻撃を受ける前のHPを表示
    print(laian.HP)
    # 主人公が敵からダメージを受けた場合（HPからダメージを引き算して残りのHPを計算する）
    laian.HP = laian.HP - slime.damage
    # ライアンが攻撃を受けた後のHPを表示
    print(laian.HP)
```
実行結果：
```terminal
$ python play_game.py 
100  
97   
```
***
### クラス記述する時に、selfをつけるのって、面倒くさくて、なんのメリットがあるの？

1. <font color="SpringGreen"><B>インスタンス変数へのアクセス</font>: インスタンスメソッド内でインスタンス変数にアクセスできます。

1. <font color="SpringGreen"><B>インスタンスメソッドの呼び出し</font>: インスタンスメソッド内で他のインスタンスメソッドを呼び出すことができます。

1. <font color="SpringGreen"><B>クラス変数へのアクセス</font>: インスタンスメソッド内でクラス変数にアクセスできます。

1. これにより、self を使用することで、<font color="SpringGreen"><B>インスタンスごとに異なる状態を保持し、操作</font>することができます。

ゲームの主人公が<font color="Cyan"><B>複数のスライムからダメージを受けた場合</font>を考えた事例
```py
# play_game.py 
class Character:
    def __init__(self, name, HP):
        self.name = name
        self.HP = HP

class Player(Character):
    def __init__(self, name, HP, level):
        super().__init__(name, HP)
        self.level = level

class Enemy(Character):
    def __init__(self, name, HP, damage):
        super().__init__(name, HP)
        self.damage = damage

if __name__ == '__main__':
    # キャラクター名：ライアン HP：100 レベル:5 として設定
    laian = Player('ライアン',100,5)
    # モンスター名：スライム01 HP：20 ダメージ:3 として設定
    slime_01 = Enemy('スライム01',20, 3)
    # モンスター名：スライム02 HP：18 ダメージ:2 として設定
    slime_02 = Enemy('スライム01',18, 2)
    # ライアンが攻撃を受ける前のHPを表示
    print(laian.HP)
    # 主人公がスライム01からダメージを受けた場合（HPからダメージを引き算して残りのHPを計算する）
    laian.HP = laian.HP - slime_01.damage
    print(laian.HP)
    # 主人公がスライム02からダメージを受けた場合（HPからダメージを引き算して残りのHPを計算する）
    laian.HP = laian.HP - slime_02.damage
    # ライアンが攻撃を受けた後のHPを表示
    print(laian.HP)
```
実行結果：
```terminal
$ python play_game.py 
100  
97
95
```
ここまで来てもおそらくselfの意味が湧かないと思いますが、さらに説明は続きます。
ここは、クラスメソッド内に「self」をつけると<font color="SpringGreen"><B>インストラクター内のすべての変数を参照できる</font>だと覚えて。
***
### ラッパーってなんに？（クラスがあるのになぜラッパー？）
Pythonにおいてクラスへのアクセスをラップ（包装）する方法はいくつかあります：

1. **デコレータを使用したクラスラッパー**:
   既存のクラスを変更せずに機能を追加するための方法。デコレータ関数内で新しいクラスを定義し、元のクラスの代わりに返すことで、元のクラスをラップする。

2. **継承を使用したクラスラッパー**:
   新しいクラスを定義し、ラップしたいクラスを継承することで、元のクラスをラップする。

3. **コンポジションを使用したクラスラッパー**:
   クラス内に他のクラスのインスタンスを持ち、その機能を使用する方法。新しいクラスを定義し、ラップしたいクラスのインスタンスを作成し、必要に応じてそのメソッドを呼び出すことで、元のクラスをラップする。

これらの方法は、既存のクラスを変更せずに機能を追加したり、特定の振る舞いをカプセル化したりするための便利な方法です。適切な方法は、使用ケースや目的に応じて異なります。

ゲームの主人公が、<font color="Cyan"><b>バイキルトが掛かっているスライム</font>からダメージを受けた場合
ラッパーを使うことにより、一時的スライムから受けるダメージを2倍にすることができる

```py
# play_game_02.py 
class Character:
    def __init__(self, name, HP):
        self.name = name
        self.HP = HP

class Player(Character):
    def __init__(self, name, HP, level):
        super().__init__(name, HP)
        self.level = level

class Enemy(Character):
    def __init__(self, name, HP, damage):
        super().__init__(name, HP)
        self.damage = damage

# バイキルトラッパー
def baikilled_rapper(name, HP, damage, bairitsu):
    return Enemy(name, HP, damage*bairitsu)

if __name__ == '__main__':
    # キャラクター名：ライアン HP：100 レベル:5 として設定
    laian = Player('ライアン',100,5)
    # モンスター名：スライム01 HP：20 ダメージ:3 バイキルトは2倍
    slime_baikilled = baikilled_rapper('スライム',20, 3, 2)
   
    # ライアンが攻撃を受ける前のHPを表示
    print(laian.HP)
    # 主人公がスライム01からダメージを受けた場合（HPからダメージを引き算して残りのHPを計算する）
    laian.HP = laian.HP - slime_baikilled.damage
    # ライアンが攻撃を受けた後のHPを表示
    print(laian.HP)
```
```terminal
$ python play_game_02.py 
100
94
```
※これを応用すれば、痛恨の一撃なども可能となる
***
### インスタンスってなに？（これがないとだめ？）
ドラゴンクエスト（Dragon Quest）のゲームを例に、Pythonのクラスとインスタンスを説明する
以下に勇者クラス、モンスタークラス、攻撃する/攻撃を受けるクラスを実装する
```py
# 基底クラス
class Character:
    def __init__(self, name, HP):
        self.name = name
        self.HP = HP
        
#プレーヤークラス
class Player(Character):
    def __init__(self, name, HP, level, attack_value):
        super().__init__(name, HP)
        self.level = level
        self.attack_value = attack_value

    def show_status(self):
        print(f"名前: {self.name}, レベル: {self.level}, HP: {self.HP}")
        
# モンスタークラス
class Enemy(Character):
    def __init__(self, name, HP, attack_value):
        super().__init__(name, HP)
        self.attack_value = attack_value

    def show_status(self):
        print(f"名前: {self.name}, HP: {self.HP}")
    

# 攻撃する/攻撃を受けるクラス
class Player_Attack(Character):
    def __init__(self, name, HP, val):
        super().__init__(name, HP)
        self.val = val

    def attack(self, enemy):
        self.enemy = enemy
        print(f"{self.name}の攻撃！")
        self.take_damage(self.val)

    def take_damage(self, damage):
        print(f"{self.enemy.name}は{damage}のダメージを受けた！")
        self.enemy.HP -= damage
        if self.enemy.HP <= 0:
            print(f"{self.enemy.name}を倒しました！")
```

### 戦闘シーン１：勇者がスライムを攻撃する
```py
if __name__ == '__main__':
    # 戦闘シーンその1
    print('戦闘シーン1')
    # 勇者のインスタンスの作成
    hero = Player("勇者", 100, 1, 10)
    # スライムのインスタンスの作成
    slime = Enemy("スライム", 10, 3)
    print(f'{slime.name}が現れました!')
    slime.show_status()
    # 勇者が攻撃するインスタンスの作成
    hero_at = Player_Attack(hero.name, hero.HP, hero.attack_value)
    # 勇者がスライムを攻撃する
    hero_at.attack(slime)
    slime.show_status()
    print('戦闘完了')
```
実行結果：
```terminal
$ python play_game_03.py 
戦闘シーン1
スライムが現れました!
名前: スライム, HP: 10
勇者の攻撃！
スライムは10のダメージを受けた！
スライムを倒しました！
名前: スライム, HP: 0
戦闘完了
```
このようにして、勇者、スライム、攻撃というそれぞれのインスタンスはそれぞれ以下：
```py
# 勇者のインスタンスの作成
hero = Player("勇者", 100, 1, 10)
# スライムのインスタンスの作成
slime = Enemy("スライム", 10, 3)
# 勇者が攻撃するインスタンスの作成
hero_at = Player_Attack(hero.name, hero.HP, hero.attack_value)
```
勇者がスライムを攻撃する場合は以下の3部構成で実装している
<font color="SpringGreen">勇者の攻撃インスタンス: hero_at</font>
<font color="SpringGreen">攻撃メソッド: attack()</font>
<font color="SpringGreen">攻撃する敵もインスタンス: slime </font>
```py
# 勇者がスライムを攻撃する
hero_at.attack(slime)
```

これを駆使しながら、戦闘シーンのメッセージを表示することができる
一回目の戦闘でスライムのHPが0になったため、戦闘終了した。

### 戦闘シーンその2
逆に勇者がスライムへ攻撃し、そしてスライムから勇者へ反撃する戦闘シーンは以下に示す。
```py
    # 戦闘シーンその2
    print('戦闘シーン2')
    # 勇者のインスタンスの作成
    hero = Player("勇者", 100, 1, 10)
    # スライムのインスタンスの作成
    slime = Enemy("スライム", 15, 3)
    print(f'{slime.name}が現れました!')
    slime.show_status()
    # 勇者が攻撃するインスタンスの作成
    hero_at = Player_Attack(hero.name, hero.HP, hero.attack_value)
    hero_at.attack(slime)
    slime.show_status()
    # スライムが攻撃するインスタンスの作成
    slime_at = Player_Attack(slime.name, slime.HP, slime.attack_value)
    slime_at.attack(hero)
    hero.show_status()
```
実行結果：
```terminal
戦闘シーン2
スライムが現れました!
名前: スライム, HP: 15
勇者の攻撃！
スライムは10のダメージを受けた！
名前: スライム, HP: 5
スライムの攻撃！
勇者は3のダメージを受けた！
名前: 勇者, レベル: 1, HP: 97
```
このように交互の攻撃を再現することができる
***
### クラスメソッドとクラス変数の違いってなに？
クラスに<font color="Red"><B>イオ</font>と<font color="SpringGreen"><B>ベホマラー</font>魔法を実装する
```py
class Hero:
    party_count = 0  # クラス変数

    def __init__(self, name, level, hp):
        self.name = name
        self.level = level
        self.hp = hp
        Hero.party_count += 1  # インスタンスが作成されるたびにクラス変数をインクリメント

    @classmethod
    def get_party_count(cls):  # クラスメソッド
        return cls.party_count

    # ベホマラー
    @staticmethod
    def heal_all_party_members(party, heal_val):  # スタティックメソッド
        for hero in party:
            hero.hp += heal_val  # 全てのパーティーメンバーのHPを回復

    # イオ
    @staticmethod
    def bang_attack(party, damage):
        for hero in party:
            hero.hp -= damage
    
    def show_status(self):
        print(f"名前: {self.name}, レベル: {self.level}, HP: {self.hp}")

```
ドラクエでパーティー全員がイオ魔法を受けた後にベホマラーで回復したシーンを考える
```py
# インスタンスの作成
hero1 = Hero("勇者1", 1, 100)
hero2 = Hero("勇者2", 1, 120)
hero3 = Hero("勇者3", 1, 130)

# クラスメソッドの呼び出し
print("パーティーの人数:", Hero.get_party_count())  # 出力: パーティーの人数: 3

# スタティックメソッドの呼び出し
party = [hero1, hero2, hero3]

print('初期ステータス：')
for hero in party:
    hero.show_status()

print('イオの攻撃を受ける：')
# イオの攻撃を受ける
Hero.bang_attack(party, 50)

# 各勇者のステータス表示
for hero in party:
    hero.show_status()

print('ベホマラー回復：')
# 全員回復（ベホマラー）
Hero.heal_all_party_members(party, 30)

# 各勇者のステータス表示
for hero in party:
    hero.show_status()
```
この中で、クラスメソッド（<font color="Red"><B>イオ</font>と<font color="SpringGreen"><B>ベホマラー</font>がメソッド）：
```py
show_status()
heal_all_party_members()
bang_attack()
get_party_count()
```
メンバー変数（勇者の名前、レベル、HP、パーティー人数）：
```py
name
level
hp
party_count
```
()が付いているのが、メソッドで、付いていないのが変数となる。
なお、partyはローカル変数(リストの中にインスタンスを格納している）
```py
party
```

出力結果
```terminal
パーティーの人数: 3
初期ステータス：
名前: 勇者1, レベル: 1, HP: 100
名前: 勇者2, レベル: 1, HP: 120
名前: 勇者3, レベル: 1, HP: 130
イオの攻撃を受ける：
名前: 勇者1, レベル: 1, HP: 50
名前: 勇者2, レベル: 1, HP: 70
名前: 勇者3, レベル: 1, HP: 80
ベホマラー回復：
名前: 勇者1, レベル: 1, HP: 80
名前: 勇者2, レベル: 1, HP: 100
名前: 勇者3, レベル: 1, HP: 110
```
***
### 「if ＿name＿ == '＿main＿':」というおまじないについて

`if __name__ == '__main__':` のおまじないを使用する利点は次の通りです：

1. <font color="SpringGreen"><B>**再利用性の向上**</font>: モジュールとして定義された関数やクラスは、他のスクリプトからインポートして再利用することができます。このおまじないを使用することで、モジュール内の関数やクラスの定義と、モジュールが直接実行されたときにのみ実行されるコードを分離することができます。これにより、再利用性が向上し、モジュールの利用が容易になります。

2. <font color="SpringGreen"><B>**テスト容易性の向上**</font>: モジュールが直接実行された場合、通常はそのモジュールに関するテストコードやデバッグ用のコードを実行します。このおまじないを使用することで、モジュールが直接実行された場合の振る舞いをテストしやすくなります。また、このおまじないを使用して、テストコードと本番用のコードを分離することもできます。

3. <font color="SpringGreen"><B>**不必要な処理の回避**</font>: モジュールが直接実行された場合にのみ実行されるコードを、このおまじないを使用することで明示的に指定することができます。これにより、不必要な処理や副作用が他のスクリプトからモジュールがインポートされた際に発生するのを防ぐことができます。

総括すると、`if __name__ == '__main__':` のおまじないを使用することで、モジュールの再利用性を向上させ、テスト容易性を高め、不必要な処理の回避が可能になります。これは、Pythonスクリプトをモジュールとして設計する際に非常に役立ちます。

***
### 感想：
クラスについての説明は意外に難しいと思いました。
なお、実際にゲームを実装する際に、グラフィックだったり、マップだったり、戦闘の動画シーンなどがあるので、こんなに簡単と言う訳にはいかないです。