オブジェクト指向 on Miura Computer Club

レッスン119

Mon, 10 Aug 2026 09:00:00 +0900

クラス入門その２　クラスを使ってゲームを作ろう

レッスン118で習ったクラスを使って、Pythonで簡単なゲームを作ってみましょう。最初はとてもシンプルなゲームですが、徐々に機能を追加していきます。

作成するゲームはポケモンバトルゲームです。 3匹のポケモンが登場し、そのうち2匹が戦います。

必要な「クラス」はPokemonクラスとBattle（戦闘）クラスです。 Battle（戦闘）クラスはあらかじめ用意してあるので、Pokemonクラスを作成していきます。

作成するクラス

Pokemonクラスを作成してください。 Pokemonクラスは以下のような仕組みを持っています。

コンストラクタ(__init__メソッド）
```
def __init__(self, name, hp, attack):
	...
```
というメソッドを定義します。

クラスからインスタンス（実体）を作成する時に呼ばれるメソッドを「コンストラクタ」と呼びます。 Pythonでは__init__(self, 引数)という名前のメソッドが「コンストラクタ」です。

以下の引数を設定し、属性(self.XXXXという変数）に設定します。
```
 - name （ポケモンの名前、文字列）
 - hp (ポケモンの体力、整数）
 - attack （ポケモンの攻撃力、整数）
```
take_damageメソッド
```
def take_damage(self, damage):
	...
```
というメソッドを定義します。

ポケモンがダメージを受けた時に呼ばれて、引数のdamage分、ポケモンのhpを減らします。ただし、hpは0より小さくは（マイナスには）なりません。

同時に、以下のようなprint文を表示してください。 {}の部分に具体的な文字列や数字が入ります。

{ポケモンの名前} は {ダメージの値} ダメージを受けた！（残りHP: {HPの値}）

print文で表示する文字列の中に変数（属性）の値を入れたい場合は、f"文字列{変数名}文字列"のような書き方をします。ポケモンの名前の属性はself.name、ダメージの変数はdamage、HPの値の属性はself.hpなので以下のように記述します。
```
print(f"{self.name} は {damage} ダメージを受けた！（残りHP: {self.hp}）")
```
is_faintedメソッド
```
def is_fainted(self):
	...
	return ...
```
というメソッドを定義します。

ポケモンが戦闘不能（HPが0）かどうかを判定するメソッドです。

戻り値（メソッドがreturnで返す値）はTrue（戦闘不能）かFalse（戦闘可能）です。

課題１

以下のサンプルコードをコピペして、Pokemon.pyというファイルを作成してください。これにPokemonクラスを追加してプログラムを完成させてください。

# ここにポケモンクラスを追加してください。

class Battle:	#ポケモン同士が戦闘するクラス
	def __init__(self, pokemon1, pokemon2):	# 戦闘する２匹のポケモンを指定する
		self.pokemon1 = pokemon1
		self.pokemon2 = pokemon2
		
	def fight(self):	# ポケモン同士が戦闘する
		print(f"\n{self.pokemon1.name} vs {self.pokemon2.name} の戦闘開始！")
		turn = 0	# 交互に攻撃するためのターンの回数
		while True:	# 戦闘ループ
			if turn % 2 == 0:	# 偶数のターン回数だったら
				attacker = self.pokemon1		# 攻撃するのはポケモン１
				defender = self.pokemon2 	# 攻撃されるのはポケモン２
			else:	# 奇数のターン回数だったら
				attacker = self.pokemon2		# 攻撃するのはポケモン２
				defender = self.pokemon1 	# 攻撃されるのはポケモン１
			print(f"\n{attacker.name} の攻撃！")
			defender.take_damage(attacker.attack)	# 攻撃するポケモンの攻撃力で攻撃されるポケモンはダメージを受ける
			
			if defender.is_fainted():	# 攻撃されたポケモンが戦闘不能になったら
				print(f"\n{defender.name} は倒れた！ {attacker.name} の勝ち！")
				break	# 戦闘ループから抜ける
			
			turn += 1		# ターン回数を更新する
			
if __name__ == '__main__':	# メインプログラム
	charmander = Pokemon("ヒトカゲ", 100, 40)	# ヒトカゲポケモンを作成
	squirtle = Pokemon("ゼニガメ", 100, 40)	# ゼニガメポケモンを作成
	bulbasaur = Pokemon("フシギダネ", 100, 40)	# フシギダネポケモンを作成
	
	battle = Battle(charmander, squirtle)		# ヒトカゲとゼニガメがバトルフィールドへ
	battle.fight()	# 戦闘開始

１〜３のメソッドを持ったPokemonクラスを追加して、このプログラムを完成させ、実行するとコンソールに以下が表示されます。

ヒトカゲ vs ゼニガメ の戦闘開始！

ヒトカゲ の攻撃！
ゼニガメ は 40 ダメージを受けた！（残りHP: 60）

ゼニガメ の攻撃！
ヒトカゲ は 40 ダメージを受けた！（残りHP: 60）

ヒトカゲ の攻撃！
ゼニガメ は 40 ダメージを受けた！（残りHP: 20）

ゼニガメ の攻撃！
ヒトカゲ は 40 ダメージを受けた！（残りHP: 20）

ヒトカゲ の攻撃！
ゼニガメ は 40 ダメージを受けた！（残りHP: 0）

ゼニガメ は倒れた！ ヒトカゲ の勝ち！

回答例

class Pokemon:
    def __init__(self, name, hp, attack):
        self.name = name
        self.hp = hp
        self.attack = attack
    
    def take_damage(self, damage):
        self.hp -= damage
        if self.hp < 0:
            self.hp = 0
        print(f"\n{self.name} は {damage} ダメージを受けた！（残りHP: {self.hp}）")
        
    def is_fainted(self):
        return self.hp == 0

課題２

ポケモンに「炎」、「水」、「草」などのポケモンタイプ(poke_type)を追加してください。

それぞれのポケモンタイプには弱点と強みがあります。

ポケモンタイプ	弱点	強み
炎	水	草
水	草	炎
草	炎	水

Pokemonクラスのコンストラクタの引数に「poke_type」を追加し、ポケモンの属性も追加して設定する
Pokemonクラスに「クラス変数」としてタイプの強みと弱みのテーブル（辞書）type_chartを追加する
```
class Pokemon:
	type_chart = {
		"炎" : {"弱点" : "水", "強み" : "草"},		# 炎タイプの弱点は水、強みは草
		"水" : {"弱点" : "草", "強み" : "炎"},		# 水タイプの弱点は草、強みは炎
		"草" : {"弱点" : "炎", "強み" : "水"}		# 草タイプの弱点は炎、強みは水
	}
	def __init__(self, name, hp, attack, poke_type):
	...
```
このように、クラスのすぐ下に定義される変数を「クラス変数」と言い、クラス共通で使用する値を設定することができます。クラス変数はPokemon.type_chartのように{クラス名}.{クラス変数名}で参照することができます。

自分のポケモンタイプから強み・弱点を取得するには、以下のようにして参照することができます。

自分のポケモンタイプの強み： Pokemon.type_chart[self.poke_type]['強み']

自分のポケモンタイプの弱点： Pokemon.type_chart[self.poke_type]['弱点']
ポケモンのタイプとそのタイプの強み・弱点を以下のように表示するshow_type_advantage()メソッドを追加する

表示する内容の例は以下の通りです。
```
ヒトカゲ のタイプ: 炎
 - 弱点: 水
 - 強み: 草
```
ポケモン作成後に、このhow_type_advantage()メソッドを呼んで表示します。
take_damage()メソッドを変更する

引数をダメージ(damage)から相手のポケモン(opponent)に変更し、ダメージ(damage)は相手のポケモンの攻撃力(attack)に設定します。さらに、ポケモン同士の相性にしたがい、相手のポケモンのタイプが自分の弱点であれば、ダメージ(damage)を1.5倍し、自分の強みであればダメージ(damage)を0.5倍にします。

これらの変更を行って、プログラムを実行すると以下のようにコンソールに表示されます。

ヒトカゲ のタイプ： 炎
 - 弱点： 水
 - 強み： 草
ゼニガメ のタイプ： 水
 - 弱点： 草
 - 強み： 炎
フシギダネ のタイプ： 草
 - 弱点： 炎
 - 強み： 水
 
ヒトカゲ vs ゼニガメ の戦闘開始！

ヒトカゲ の攻撃！
ゼニガメ は 20 ダメージを受けた！（残りHP: 80）

ゼニガメ の攻撃！
ヒトカゲ は 60 ダメージを受けた！（残りHP: 40）

ヒトカゲ の攻撃！
ゼニガメ は 20 ダメージを受けた！（残りHP: 60）

ゼニガメ の攻撃！
ヒトカゲ は 60 ダメージを受けた！（残りHP: 0）

ヒトカゲ は倒れた！ ゼニガメ の勝ち！

Pokemon.pyを修正して、実行結果が上記のようになるようにしてください。

回答例

class Pokemon:
	type_chart = {	# タイプ同士の相性テーブル（クラス変数）
		"炎" : {"弱点" : "水", "強み" : "草"},
		"水" : {"弱点" : "草", "強み" : "炎"},
		"草" : {"弱点" : "炎", "強み" : "水"}
	}

	def __init__(self, name, hp, attack, poke_type):
		self.name = name
		self.hp = hp
		self.attack = attack
		self.poke_type = poke_type	# ポケモンのタイプを追加
		
	def show_type_advantage(self):	# ポケモンのタイプを表示するメソッド
		print(f"{self.name} のタイプ： {self.poke_type}")
		print(f" - 強み： {Pokemon.type_chart[self.poke_type]['強み']}")
		print(f" - 弱点： {Pokemon.type_chart[self.poke_type]['弱点']}")
    
	def take_damage(self, opponent):	# 引数を戦闘相手のポケモンに変更
		if Pokemon.type_chart[self.poke_type]['強み'] == opponent.poke_type:	# 戦闘相手のポケモンのタイプが「強み」なら
			damage = int(opponent.attack * 0.5)	# ダメージが半減
		elif Pokemon.type_chart[self.poke_type]['弱点'] == opponent.poke_type:	# 戦闘相手のポケモンのタイプが「弱点」なら
			damage = int(opponent.attack * 1.5)	# ダメージが1.5倍
		else:	# それ以外なら
			damage = opponent.attack	# 攻撃力がそのままダメージになる	
		self.hp -= damage
		if self.hp < 0:
			self.hp = 0
		print(f"\n{self.name} は {damage} ダメージを受けた！（残りHP: {self.hp}）")
        
	def is_fainted(self):
		return self.hp == 0
        
class Battle:	#ポケモン同士が戦闘するクラス
	def __init__(self, pokemon1, pokemon2):	# 戦闘する２匹のポケモンを指定する
		self.pokemon1 = pokemon1
		self.pokemon2 = pokemon2
		
	def fight(self):	# ポケモン同士が戦闘する
		print(f"\n{self.pokemon1.name} vs {self.pokemon2.name} の戦闘開始！")
		turn = 0	# 交互に攻撃するためのターンの回数
		while True:	# 戦闘ループ
			if turn % 2 == 0:	# 偶数のターン回数だったら
				attacker = self.pokemon1		# 攻撃するのはポケモン１
				defender = self.pokemon2 	# 攻撃されるのはポケモン２
			else:	# 奇数のターン回数だったら
				attacker = self.pokemon2		# 攻撃するのはポケモン２
				defender = self.pokemon1 	# 攻撃されるのはポケモン１
			print(f"\n{attacker.name} の攻撃！")
			defender.take_damage(attacker)	# 攻撃する相手のポケモンから攻撃されるポケモンはダメージを受ける
			
			if defender.is_fainted():	# 攻撃されたポケモンが戦闘不能になったら
				print(f"\n{defender.name} は倒れた！ {attacker.name} の勝ち！")
				break	# 戦闘ループから抜ける
			
			turn += 1		# ターン回数を更新する
			
if __name__ == '__main__':	# メインプログラム
	charmander = Pokemon("ヒトカゲ", 100, 40, "炎")	# ヒトカゲポケモンを作成
	charmander.show_type_advantage()	# ポケモンのタイプと特徴を表示
	squirtle = Pokemon("ゼニガメ", 100, 40, "水")	# ゼニガメポケモンを作成
	squirtle.show_type_advantage()	# ポケモンのタイプと特徴を表示
	bulbasaur = Pokemon("フシギダネ", 100, 40, "草")	# フシギダネポケモンを作成
	bulbasaur.show_type_advantage()		# ポケモンのタイプと特徴を表示
	
	battle = Battle(charmander, squirtle)		# ヒトカゲとゼニガメがバトルフィールドへ
	battle.fight()	# 戦闘開始

課題３

ポケモンが相手を攻撃するとき、本来は「わざ」を使います。また、ポケモンの攻撃の威力はポケモン同士のタイプの相性によるのではなく、攻撃をうけたポケモンのタイプと攻撃の「わざ」のタイプの相性によります。

そこで、「Waza」というクラスを追加して、ポケモンが「わざ」を使って攻撃するようにしてみましょう。

Wazaクラスには以下の属性があります
```
 - 「わざ」の名前(name)
 - 「わざ」のタイプ(waza_type)
 - 「わざ」の威力(power)
```
コンストラクタ(__init__())でこれらを受け取って、属性に設定してください
Wazaクラスには、「わざ」の名前と威力を文字列で返す__str__()メソッドがあります

戻り値（返す値）： {わざの名前} {わざの威力｝

例：ひのこ 40

クラスに__str__()メソッドがあると、クラスのオブジェクト（インスタンス）をprintしたとき、このメソッドの戻り値が表示されます。

各ポケモンが持っている「わざ」は以下の通り

メインプログラムの先頭でこれらの「わざ」を作成し、各ポケモンに設定します。

ポケモン	わざの名前	わざのタイプ	わざの威力
ヒトカゲ	ひのこ	炎	40
ゼニガメ	みずでっぽう	水	40
フシギダネ	はっぱカッター	草	40

Pokemonクラスの属性のうち、攻撃力(attack)を、「わざ」(waza)という属性に変えます

コンストラクタで受け取るものもattackではなくwazaになります。
take_damageメソッドにおいて、ダメージ(damage)を相手の攻撃力(attack)ではなく、相手の「わざ」(waza)の威力(power)に変更します

damage = opponent.waza.powerになります
take_damageメソッドにおいて、ダメージ(damage)の効果に影響するのは相手のタイプ(opponent.poke_type)ではなく、相手の「わざ」のタイプに変更します

相手の「わざ」のタイプ： opponent.waza.waza_type
show_type_advantageメソッドにおいて、以下のように「わざ」の名前と威力も表示します
```
ヒトカゲ のタイプ: 炎
 - 弱点: 水
 - 強み: 草
 - わざ: ひのこ 40
```
Battleクラスのfightメソッドにおいて、ポケモンの攻撃メッセージに「わざ」の名前と威力も追加します

Pokemonクラスのwaza「わざ」も追加し、以下のように表示させます。

例：　ヒトカゲの攻撃！ひのこ 40!!

これらの変更を行って、プログラムを実行すると以下のようにコンソールに表示されます。

ヒトカゲ のタイプ： 炎
 - 弱点： 水
 - 強み： 草
 - わざ： ひのこ 40
ゼニガメ のタイプ： 水
 - 弱点： 草
 - 強み： 炎
 - わざ： みずでっぽう 40
フシギダネ のタイプ： 草
 - 弱点： 炎
 - 強み： 水
 - わざ： はっぱカッター 40
 
ヒトカゲ vs ゼニガメ の戦闘開始！

ヒトカゲ の攻撃！ ひのこ 40!!
ゼニガメ は 20 ダメージを受けた！（残りHP: 80）

ゼニガメ の攻撃！ みずでっぽう 40!!
ヒトカゲ は 60 ダメージを受けた！（残りHP: 40）

ヒトカゲ の攻撃！ ひのこ 40!!
ゼニガメ は 20 ダメージを受けた！（残りHP: 60）

ゼニガメ の攻撃！みずでっぽう 40!!
ヒトカゲ は 60 ダメージを受けた！（残りHP: 0）

ヒトカゲ は倒れた！ ゼニガメ の勝ち！

Pokemon.pyを修正して、実行結果が上記のようになるようにしてください。

回答例

class Waza:
	def __init__(self, name, power, waza_type):
		self.name = name
		self.power = power
		self.waza_type = waza_type
		
	def __str__(self):
		return f"{self.name} {self.power}"
		
class Pokemon:
	type_chart = {
		"炎" : {"弱点" : "水", "強み" : "草"},
		"水" : {"弱点" : "草", "強み" : "炎"},
		"草" : {"弱点" : "炎", "強み" : "水"}
	}

	def __init__(self, name, hp, waza, poke_type):
		self.name = name
		self.hp = hp
		self.waza = waza
		self.poke_type = poke_type
		
	def show_type_advantage(self):
		print(f"{self.name} のタイプ： {self.poke_type}")
		print(f" - 強み： {Pokemon.type_chart[self.poke_type]['強み']}")
		print(f" - 弱点： {Pokemon.type_chart[self.poke_type]['弱点']}")
		print(f" - わざ： {self.waza}")
    
	def take_damage(self, opponent):
		if Pokemon.type_chart[self.poke_type]['強み'] == opponent.waza.waza_type:
			damage = int(opponent.waza.power * 0.5)
		elif Pokemon.type_chart[self.poke_type]['弱点'] == opponent.waza.waza_type:
			damage = int(opponent.waza.power * 1.5)
		else:
			damage = opponent.waza.power
		self.hp -= damage
		if self.hp < 0:
			self.hp = 0
		print(f"\n{self.name} は {damage} ダメージを受けた！（残りHP: {self.hp}）")
        
	def is_fainted(self):
		return self.hp == 0
        
class Battle:	#ポケモン同士が戦闘するクラス
	def __init__(self, pokemon1, pokemon2):	# 戦闘する２匹のポケモンを指定する
		self.pokemon1 = pokemon1
		self.pokemon2 = pokemon2
		
	def fight(self):	# ポケモン同士が戦闘する
		print(f"\n{self.pokemon1.name} vs {self.pokemon2.name} の戦闘開始！")
		turn = 0	# 交互に攻撃するためのターンの回数
		while True:	# 戦闘ループ
			if turn % 2 == 0:	# 偶数のターン回数だったら
				attacker = self.pokemon1		# 攻撃するのはポケモン１
				defender = self.pokemon2 	# 攻撃されるのはポケモン２
			else:	# 奇数のターン回数だったら
				attacker = self.pokemon2		# 攻撃するのはポケモン２
				defender = self.pokemon1 	# 攻撃されるのはポケモン１
			print(f"\n{attacker.name} の攻撃！ {attacker.waza}!!")
			defender.take_damage(attacker)	# 攻撃するポケモンの攻撃力で攻撃されるポケモンはダメージを受ける
			
			if defender.is_fainted():	# 攻撃されたポケモンが戦闘不能になったら
				print(f"\n{defender.name} は倒れた！ {attacker.name} の勝ち！")
				break	# 戦闘ループから抜ける
			
			turn += 1		# ターン回数を更新する
			
if __name__ == '__main__':	# メインプログラム

	fire_waza = Waza("ひのこ", 40, "炎")				# 炎わざ「ひのこ」威力40
	water_waza = Waza("みずでっぽう", 40, "水")		# 水わざ「みずでっぽう」威力40
	grass_waza = Waza("はっぱカッター", 40, "草")		# 草わざ「はっぱカッター」威力40
	
	charmander = Pokemon("ヒトカゲ", 100, fire_waza, "炎")	# ヒトカゲポケモンを作成
	charmander.show_type_advantage()
	squirtle = Pokemon("ゼニガメ", 100, water_waza, "水")	# ゼニガメポケモンを作成
	squirtle.show_type_advantage()
	bulbasaur = Pokemon("フシギダネ", 100, grass_waza, "草")	# フシギダネポケモンを作成
	bulbasaur.show_type_advantage()
	
	battle = Battle(charmander, squirtle)		# ヒトカゲとゼニガメがバトルフィールドへ
	battle.fight()	# 戦闘開始

課題４

レッスン119で習ったクラスの「継承」「ポリモーフィズム」を使って、プログラムをリファクタリング（作り直し）してみましょう。

Pokemonクラスを抽象クラスにし、各ポケモンタイプごとに新たなクラスを作成します

abcライブラリをimportしてABC, abstractmethodが使えるようにし、Pokemonクラスを抽象クラスに設定します
```
from abc import ABC, abstractmethod
...
class Pokemon(ABC):
	...
```
Pokemonクラスからtype_chartクラス変数とポケモンタイプの属性を削除します
```
class Pokemon(ABC):
	def __init__(self, name, hp, waza):
		...
```
show_type_advantageメソッドを仮想メソッドにします
```
@abstractmethod
def show_type_advantage(self):
	pass
```

get_damageという仮想メソッドを追加します

@abstractmethod
def get_damage(self, opponent):
	pass

take_damageメソッドにおいて、damageを取得する部分を上記のget_damageメソッドから取得するように変更します
```
def take_damage(self, opponent):
	damage = self.get_damage(opponent)
	self.hp -= damage
	...
```
炎ポケモンクラス(Fire_Pokemon)、水ポケモンクラス(Water_Pokemon)、草ポケモンクラス(Grass_Pokemon)を作成し、Pokemonクラスを継承します
```
class Fire_Pokemon(Pokemon):
	...
class Water_Pokemon(Pokemon):
	...
class Grass_Pokemon(Pokemon):
	...
```

各クラスにshow_type_advantageメソッドと、get_damageメソッドを追加します

type_charテーブルを削除したので、このテーブルを使わず、代わりに各クラスに対応した情報を直接書き込みます。

例：Grass_Pokemonクラス

class Grass_Pokemon(Pokemon):

	def show_type_advantage(self):
		print(f"{self.name} のタイプ： 草")
		print(" - 強み： 水")
		print(" - 弱点： 炎")
		print(f" - わざ： {self.waza}")

	def get_damage(self, opponent):
		if 	opponent.waza.waza_type == "水":	# 草タイプポケモンの強みは水タイプのわざ
			damage = int(opponent.waza.power * 0.5)
		elif opponent.waza.waza_type == "炎":	# 草タイプポケモンの弱点は炎タイプのわざ
			damage = int(opponent.waza.power * 1.5)
		else:
			damage = opponent.waza.power
		return damage

ポケモンを作成する時、ポケモンのタイプに合わせてそれぞれのポケモンタイプクラスから作成するように変更します

例：フシギダネポケモンの作成
```
bulbasaur = Grass_Pokemon("フシギダネ", 100, grass_waza)    # フシギダネポケモンを作成
```

Pokemon.pyを修正して、実行してみましょう。出力結果は例題３と同じです。

回答例

from abc import ABC, abstractmethod

class Waza:
    def __init__(self, name, power, waza_type):
        self.name = name
        self.power = power
        self.waza_type = waza_type
        
    def __str__(self):
        return f"{self.name} {self.power}"
        
class Pokemon(ABC):
    def __init__(self, name, hp, waza):
        self.name = name
        self.hp = hp
        self.waza = waza
        
    @abstractmethod
    def show_type_advantage(self):
        pass

    @abstractmethod    
    def get_damage(self, opponent):
        pass
    
    def take_damage(self, opponent):
        damage = self.get_damage(opponent)
        self.hp -= damage
        if self.hp < 0:
            self.hp = 0
        print(f"\n{self.name} は {damage} ダメージを受けた！（残りHP: {self.hp}）")
        
    def is_fainted(self):
        return self.hp == 0
    
class Fire_Pokemon(Pokemon):   
    def show_type_advantage(self):
        print(f"{self.name} のタイプ： 炎")
        print(" - 強み： 草")
        print(" - 弱点： 水")
        print(f" - わざ： {self.waza}")
        
    def get_damage(self, opponent):
        if opponent.waza.waza_type == "草":
            damage = int(opponent.waza.power * 0.5)
        elif opponent.waza.waza_type == "水":
            damage = int(opponent.waza.power * 1.5)
        else:
            damage = opponent.waza.power
        return damage
    
class Water_Pokemon(Pokemon):   
    def show_type_advantage(self):
        print(f"{self.name} のタイプ： 水")
        print(" - 強み： 炎")
        print(" - 弱点： 草")
        print(f" - わざ： {self.waza}")
        
    def get_damage(self, opponent):
        if opponent.waza.waza_type == "炎":
            damage = int(opponent.waza.power * 0.5)
        elif opponent.waza.waza_type == "草":
            damage = int(opponent.waza.power * 1.5)
        else:
            damage = opponent.waza.power
        return damage
    
class Grass_Pokemon(Pokemon):
    def show_type_advantage(self):
        print(f"{self.name} のタイプ： 草")
        print(" - 強み： 水")
        print(" - 弱点： 炎")
        print(f" - わざ： {self.waza}")
        
    def get_damage(self, opponent):
        if opponent.waza.waza_type == "水":
            damage = int(opponent.waza.power * 0.5)
        elif opponent.waza.waza_type == "炎":
            damage = int(opponent.waza.power * 1.5)
        else:
            damage = opponent.waza.power
        return damage
        
class Battle:    #ポケモン同士が戦闘するクラス
    def __init__(self, pokemon1, pokemon2):    # 戦闘する２匹のポケモンを指定する
        self.pokemon1 = pokemon1
        self.pokemon2 = pokemon2
        
    def fight(self):    # ポケモン同士が戦闘する
        print(f"\n{self.pokemon1.name} vs {self.pokemon2.name} の戦闘開始！")
        turn = 0    # 交互に攻撃するためのターンの回数
        while True:    # 戦闘ループ
            if turn % 2 == 0:    # 偶数のターン回数だったら
                attacker = self.pokemon1        # 攻撃するのはポケモン１
                defender = self.pokemon2     # 攻撃されるのはポケモン２
            else:    # 奇数のターン回数だったら
                attacker = self.pokemon2        # 攻撃するのはポケモン２
                defender = self.pokemon1     # 攻撃されるのはポケモン１
            print(f"\n{attacker.name} の攻撃！ {attacker.waza}!!")
            defender.take_damage(attacker)    # 攻撃するポケモンの攻撃力で攻撃されるポケモンはダメージを受ける
            
            if defender.is_fainted():    # 攻撃されたポケモンが戦闘不能になったら
                print(f"\n{defender.name} は倒れた！ {attacker.name} の勝ち！")
                break    # 戦闘ループから抜ける
            
            turn += 1        # ターン回数を更新する
            
if __name__ == '__main__':    # メインプログラム
    
    fire_waza = Waza("ひのこ", 40, "炎")                # 炎わざ「ひのこ」威力40
    water_waza = Waza("みずでっぽう", 40, "水")        # 水わざ「みずでっぽう」威力40
    grass_waza = Waza("はっぱカッター", 40, "草")        # 草わざ「はっぱカッター」威力40
    
    charmander = Fire_Pokemon("ヒトカゲ", 100, fire_waza)    # ヒトカゲポケモンを作成
    charmander.show_type_advantage()
    squirtle = Water_Pokemon("ゼニガメ", 100, water_waza)    # ゼニガメポケモンを作成
    squirtle.show_type_advantage()
    bulbasaur = Grass_Pokemon("フシギダネ", 100, grass_waza)    # フシギダネポケモンを作成
    bulbasaur.show_type_advantage()
    
    battle = Battle(charmander, squirtle)        # ヒトカゲとゼニガメがバトルフィールドへ
    battle.fight()    # 戦闘開始

まとめ

レッスン118で学んだ「クラス」を使って、簡単なポケモンバトルゲームを作ることができました。このように、クラスを使うと簡単に「わざ」を増やしたり、いろいろなタイプのポケモンたちを増やしたりすることができるようになります。プログラムを改造し、好きなポケモンを増やして、バトルさせてみましょう。

もちろん、実際のポケモンバトルゲームはもっともっと複雑ですが、「クラス」を使って共通化するという基本的な考え方は同じです。

レッスン118

Sun, 09 Aug 2026 08:00:00 +0900

クラス入門

Pythonには「クラス(class)」と呼ばれる仕組みがあります。この「クラス」は、どのような仕組みで、どのように使用するのか簡単に説明します。

オブジェクト指向プログラミング

「クラス」は「オブジェクト指向プログラミング(Object Oriented Programming, OOP)」といわれるプログラミング手法で使用される仕組みです。では、この「オブジェクト指向プログラミング」とはどんな手法でしょう。

「オブジェクト指向プログラミング」とは「モノ（オブジェクト）」とその「モノ」が「どんなもので、どう動くか」に注目する考え方です。

例えば、あなたがシューティングゲーム（射撃ゲーム）を作ろうとしているとしましょう。

このシューティングゲームは以下のようなシナリオだとします。

あなたは、HPが3で3回相手の弾に当たると死んでゲームが終了し、あなたの負けになる
あなたは、上下に移動することができる
あなたは、好きなタイミングで弾を撃つことができる
敵のモンスターは、最初はHPが1であなたの弾に1回あたると死んでしまう
敵のモンスターが死ぬと、HPが1つ多い新たなモンスターが現れる
最後にHPが5のラスボスモンスターが現れ、このモンスターを倒すとゲームが終了し、あなたの勝ちになる
敵のモンスターは上下にランダムに移動する
敵のモンスターはランダムに弾を打ってくる

このゲームの基本的な登場人物は以下の通りです。

自分（あなた）
敵（モンスター）
弾（あなたと敵の弾）

「オブジェクト指向プログラミング」ではこの登場人物（モノ、オブジェクト）に注目し、「どんなモノ（属性）」で「どう動くか（メソッド）」を考えます。

まず、自分に注目してみます。

自分はHPが3（どんなモノ）
自分は上下に動ける（どう動くか）
自分は弾を撃てる（どう動くか）

次に、敵のモンスターに注目します。

敵のHPは1〜5（どんなモノ）
敵は上下にランダムに動く（どう動くか）
敵はランダムに弾を撃つ（どう動くか）

最後に弾に注目します

弾はあなたの弾と敵の弾がある（どんなモノ）
一定の速度で移動する（どう動くか）

これらを登場人物ごとに整理してみましょう

番号	1	2	3
登場人物	自分	敵	弾
どんなモノ（属性）	HPが3	HPが1〜5	自分の弾か敵の弾
どう動く（メソッド）	上下に動く	上下にランダムに動く	一定の速度で移動する
どう動く（メソッド）	弾を撃つ	弾をランダムに撃つ

ゲームは、この登場人物を組み合わせてプログラムを作っていけば出来上がります。

例えば

「1 自分」の「3 弾」が「2 敵」に当たったら「2 敵」のHPが1つ減る

のようなプログラムを先ほどのシナリオに合わせて作っていけば良いことになります。

このように「自分」「敵」「弾」といった「モノ（オブジェクト）」に注目して、プログラムを作っていくことを「オブジェクト指向プログラミング」と言います。

クラスとインスタンス

クラスとは、先ほど整理した「モノ」ごとに「どんなモノ（属性）」「どう動く（メソッド）」を定義した設計図のことです。

「どんなモノ」のことを「クラスの属性」、「どう動く」のことを「クラスのメソッド」と呼びます。

そして、設計図に基づいて作られた「自分」「敵」「弾」などの実際のモノを「インスタンス」と呼びます。

と言われても、さっぱりわかりませんよね。

例えば、敵が死ぬと新たな敵が現れます。このとき新たに現れる敵はあらかじめ作られた設計図（クラス）から召喚（作成）されて、インスタンス（敵のモンスターの実体）になります。弾は、自分や敵から撃たれると、召喚（作成）されてインスタンス（弾の実体）になります。なお、自分や最初の敵は、プログラムの開始時に1回だけ召喚（作成）されインスタンス（実体）になっています。

実際のpythonのプログラムで見てみましょう。


class Player:	# 自分です
	def __init__(self):	# 自分が召喚（作成）されたときに呼ばれます。
		self.hp = 3 			# HPは3です。	
		self.y = 0			# 最初は上下の中央にいます
		self.x = -100		# 自分は左端にいます
	# self.hp, self.y, self.x がクラスPlayerの属性です。
		
	def move(self, dy):	# 上下(+は上、-は下）に動きます（クラスのメソッド）
		self.y += dy
		
	def shot(self):			# 弾を打ちます（クラスのメソッド）
		return Shot(True, self.x, self.y)	# 自分の弾を自分の位置で召喚（作成）して返します。
		
class Monster:	# 敵のモンスターです。
	def __init__(self, hp):	# 召喚（作成）されたときに、HPを指定して呼ばれます。
		self.hp = hp				# 召喚（作成）時に指定したHPを設定します
		self.y = 0				# 最初は上下の中央にいます
		self.x = 100				# 自分は右端にいます
	# self.hp, self.y, self.x がクラスMonsterの属性です。
	
	def move(self):			# ランダムに上下します。（クラスのメソッド）
		self.y += random.randint(-50, 50) # ±50でランダムに移動します
		
	def shot(self):			# ランダムに弾を打ちます。（クラスのメソッド）
		if random.randint(0, 9) == 0:		# ランダムに10回に1回
			return Shot(False, self.x, self.y)		# 敵の弾を敵の位置で召喚（作成）して返します。
		return None		# 撃たないときは空(None)を返します
		
class Shot:	# 弾です。
	def __init__(self, isPlayer, x, y):	# 召喚（作成）されたとき、自分か敵かと位置を指定して呼ばれます。
		self.isPlayer = isPlayrt		# 自分か敵かを設定します
		self.x = x		# 位置を設定します
		self.y = y
		
# ここまではクラス定義（設計図）ですぐには実行されません。
		
player = Player()		# ゲーム開始時に上記で定義された自分の設計図（クラス）に基づいて自分を召喚（作成）します。
monster = Monster(1)	# ゲーム開始時に上記で定義された最初の敵の設計図（クラス）に基づいて、HP1のモンスターを召喚（作成）します。

class Player以下が設計図になり、player = Player()で設計図（クラス）からインスタンス（プレイヤーの実体）が作成され、player変数に設定されます。

同様に、class Monster以下が設計図になり、monster = Monster(1)で設計図（クラス）からインスタンス（モンスターの実体）が作成され、monster変数に設定されます。

クラスの利点

クラスを使うとどんないいことがあるでしょう。代表的なものは以下の４つです。

コピペしなくても同じ実体（インスタンス）をいっぱい作れる
モノ（オブジェクト）ごとに整理されていて、修正したり、追加したりしやすい
元のクラスを変更せずに、属性やメソッドを追加した新たなクラスを作ることができる
モノ（オブジェクト）が違っていても、同じプログラムを使える仕組み（ポリモーフィズム）がある

これらを１つずつ説明します。

コピペしなくても同じ実体（インスタンス）をいっぱい作れる

クラスを使うことで、同じ設計図でたくさんの実体を作ることができます。

例えば、さきほどのシューティングゲームの例では、必要な時に敵を召喚(Monster()を呼ぶ）ことで、いくらでも敵の数を増やせます。クラスを使えば

monster1 = Monster(1)
monster2 = Monster(2)
monster3 = Monster(3)

のように簡単に3種類のモンスターが作れます。もしクラスを使わなければ、

monster_1_hp = 1
monster_1_y = 0
monster_1_x = 100
monster_2_hp = 2
monster_2_y = 0
monster_2_x = 100
monster_3_hp = 2
monster_3_y = 0
monster_3_x = 100

のようにモンスターごとに同じような属性や関数を用意しなければいけなくなり、コピペのかたまりになってしまいます。

モノ（オブジェクト）ごとに整理されていて、修正したり、追加したりしやすい

モノ（オブジェクト）に関係するもの（属性やメソッド）がクラスとしてまとまっているので、モノ（オブジェクト）に関係するものを修正したり、追加する時、あちこちのプログラムを修正することなく、モノのクラスだけ修正すれば済むようになります。

また、カプセル化といって、そのクラス以外のプログラムから変更させたくない属性や、実行させたくないメソッドをそのクラスの中だけでしか利用できないようにすることができる仕組みがあります。例えばpythonでは、属性やメソッドの名前の頭に「_」を付けることで実現することができます。

class Student:	# 生徒のクラス
	def __init__(self, name, age):	# 名前と年齢を指定してインスタンスを作成する	
		self._name = name	# 名前の属性_nameは直接クラスの外からアクセスできない
		self._age = age		# 年齢の属性_ageは直接クラスの外からアクセスできない
	def getName(self):		# 名前を返すメソッド（クラスの外からアクセスできる）、クラスの名前を外から変更するメソッドはない
		return self._name
	def addAge(self):		# 年齢を１つ加算するメソッド（クラスの外からアクセスできる）、ただしクラスの外から任意に変更するメソッドはない
		self._age += 1
	def getAge(self):		# 年齢を返すメソッド（クラスの外からアクセスできる）
		return self._age

例えば、このような生徒クラスを作ることで、生徒クラスの外からは名前と年齢を参照できるが、最初に設定した名前は後から変更できず、年齢の加算だけできるというように、生徒の情報を管理するができるようになります。

また、生徒に関する属性やメソッドは、このクラス内で完結しているので、修正・追加もこのクラスだけで行えます。

元のクラスを変更せずに、属性やメソッドを追加した新たなクラスを作ることができる

例えば、先ほどのシューティングゲームで敵のモンスターのラスボスだけは、「魔法を使う（相手を一定時間動けなくする）」ことができることにします。ただし、それ以外の能力は通常のモンスターと一緒です。

こういう場合、モンスタークラスに「魔法を使う」というメソッドを追加してしまうと、ラスボス以外のモンスターも魔法を使えるようになってしまいます。だからといって、モンスタークラスをコピペしてラストモンスタークラスを作ると、同じようなプログラムが増えていきます。さらに、後からモンスタークラスを修正した場合、ラストモンスタークラスにも同じ修正をしなくてはならなくなり、面倒で修正ミスなどトラブルの元になります。

クラスでは「継承」という仕組みを使って元のクラスを修正せずに、属性やメソッドを追加した新たなクラスを作る仕組みがあります。


class Monster:
	....
	
class LastMonster(Monster):
	def magic(self):
		.....

Pythonではこのように書くと、LastMonsterはMonsterクラスの属性やメソッドをそのまま引き継ぎ（継承し）、拡張したい部分（mogicメソッド）だけ、追加することが可能になります。 Monsterクラスは全く変更がありませんし、Monsterクラスの変更は、全て自動的にLastMonsterクラスにも反映されることになります。

また、この仕組みを積極的に使って、複数のクラスの共通部分をまとめたクラス（スーパークラス）を作り、そのクラスを継承させることで、プログラムをまとめることができます。例えば、先ほどのシューティングゲームでは、自分もモンスターもHPと位置(x, y)を持っている部分は共通なので、例えばCharacterというスーパークラスを作り以下のようにまとめることができます。


class Character:
	def __init__(self, hp, x, y):
		self.hp = hp
		self.x = x
		self.y = y
		
class Player(Character):
	def __init__(self):
		super().__init__(3, 100, 0)
	...
	
class Monster(Character):
	def __init__(self, hp):
		super().__init__(hp, -100, 0)
	...

このようにすると、プレイヤーとモンスターで共通のメソッドを追加したい場合、Characterクラスにそのメソッドを作成すれば、わざわざ同じメソッドをプレイヤーとモンスターの各クラスにコピペして作りこむ必要はなくなり、修正する際も１つのメソッドの修正ですみます。

一方、プレイヤーとモンスターでどちらか単独に属性やメソッドを追加したい場合は、該当するクラスにだけ追加すればよいことになります。さらに、メソッドが共通でも行う内容が異なる場合なども後述する「ポリフォリズム」の仕組みを使えば実現できます。

なお、このような共通クラスは通常、共通クラスだけのインスタンスを作ることはないので「抽象クラス」と呼ばれます。 PythonにはABCというライブラリを使って、「抽象クラス」を定義し、「抽象クラス」からインスタンスを作るとエラーになるという仕組みがあるので、これを使うことも可能です。

モノ（オブジェクト）が違っていても、同じプログラムを使える仕組み（ポリモーフィズム）がある

クラスには「ポリモーフィズム」と呼ばれる「モノ（オブジェクト）が違っていても、同じプログラムを使える仕組み」があります。

例えば、先ほどのシューティングゲームで、ゲームのシステムは一定周期（例えば1秒に1回とか）で各登場人物を表示し直す仕組みになっているとします。この場合、いろいろな登場人物に対して、この人物はこう描画するというようにプログラミングしていたら、登場人物が増えるたびにプログラムを書き換えなければならなくなってしまいます。

そこでItemという登場人物を共通化した抽象クラス（スーパークラス）を作成し、このクラスにdrawという描画を行うメソッドを定義して、描画したい場合、システムはどの登場人物に対しても、drawというメソッドを呼べばよいようにします。

from abc import ABC, abstractmethod

class Item(ABC):	# インスタンスを作らない抽象クラス
	@abstractmethod
	def draw(self):
		pass		# 実際に呼ばれない仮想メソッド
		
class Character(Item, ABC):	# このクラスもインスタンスを作らない抽象クラス
	...
	
Class Player(Character):	# 実際にプレイヤーのインスタンスを作るクラス
	...
	def draw(self):
		# ここに自分を描画するプログラムを書く
		print("draw player")
		
Class Monster(Character):	# 実際にモンスターのインスタンスを作るクラス
	...
	def draw(self):
		# ここにモンスターを描画するプログラムを書く
		print("draw monster")
		
Class Shot(Item):
	...
	def draw(self):
		# ここに弾を描画するプログラムを書く
		print("draw shot")
		
items = []	# 描画する登場人物のリスト

player = Player()
items.append(player)	# 登場人物を召喚したら登場人物リストに追加する
monster = Monster(1)
items.append(monster)	# 登場人物を召喚したら登場人物リストに追加する
...

def draw():	# システムが一定周期で描画する際に呼ばれる関数
	for item in items:		# 登場人物を1人ずつリストから取り出し
		item.draw()		# 登場人物を意識せずに描画する（各登場人物に対応したクラスのdrawメソッドが呼ばれる）

システムは単純に各登場人物のdrawメソッドを呼びます。すると登場人物に対応したクラスに実装されたdrawメソッドが呼ばれ、登場人物ごとに必要な描画の処理が行われます。

このように、描画の違いは各クラスごとのメソッドが対応してくれるので、呼ぶ方のシステムは同じやり方で呼ぶことができます。

今回は１つのメソッドなので単純ですが、Aというメソッドを呼び、Bというメソッドを繰り返し呼び、最後にCというメソッドを呼ぶというような複雑なプログラムでも、クラスごとにA,B,Cそれぞれのメソッドを用意することで、各クラスに対して同じプログラムで呼ぶことができるようになります。

なお、抽象クラスに実装されたdrawメソッドは、実際には各クラスに実装されたdrawメソッドの方が呼ばれるので、「抽象メソッド」と呼ばれ通常は実行されません。ただし、pythonでは、各クラスにdrawメソッドが実装されていなければ、エラーにはならず、抽象メソッドの方が実行されてしまいます。（抽象メソッドの中身はpassなので実際は何も行われなくなってしまう）このようなことを防ぐため、ABCというライブラリを使用し@abstractmethodという印を「抽象メソッド」の前に付けることで、「抽象メソッド」に対応するメソッドが各クラスで実装されていないとエラーとする仕組みがあります。

まとめ

「クラス」とか「オブジェクト指向」というと非常に難しく聞こえますが、実際はプログラムを作る時、共通化できるものはできるだけ共通化して、できるだけ簡単に、バグがなく、メンテナンスのしやすいプログラムを作成するための方法です。

「クラス」を活用し、きれいで、効率的で、わかりやすいプログラムが書けるようになりましょう。