Pythonで〇×ゲームのAIを一から作成する　その54　namedtuple を使った dict の変換

Last updated at 2024-02-18Posted at 2024-02-15

目次と前回の記事

これまでに作成したモジュール

以下のリンクから、これまでに作成したモジュールを見ることができます。

これまでに作成した AI

これまでに作成した AI のアルゴリズムは以下の通りです。

ルール	アルゴリズム
ルール1	左上から順に空いているマスを探し、最初に見つかったマスに着手する
ルール2	ランダムなマスに着手する
ルール3	真ん中のマスに優先的に着手する既に埋まっていた場合はランダムなマスに着手する
ルール4	真ん中、隅のマスの順で優先的に着手する既に埋まっていた場合はランダムなマスに着手する
ルール5	勝てる場合に勝つそうでない場合はランダムなマスに着手する
ルール6	勝てる場合に勝つそうでない場合は相手の勝利を阻止するそうでない場合はランダムなマスに着手する
ルール6改	勝てる場合に勝つそうでない場合は相手が勝利できる着手を行わないそうでない場合はランダムなマスに着手する
ルール7	真ん中のマスに優先的に着手するそうでない場合は勝てる場合に勝つそうでない場合は相手の勝利を阻止するそうでない場合はランダムなマスに着手する
ルール7改	真ん中のマスに優先的に着手するそうでない場合は勝てる場合に勝つそうでない場合は相手が勝利できる着手を行わないそうでない場合はランダムなマスに着手する
ルール8	真ん中のマスに優先的に着手するそうでない場合は勝てる場合に勝つそうでない場合は相手が勝利できる着手を行わないそうでない場合は、次の自分の手番で勝利できるように、「自 2 敵 0 空 1」が 1 つ以上存在する局面になる着手を行うそうでない場合はランダムなマスに着手する

基準となる ai2 との 対戦結果（単位は %）は以下の通りです。太字は ai2 VS ai2 よりも 成績が良い 数値を表します。欠陥の列は、アルゴリズム に欠陥があるため、ai2 との 対戦成績 が 良くても強い とは 限らない ことを表します。欠陥の詳細については、関数名のリンク先の説明を見て下さい。

関数名	o 勝	o 負	o 分	x 勝	x 負	x 分	勝	負	分	欠陥
`ai1` `ai1s`	78.1	17.5	4.4	44.7	51.6	3.8	61.4	34.5	4.1	あり
`ai2` `ai2s`	58.7	28.8	12.6	29.1	58.6	12.3	43.9	43.7	12.5
`ai3` `ai3s`	69.3	19.2	11.5	38.9	47.6	13.5	54.1	33.4	12.5
`ai4` `ai4s`	83.0	9.5	7.4	57.2	33.0	9.7	70.1	21.3	8.6	あり
`ai5` `ai5s`	81.2	12.3	6.5	51.8	39.8	8.4	66.5	26.0	7.4
`ai6`	88.9	2.2	8.9	70.3	6.2	23.5	79.6	4.2	16.2
`ai6s`	88.6	1.9	9.5	69.4	9.1	21.5	79.0	5.5	15.5
`ai7` `ai7s`	95.8	0.2	4.0	82.3	2.4	15.3	89.0	1.3	9.7
`ai8s`	98.2	0.1	1.6	89.4	2.5	8.1	93.8	1.3	4.9

修正した `count_marks` の問題点

前回の記事で修正した、count_marks が 返り値 として返す tuple の要素の意味は、順番に「直前の手番 のマーク、現在の手番 のマーク、空のマス」の数のように決めましたが、tuple は dict のよう に、それぞれの 要素の意味 を表現できるキーを 持たない ので、例えば (2, 0, 1) という tuple を 見ただけ では、それぞれの要素が 何を意味する のかが わからない という欠点があります。

一方、dict は { "o": 2, "x": 0, ".": 1 } のように、キーを見ることで、キーの値 が 何を表しているか を知ることが できます が、dict は ハッシュ可能なオブジェクトではない ため、set の 要素に代入 することは できません。

namedtuple の性質と使い方

この問題を解決する方法の一つに、tuple の それぞれの要素 に 名前がつけられた（named）、namedtuple という ハッシュ可能 な データ型 を利用するという方法があります。namedtuple は 頻繁に利用される データ型では ありません が、今回のように、知っておくと便利 な 場合がある ので、その使い方について説明します。

namedtuple では、要素につけられた名前のことを フィールド名 と呼びます。

ただし、namedtuple には、以下のような欠点もあります。そのため、tuple の 要素の数が少ない 場合などで、tuple の それぞれの要素 が 何を表すか を 容易に覚えることができる ような場合は、無理に namedtuple を利用する必要は ありません。

tuple と 異なり、利用の際 に 前準備が必要 になる
tuple より も、データの記述 が 多くなる

namedtuple の詳細については、下記のリンク先を参照して下さい

namedtuple の性質

namedtuple は、以下のような、tuple と dict の性質を 併せ持つ データ型です。

tuple の性質 を すべて持つ
tuple の性質 に 加えて、それぞれの要素 を dict のように 名前で参照 できる

ただし、namedtuple は 以下の表の点 で dict と 性質が異なり ます。なお、表の　namedtuple に関する内容の詳細については、この後で詳しく説明します。

	dict	namedtuple
ミュータブルであるか	ミュータブル	イミュータブル
ハッシュ可能であるか	ハッシュ可能でない	ハッシュ可能である
名前に利用できるデータ	ハッシュ可能なオブジェクト	文字列のみ
名前による要素の参照方法	`[キーの名前]`	`.フィールド名` （属性の参照と同じ）
`[]` によって参照される値	キーの値	インデックスの要素（tuple と同じ）
データの作成	リテラルで直接行える	サブクラスを定義し、インスタンスを作成する

このように、namedtuple は、文字列 による名前を使って要素を 参照できる という点は dict に似ています が、それ以外 の性質は dict とは 大きく異なり ます。

namedtuple はその名前の通り、要素に 名前を付けられる tuple であり、性質は tuple に準じます。dict とは 大きく異なる データ型である点に注意して下さい。

namedtuple のインポート

namedtuple は、collections モジュール内で、クラス として定義されているので、利用する際 には、defaultdict と 同様の方法 で、下記のプログラムのように、collections モジュールから インポート する必要があります。

from collections import namedtuple

namedtuple のデータの作成手順

tuple は、例えば (1, 2, 3) のように tuple の リテラルを記述 することで、任意の数 の要素を持つ tuple の データ を 直接作成 することが できます が、namedtuple の場合は 下記の手順 のように、データを作成 する前に、それぞれの要素 に対応する フィールド名 を設定した、tuple の サブクラスを定義 する必要があります。

namedtuple の フィールド名 を設定した、tuple の サブクラス を定義する
サブクラス から、設定した フィールド名 を持つ namedtuple の データ を作成する

サブクラスとは何か

サブクラス とは、特定のクラス を元に新しく 定義されたクラス の事で、元となった クラスの性質 を すべて受け継いだ¹上で、さらなる 機能を付け加えたクラス の事を表します。先ほど説明したように、namedtuple が、tuple の性質 を すべて持ち、その上 でそれぞれの 要素に名前を付ける ことができる 機能を持つ のは、namedtuple が tuple のサブクラス だからです。サブクラスの詳細については、今後の記事で紹介します。

サブクラスを定義する理由

namedtuple を利用する際には、多くの場合 で 同じ意味 を持つ namedtuple の データ を 複数作成 します。例えば、count_marks を namedtuple を返すように修正した場合、「直線の手番 のマーク、現在の手番 のマーク、空のマス」の数を要素として持つ namedtuple が count_marks が 呼び出されるたび に作成されます。

このような場合は、一般的 に、共通の フィールド名 を持つ namedtuple の データ を作成する必要があります。その理由は、同じ意味 を持つ namedtuple の データ に 異なるフィールド名 が設定されていた場合は、フィールド名 を使って 特定の要素 を参照するプログラムを記述することが できない（できても非常に 困難になる）からです。

分かりづらいと思った方は、同じもの に、異なる名前 が ついている 場合のことを 思い浮かべて みて下さい。例えば、1 という数字は、日本語 ではいち、英語では one、ドイツ語 では eins と表記します。同じ文章 の中で、1 を さまざまな言語 で表記すると わかりづらくなる ので、特に理由がない限り、ものの名前 を 統一する のが 一般的 です。これは プログラム の場合でも同様で、一般的に 同じ意味 を持つ namedtuple の フィールド名 は、同じプログラムの中 では統一します。

以前の記事で説明したように、クラス を 自分で定義 する事で、任意のデータ構造 を管理し、そのデータを処理する メソッド を持つ カスタムデータ型 を定義することができます。また、定義した クラス から インスタンスを作成 することで、同じデータ構造 と機能をもつ データ を いくらでも作る ことが できるようになります。実際に Marubatsu クラスを定義する事で、〇×ゲーム の機能を持つ データ を いくつも作成 してきました。

フィールド名 を設定した tuple の サブクラスを定義 する事で、設定した フィールド名 を持つ namedtuple の ひな形 となる カスタムデータ型 を定義することができます。また、その カスタムデータ型 から インスタンス を作成することで、同じフィールド名 を持つ namedtuple の データ をいくつでも、必要なだけ作成 することが できるようになります。

これが、namedtuple の データ を作成する際に、サブクラス を定義する理由です。

他の利点として、サブクラスを定義 する際に、サブクラスに 名前を付ける ことができるというものがあります。異なる意味 を持つ namedtuple の ひな形 となる サブクラス に、適切な名前 を付けることで、それらを区別して 管理しやすくなる という利点が生じます。

以後は、わかりやすさ を重視して、「tuple の サブクラスの定義」を、「namedtuple の カスタムデータ型の定義」と表記することにします。

namedtuple のカスタムデータ型の定義

namedtuple の カスタムデータ型の定義 は、下記のように記述します。

変数名 = namedtuple(typename, field_names)

typename には、定義する namedtuple の カスタムデータ型（typename）の名前を 文字列 で記述します。この名前には、カスタムデータ型 が扱う データを表す名前 を付けるのが 一般的 です。なお、アラビア数字で始まる 名前や、_ 以外の記号 が入った名前など、Python の 変数名 や 関数名 として 利用できない名前 を 付ける ことは できません。

field_names には、namedtuple の カスタムデータ型 の フィールド名（field names）を表す 文字列 を 先頭の要素 から順番に持つ、list や tuple などの シーケンス型 で記述します。namedtuple では、すべての要素 に 名前を付ける必要 があるので、filed_names の 要素の数 が、カスタムデータ型 の 要素の数 に一致します。なお、フィールド名 として、それぞれの 要素の名前 に 利用できるデータ には、以下のような制限があります。

typename の場合と同様に、変数名 として 利用できない名前 をつけることは できない
_（半角のアンダースコア）で 始まる名前 は 利用できない
異なる要素 に 同じ名前 を 付ける ことは できない

namedtuple の 返り値 は、作成した カスタムデータ型 を表す tuple の サブクラス で、変数に代入 して利用します。サブクラス を代入する 変数の名前 は、一般的 に typename で設定した名前と 同じ名前 にします。

初心者が 勘違いしやすい 点ですが、namedtuple(typename, field_names) によって作成されるのは、namedtuple の カスタムデータ型 であり、それ自体が namedtuple の性質を持つデータ ではない 点に注意して下さい。

マークのパターンを表す namedtuple のカスタムデータ型の定義

上記の説明では意味が わかりづらい と思いますので、具体例 を示します。下記の具体例を見て、概要を理解 してから、もう一度 上記の 説明を読み直す ことを お勧めします。

マークのパターン を表す namedtuple の カスタムデータ型 は、下記の手順 で定義します。

typename を 決める。マークのパターン を表すので、Markpat という 名前にした。なお、クラスの名前 は 頭文字 を 大文字 にする慣習があるので、頭文字 を 大文字 にした
直前の手番 のマーク、現在の手番 のマーク、空のマス を表す 3 つの要素 の 名前を決める 必要がある。それぞれを "last_turn"、"turn"、"empty" と 名付ける ことした
上記を元に、下記のプログラムを記述する

Markpat = namedtuple("Markpat", [ "last_turn", "turn", "empty" ])

typename や、それぞれの 要素の名前 は、文字列 で指定する必要がある点に注意して下さい。また、返り値 を代入する 変数名 は、一般的 に typename と 同じ名前 にしますが、そちらは 変数名 なので、"" で 囲ってはいけない 点に注意して下さい。

field_names を一つの 文字列 で指定することもできます。その場合は、名前と名前の間を 半角の空白 か、半角の , で 区切ります。下記のプログラムは、いずれも上記のプログラムと 同じ処理 を行います。

Markpat = namedtuple("Markpat", "last_turn turn empty")
Markpat = namedtuple("Markpat", "last_turn, turn, empty")

下記のプログラムのように、typename や field_names に、名前に 利用できない文字列 を指定すると エラーが発生 します。

# typename の名前がアラビア数字で始まっている
namedtuple("0Markpat", ["last_turn", "turn", "empty"])

実行結果

略
    396     raise ValueError('Type names and field names cannot be a '
    397                      f'keyword: {name!r}')

ValueError: Type names and field names must be valid identifiers: '0Markpat'

上記のエラーメッセージは、以下のような意味を持ちます。

ValueError
値（Value）に関するエラー
Type names and field names must be valid identifiers: '0Markpat'
'0Markpat' という、データ型（type）や（and）フィールド（field）の名前（names）は、有効（valid）な識別子（identifiers）でなければならない

# フィールド名が _ で始まっている
namedtuple("Markpat", ["_last_turn", "turn", "empty"])

実行結果

略
    404     if name in seen:
    405         raise ValueError(f'Encountered duplicate field name: {name!r}')

ValueError: Field names cannot start with an underscore: '_last_turn'

上記のエラーメッセージは、以下のような意味を持ちます。

ValueError
値（Value）に関するエラー
ValueError: Field names cannot start with an underscore: '_last_turn'
'_last_turn' というフィールド名（field names）は _（underscore）で始める（start with）ことはできない（can not）

namedtuple のインスタンスの作成

定義した namedtuple の カスタムデータ型 から、下記の方法で インスタンスを作成 することで、同じフィールド名 を持つ namedtuple の データ を いくつでも作成できます。

実引数 に、field_names で 設定した順番 で要素を記述する。その際に、field_names で設定した名前を使って、キーワード引数 で記述することも できる
実引数の数 は、field_names の 要素の数 に一致する必要がある²

下記は、いずれも Markpat から「直前の手番、現在の手番、空のマス」に 対応する要素 に「2、0、1」を代入した データ（インスタンス）を作成するプログラムです。キーワード引数 で記述した場合は、5 行目のように、記述の順番 を 変える ことが できます。

作成された データ を print で表示すると、実行結果 のような表示が行われます。

print(Markpat(2, 0, 1))
print(Markpat(2, 0, empty=1))
print(Markpat(2, turn=0, empty=1))
print(Markpat(last_turn=2, turn=0, empty=1))
print(Markpat(empty=1, last_turn=2, turn=0))

実行結果

Markpat(last_turn=2, turn=0, empty=1)
Markpat(last_turn=2, turn=0, empty=1)
Markpat(last_turn=2, turn=0, empty=1)
Markpat(last_turn=2, turn=0, empty=1)
Markpat(last_turn=2, turn=0, empty=1)

細かい話になりますが、namedtuple の カスタムデータ型 の データ を print で表示した際に、最初に表示 される名前は、typename で指定した名前です。カスタムデータ型 を代入した 変数名ではない 点に注意して下さい。

下記は、typename に "Markpat2" を指定し、typename とは 異なる Markpat3 という変数に カスタムデータ型 を代入したプログラムですが、実行結果 からわかるように、最初に表示 される名前は、typename に代入した Markpat2 です。

Markpat3 = namedtuple("Markpat2", [ "last_turn", "turn", "empty" ])
print(Markpat3(0, 1, 2))

実行結果

Markpat2(last_turn=0, turn=1, empty=2)

namedtuple の カスタムデータ型 から データを作成 する際に、field_names の 要素数 と 異なる数 の 実引数 を記述した場合は、下記のプログラムのように エラーが発生 します。下記は 実引数の数 が 少ない 場合です。

print(Markpat(0, 1))

実行結果

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[8], line 1
----> 1 print(Markpat(0, 1))

TypeError: Markpat.__new__() missing 1 required positional argument: 'empty'

上記のエラーメッセージは、以下のような意味を持ちます。

TypeError
データ型（type）に関するエラー
Markpat.new() missing 1 required positional argument: 'empty'
Markpat からインスタンスを作成する際に呼び出される __new__³ メソッドで必要とされる（required) 仮引数 empty に対応する位置引数（positional argument）が存在しない（missing）

下記は 実引数の数 が多い場合です。

print(Markpat(0, 1, 2, 3))

実行結果

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[9], line 1
----> 1 print(Markpat(0, 1, 2, 3))

TypeError: Markpat.__new__() takes 4 positional arguments but 5 were given

上記のエラーメッセージは、以下のような意味を持ちます。

TypeError
データ型（type）に関するエラー
Markpat.new() takes 4 positional arguments but 5 were given
Markpat からインスタンスを作成する際に呼び出される __new__ メソッドは 4 つの位置引数（positional argument）を持つ（takes）が、5 つの位置引数が記述されている（were given）

フィールド名のデフォルト値の設定方法

namedtuple の フィールド名 に デフォルト値 を設定する方法について説明します。本記事 では 利用しない ので、興味がない方は 読み飛ばし ても 構いません。

namedtuple の カスタムデータ型 を定義する際に、 実引数 に defaluts=デフォルト値を表すシーケンス型 という キーワード引数⁴ を記述することで、それぞれ の要素の デフォルト値 を設定することが できます。例えば、下記のプログラムは、x、y という名前が付けられた要素に、それぞれ 1、2 という デフォルト値 が設定された namedtuple の カスタムデータ型 を定義します。なお、この カスタムデータ型 は、2 次元 の 点（point）の座標 のように 扱うことができる ので typename に Point という名前を付けました。

Point = namedtuple("Point", ["x", "y"], defaults=[1, 2])

# 実引数が記述されていないので、両方の要素が、デフォルト値である 1 と 2 に設定される
print(Point())       
# 1 つ目の要素が実引数に記述された 3 に、2 つ目の要素がデフォルト値である 2 に設定される
print(Point(3))      
# 2 つの要素が、実引数に記述された 4 と 5 に設定される
print(Point(4, 5))

実行結果

Point(x=1, y=2)
Point(x=3, y=2)
Point(x=4, y=5)

defaults に記述された 要素の数 が、field_names に記述された 要素の数より も 少ない 場合は、field_names の先頭から 足りない分 の数の要素には デフォルト値 は 設定されません。これは、以前の記事で説明したように、デフォルト引数 は、通常の仮引数より も 後に記述 する必要があるからです。

下記のプログラムは、field_names に "x"、"y"、"z" という 3 つ の 要素の名前 を設定していますが、defaults には 2 つ の デフォルト値 しか設定していません。この場合は、先頭の "x" には デフォルト値 は 設定されず、その後の "y"、"z" にそれぞれ 1、2 という デフォルト値 が設定されます。なお、この カスタムデータ型 は、3 次元（3D）の点の座標のように 扱うことができる ので typename に Point3D という名前を付けました。

Point3D = namedtuple("Point3D", ["x", "y", "z"], defaults=[1, 2])

print(Point3D(3))
print(Point3D(4, 5))
print(Point3D(6, 7, 8))

実行結果

Point3D(x=3, y=1, z=2)
Point3D(x=4, y=5, z=2)
Point3D(x=6, y=7, z=8)

なお、デフォルト値 が 設定されていない 要素に対応する 実引数 は、必ず記述 する必要があるので、下記のプログラムを実行すると エラーが発生 します。

print(Point3D())

実行結果

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[12], line 1
----> 1 print(Point3D())

TypeError: Point3D.__new__() missing 1 required positional argument: 'x'

namedtuple の利用方法

表記が長いので、以後は namedtuple の カスタムデータ型 から作成した データ のことを、list 等と同様に、単に nametuple と表記します。

次に、namedtuple の 利用方法 について説明します。

インデックスによる要素の参照

namedtuple は tuple の 性質を持つ ので、下記のプログラムのように、tuple と同様に インデックス を使って 要素を参照 できます。

mp = Markpat(2, 0, 1)
print(mp[0], mp[1], mp[2])

実行結果

2 0 1

要素の展開

namedtuple は tuple の 性質を持つ ので、下記のプログラムのように、tuple と同様に 要素の展開 を行うことができます。

mp = Markpat(2, 0, 1)
last_turn, turn, empty = mp
print(last_turn, turn, empty)

実行結果

2 0 1

名前による要素の参照

namedtuple の要素を field_names で 設定した名前 を使って参照する場合は、下記のプログラムのように、オブジェクトの属性 と 同様の方法 で、.名前 のように記述します。

mp = Markpat(2, 0, 1)
print(mp.last_turn, mp.turn, mp.empty)

実行結果

2 0 1

なお、最初は 間違いやすい ですが、dict と 異なり、下記のプログラムのように、[] と 要素の名前 を使って要素を参照しようとすると エラーが発生 します。これは、エラーメッセージからわかるように namedtuple は tuple の一種なので、[] によって 指定できる のは インデックス だからです。namedtuple と dict を 混同しない ように注意して下さい。

mp = Markpat(2, 0, 1)
print(mp["last_turn"])

実行結果

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[16], line 2
      1 mp = Markpat(2, 0, 1)
----> 2 print(mp["last_turn"])

TypeError: tuple indices must be integers or slices, not str

上記のエラーメッセージは、以下のような意味を持ちます。

TypeError
データ型（type）に関するエラー
tuple indices must be integers or slices, not str
tuple のインデックス（indices）は、文字列ではなく（not str）、整数（integers）またはスライス（slices）でなければならない

変数の値を利用した要素の参照

dict のように、変数の値 を使って namedtuple の要素を参照したい場合は、getattr という 組み込み関数 を利用する必要があります。getattr は、任意の オブジェクト 対して 利用できる関数 で、1 つ目 の 実引数 に オブジェクト を、2 つ目 の 実引数 に 属性の名前 を記述することで、指定した属性 の値を 返り値 として返す処理を行います。

下記は、Markpat から 作られた namedtuple の中から、name に代入された "last_turn" という名前が付けられた 要素の値 を 取り出して表示 するプロブラムです。

mp = Markpat(2, 0, 1)
name = "last_turn"
print(getattr(mp, name))

実行結果

getattr の詳細については、下記のリンク先を参照して下さい。

namedtuple を利用した `ai8s` の修正

次は、namedtuple を利用するように ai8s を修正します。

`Markpat` の定義と保存場所

まず、マークのパターン を表す namedtuple の カスタムデータ型 を定義する必要がありますが、その定義は、先程記述した下記のプログラムで行うことができます。

Markpat = namedtuple("Markpat", [ "last_turn", "turn", "empty" ])

Markpat は、count_marks だけでなく、この後で ai8s を 修正する際 に、ai8s の ブロックの中 でも利用します。そのため、Markpat を marubatsu.py の中 で定義する場合は、ai.py などの 他のモジュール から インポートできる ようにする必要があります。そのためには、Markpat を Marubatsu クラスの ブロックの外 に定義する必要があります。

また、Markpat は、Marubatsu クラスの中でも 利用する ので、本記事では marubatsu.py の中 で、Marubatsu クラスを 定義する前 に Markpat の 定義を記述 する事にします。後で、本記事の最後で示す marubatsu_new.py のリンクで確認して下さい。

`count_marks` の修正

次に、下記のように、count_marks が Markpat を利用するように修正します。

15 行目：Markpat の インスタンス を作成して返すように修正する

 1  from marubatsu import Marubatsu
 2  from collections import defaultdict
 3
 4  def count_marks(self, coord, dx, dy, datatype="dict"):     
 5      x, y = coord   
 6      count = defaultdict(int)
 7      for _ in range(self.BOARD_SIZE):
 8          count[self.board[x][y]] += 1
 9          x += dx
10          y += dy
11
12      if datatype == "dict":
13          return count
14      else:
15          return Markpat(count[self.last_turn], count[self.turn], count[Marubatsu.EMPTY])
16
17  Marubatsu.count_marks = count_marks

行番号のないプログラム

from marubatsu import Marubatsu
from collections import defaultdict

def count_marks(self, coord, dx, dy, datatype="dict"):     
    x, y = coord   
    count = defaultdict(int)
    for _ in range(self.BOARD_SIZE):
        count[self.board[x][y]] += 1
        x += dx
        y += dy

    if datatype == "dict":
        return count
    else:
        return Markpat(count[self.last_turn], count[self.turn], count[Marubatsu.EMPTY])

Marubatsu.count_marks = count_marks

修正箇所

from marubatsu import Marubatsu
from collections import defaultdict

def count_marks(self, coord, dx, dy, datatype="dict"):     
    x, y = coord   
    count = defaultdict(int)
    for _ in range(self.BOARD_SIZE):
        count[self.board[x][y]] += 1
        x += dx
        y += dy

    if datatype == "dict":
        return count
    else:
-       return count[self.last_turn], count[self.turn], count[Marubatsu.EMPTY]
+       return Markpat(count[self.last_turn], count[self.turn], count[Marubatsu.EMPTY])

Marubatsu.count_marks = count_marks

15 行目 を、下記のように キーワード引数 で記述しても 構いません が、 count[self.last_turn] の中に キーワード である last_turn が 記述されている ので、この場合はわざわざ キーワード引数 を記述する 必要はない でしょう。

return Markpat(last_turn=count[self.last_turn], turn=count[self.turn], \
               empty=count[Marubatsu.EMPTY])

動作の確認

namedtuple は、tuple の 性質を持つ ので、上記のように count_marks の 返り値 を tuple から namedtuple に 変更しても、count_marks の 返り値 を tuple として処理を行う、ai8s のようなプログラムの処理には影響を 及ぼしません。従って、上記の修正 を 行っても、ai8s を 変更することなく そのまま実行することが できます。

前回の記事と同様に、ai2、ai7s と対戦し、以前の対戦結果と比較することで、ai8s が 正しく動作するか どうかを確認します。まず、ai2 と対戦します。

from ai import ai_match, ai2, ai7s, ai8s

ai_match(ai=[ai8s, ai2])

実行結果（実行結果はランダムなので下記とは異なる場合があります）

ai8s VS ai2
count     win    lose    draw
o        9843      11     146
x        8926     234     840
total   18769     245     986

ratio     win    lose    draw
o       98.4%    0.1%    1.5%
x       89.3%    2.3%    8.4%
total   93.8%    1.2%    4.9%

次に、ai7s と対戦します。

ai_match(ai=[ai8s, ai7s])

実行結果（実行結果はランダムなので下記とは異なる場合があります）

ai8s VS ai7s
count     win    lose    draw
o        3313     393    6294
x         377    2923    6700
total    3690    3316   12994

ratio     win    lose    draw
o       33.1%    3.9%   62.9%
x        3.8%   29.2%   67.0%
total   18.4%   16.6%   65.0%

下記は、以前と今回 の 対戦結果の表 です。いずれも 以前と今回で成績は ほぼ変わらない ので、正しく動作 する 可能性が高い ことが確認できました。

関数名	o 勝	o 負	o 分	x 勝	x 負	x 分	勝	負	分
以前の VS `ai2`	98.2	0.1	1.6	89.4	2.5	8.1	93.8	1.3	4.9
今回の VS `ai2`	98.4	0.1	1.5	89.3	2.3	8.4	93.8	1.2	4.9
以前の VS `ai7s`	33.4	3.9	62.6	3.9	28.8	67.3	18.7	16.4	65.0
今回の VS `ai7s`	33.1	3.9	62.9	3.8	29.2	67.0	18.4	16.6	65.0

`ai8s` の修正

namedtuple を利用することで ai8s を、下記のプログラムのように修正できます。(0, 2, 1) から Markpat(last_turn=0, turn=2, empty=1) のように修正されたため、プログラムの 記述が長く なりますが、プログラムの 意味が明確になる という利点が得られます。

ただし、マークのパターン のように、要素が 3 つ程度 であれば、(0, 2, 1) のほうが 簡潔に記述できる という利点があるので、tuple と namedtuple の どちらを利用 したほうが 良いか は、人によって判断が異なる のではないかと思います。本記事 では namedtuple を利用しますが、分かりやすい と 思ったほう を利用しても かまいません。

15、18 行目：tuple を、同じ意味 を表す namedtuple に修正する

 1  from ai import ai_by_score
 2
 3  def ai8s(mb, debug=False):
 4      def eval_func(mb):
 5          # 真ん中のマスに着手している場合は、評価値として 2 を返す
 6          if mb.last_move == (1, 1):
 7              return 3
 8   
 9          # 自分が勝利している場合は、評価値として 1 を返す
10          if mb.status == mb.last_turn:
11              return 2
12
13          markpats = mb.enum_markpats()
14          # 相手が勝利できる場合は評価値として -1 を返す
15          if Markpat(last_turn=0, turn=2, empty=1) in markpats:
16              return -1
17          # 次の自分の手番で自分が勝利できる場合は評価値として 1 を返す
18          elif Markpat(last_turn=2, turn=0, empty=1) in markpats:
19              return 1
20          # それ以外の場合は評価値として 0 を返す
21          else:
22              return 0
23
24      return ai_by_score(mb, eval_func, debug=debug)

行番号のないプログラム

from ai import ai_by_score

def ai8s(mb, debug=False):
    def eval_func(mb):
        # 真ん中のマスに着手している場合は、評価値として 2 を返す
        if mb.last_move == (1, 1):
            return 3
    
        # 自分が勝利している場合は、評価値として 1 を返す
        if mb.status == mb.last_turn:
            return 2

        markpats = mb.enum_markpats()
        # 相手が勝利できる場合は評価値として -1 を返す
        if Markpat(last_turn=0, turn=2, empty=1) in markpats:
            return -1
        # 次の自分の手番で自分が勝利できる場合は評価値として 1 を返す
        elif Markpat(last_turn=2, turn=0, empty=1) in markpats:
            return 1
        # それ以外の場合は評価値として 0 を返す
        else:
            return 0

    return ai_by_score(mb, eval_func, debug=debug)

修正箇所

from ai import ai_by_score

def ai8s(mb, debug=False):
    def eval_func(mb):
        # 真ん中のマスに着手している場合は、評価値として 2 を返す
        if mb.last_move == (1, 1):
            return 3
    
        # 自分が勝利している場合は、評価値として 1 を返す
        if mb.status == mb.last_turn:
            return 2

        markpats = mb.enum_markpats()
        # 相手が勝利できる場合は評価値として -1 を返す
-       if (0, 2, 1) in markpats:
+       if Markpat(last_turn=0, turn=2, empty=1) in markpats:
            return -1
        # 次の自分の手番で自分が勝利できる場合は評価値として 1 を返す       
-       elif (2, 0, 1) in markpats:
+       elif Markpat(last_turn=2, turn=0, empty=1) in markpats:
            return 1
        # それ以外の場合は評価値として 0 を返す
        else:
            return 0

    return ai_by_score(mb, eval_func, debug=debug)

上記の 15 行目 の namedtuple を Markpat(0, 2, 1) のように記述することも できますが、わざわざ namedtuple を利用する 意味がなくなります。

動作の確認

先程と同様に、ai2、ai7s と対戦し、以前の対戦結果と比較することで、ai8s が 正しく動作するか どうかを確認します。まず、ai2 と対戦します。

ai_match(ai=[ai8s, ai2])

実行結果（実行結果はランダムなので下記とは異なる場合があります）

ai8s VS ai2
count     win    lose    draw
o        9820       9     171
x        8910     245     845
total   18730     254    1016

ratio     win    lose    draw
o       98.2%    0.1%    1.7%
x       89.1%    2.5%    8.5%
total   93.7%    1.3%    5.1%

次に、ai7s と対戦します。

ai_match(ai=[ai8s, ai7s])

実行結果（実行結果はランダムなので下記とは異なる場合があります）

ai8s VS ai7s
count     win    lose    draw
o        3317     431    6252
x         386    2961    6653
total    3703    3392   12905

ratio     win    lose    draw
o       33.2%    4.3%   62.5%
x        3.9%   29.6%   66.5%
total   18.5%   17.0%   64.5%

関数名	o 勝	o 負	o 分	x 勝	x 負	x 分	勝	負	分
以前の VS `ai2`	98.2	0.1	1.6	89.4	2.5	8.1	93.8	1.3	4.9
今回の VS `ai2`	98.2	0.1	1.7	89.1	2.5	8.5	93.7	1.3	5.1
以前の VS `ai7s`	33.4	3.9	62.6	3.9	28.8	67.3	18.7	16.4	65.0
今回の VS `ai7s`	33.2	4.3	62.5	3.9	29.6	66.5	18.5	17.0	64.5

NamedTuple

Python には、namedtuple に、要素の データ型のヒント を表す 型アノテーション の 機能を追加 した NamedTuple という クラス が typing モジュール に定義されています。NamedTuple と namedtuple の違いは以下の 3 点 で、それ以外 の 機能は同じ です。

NamedTuple では、それぞれの要素に 型アノテーション を 指定できる
カスタムデータ型（tuple のサブクラス）の定義の方法が 異なる
docstring を 記述できる

特に理由がなければ、NamedTuple は、namedtuple の 機能を拡張 したものなので、NamedTuple のほうを 利用したほうが良い でしょう。そこで、NamedTuple の 使い方 について説明し、ai8s を NamedTuple を利用するように修正することにします。

NamedTuple の詳細については、下記のリンク先を参照して下さい。

NamedTuple のインポート

NamedTuple は typing モジュールで定義されているので、利用する際には、下記のプログラムで インポート する必要があります。

from typing import NamedTuple

NamedTuple によるカスタムデータ型の定義

NamedTuple による カスタムデータ型 の定義は、下記のように記述します。理由は後で説明しますが、型アノテーション を省略すると エラーが発生 する点に注意して下さい。

class クラスの名前(NamedTuple):
    要素の名前: 型アノテーション # この行を要素の数だけ記述する

1 行目：通常の クラスの定義 と 同様の記述 を行うが、クラスの名前 の直後に (NamedTuple)⁵を記述する点が 異なる。namedtuple と 異なり、カスタムデータ型 の名前は typename ではなく、クラスの名前 で設定する
2 行目以降：先頭の要素 から順番に、1 行ずつ、要素の名前: 型アノテーション の形式で 要素の名前 と、その要素の データ型のヒント を記述する

namedtuple で定義した場合と 同じフィールド名 を持つ Markpat を、NamedTuple で定義するプログラムは、下記のように記述します。それぞれの要素に代入する値は、整数なので、それぞれの要素の 型アノテーション には 整数型 を表す int を記述しています。

class Markpat(NamedTuple):   
    last_turn: int
    turn: int
    empty: int

また、1 行目 の直後に、通常のクラス と同様に docstring を記述することが できます。docstring を記述する際に、属性の名前 は Attributes セクション に記述します。

下記は、上記のプログラムに docstring を記述したものです。

class Markpat(NamedTuple):
    """マークのパターン.
    
    Attributes:
        last_turn (int):
            直前のターンのマークの数
        turn (int):
            現在のターンのマークの数
        empty (int):
            空のマスの数
    """
    
    last_turn: int
    turn: int
    empty: int

NamedTuple のインスタンスの作成

namedtuple の場合と同様に、以後は NamedTuple の カスタムデータ型 から作成した データ のことを、単に NameTuple と表記します。

NamedTuple の カスタムデータ型 を 定義した後 は、namedtuple の場合と 同じ方法 で インスタンス を作成します。下記は、上記の Markpat から NamedTuple を作成するプログラムで、先程の namedtuple で紹介した すべての方法 が そのまま利用 できます。従って、実行結果 は、先程と 全く同じ になります。

print(Markpat(2, 0, 1))
print(Markpat(2, 0, empty=1))
print(Markpat(2, turn=0, empty=1))
print(Markpat(last_turn=2, turn=0, empty=1))
print(Markpat(empty=1, last_turn=2, turn=0))

実行結果

Markpat(last_turn=2, turn=0, empty=1)
Markpat(last_turn=2, turn=0, empty=1)
Markpat(last_turn=2, turn=0, empty=1)
Markpat(last_turn=2, turn=0, empty=1)
Markpat(last_turn=2, turn=0, empty=1)

動作の確認

namedtuple と NamedTuple は、型アノテーション以外 は 同一の性質 を持ちます。従って、上記のように Markpat を NamedTuple の カスタムデータ型 に変更しても、それを 利用する側 の ai8s を修正する必要は ありません。

先程と同様に、ai2、ai7s と対戦し、以前の対戦結果と比較することで、ai8s が 正しく動作するか どうかを確認します。まず、ai2 と対戦します。

ai_match(ai=[ai8s, ai2])

実行結果（実行結果はランダムなので下記とは異なる場合があります）

ai8s VS ai2
count     win    lose    draw
o        9845       6     149
x        8930     236     834
total   18775     242     983

ratio     win    lose    draw
o       98.5%    0.1%    1.5%
x       89.3%    2.4%    8.3%
total   93.9%    1.2%    4.9%

次に、ai7s と対戦します。

ai_match(ai=[ai8s, ai7s])

実行結果（実行結果はランダムなので下記とは異なる場合があります）

ai8s VS ai7s
count     win    lose    draw
o        3319     415    6266
x         391    2939    6670
total    3710    3354   12936

ratio     win    lose    draw
o       33.2%    4.2%   62.7%
x        3.9%   29.4%   66.7%
total   18.6%   16.8%   64.7%

関数名	o 勝	o 負	o 分	x 勝	x 負	x 分	勝	負	分
以前の VS `ai2`	98.2	0.1	1.6	89.4	2.5	8.1	93.8	1.3	4.9
今回の VS `ai2`	98.5	0.1	1.5	89.3	2.4	8.3	93.9	1.2	4.9
以前の VS `ai7s`	33.4	3.9	62.6	3.9	28.8	67.3	18.7	16.4	65.0
今回の VS `ai7s`	33.2	4.2	62.7	3.9	29.4	66.7	18.6	16.8	64.7

デフォルト値の設定方法

NamedTuple でも、namedtuple と同様に、要素の デフォルト値 を設定することが できます。NamedTuple の場合は、NamedTuple の カスタムデータ型 を定義する際に、デフォルト値 を 要素の名前: 型アノテーション = デフォルト値 のように記述します。namedtuple と同様の理由で、デフォルト値 が設定された 要素名 よりも後に、デフォルト値 が 設定されていない要素名 を記述することは できない 点に注意して下さい。

下記は、namedtuple で デフォルト値 の 設定方法 を説明した際に定義した Point3D を NamedTuple で定義するプログラムです。実行結果 は、先ほど と 全く同じ になります。

class Point3D(NamedTuple):
    last_turn: int
    turn: int = 1
    empty: int = 2

print(Point3D(3))
print(Point3D(4, 5))
print(Point3D(6, 7, 8))

実行結果

Point3D(last_turn=3, turn=1, empty=2)
Point3D(last_turn=4, turn=5, empty=2)
Point3D(last_turn=6, turn=7, empty=8)

NamedTuple の利点

NamedTuple の利点は、NamedTuple の 要素を入力 する際に、型ノーテーション で設定した データ型のヒント が表示される点です。また、docstring を記述することで、NamedTuple の 要素を入力 する際に 説明が表示 されるという利点が得られます。

下図は、namedtuple で定義した Markpat を入力した場合の図です。すぐ上に フィールド名 は表示されますが、データ型 などの情報は 表示されません。

下図は、NamedTuple で定義した Markpat を入力した場合の図です。

図からわかるように、それぞれの 要素の名前 の右に、データ型のヒント（型アノテーション）が表示されます。また、docstring を記述することで、それぞれの要素の意味が表示されるので、データの入力が 分かりやすくなる という利点が得られます。

NamedTuple の限界

NamedTuple による 型アノテーション は、関数の型アノテーション と同様に、ヒントにすぎない ため、強制力 は ありません。従って、下記のプログラムのように、型アノテーション と 異なるデータ型 を要素に代入しても エラーは発生しない 点に注意して下さい。

print(Markpat("a", "b", "c"))

実行結果

Markpat(last_turn='a', turn='b', empty='c')

変数の型アノテーション

以前の記事では、関数の 仮引数 と 返り値 の 型アノテーション を紹介しましたが、Python では、ローカル変数、グローバル変数、属性などに対しても、仮引数 と同様に、名前: 型アノテーション という方法で 型アノテーション を記述することが できます。

NamedTuple の 型アノテーション は、この後で説明する、クラス変数 に対する、値を代入しない 型アノテーション の 仕組み を使って記述しています。

変数の 型アノテーション は、値を代入する 場合と しない 場合があります。

値を代入する変数の型アノテーション

名前: 型アノテーション = 式 のように記述することで、型アノテーション と代入を 同時に行う ことができます。下記は、グローバル変数、ローカル変数、クラス属性、インスタンスの属性 に対する 型アノテーション と代入を行うプログラムです。

a: int = 1 # グローバル変数の型アノテーション

def f():
    b : float = 1.2  # ローカル変数の型アノテーション
    
class C:
    d : str = "text"  # クラス属性の型アノテーション
    
    def __init__(self):
        self.e : list[int] = [1, 2, 3]  # インスタンスの属性の型アノテーション

JupyterLab では、文字を入力すると、下図のような、入力した文字 に関連する 入力の候補 の メニュー が表示されます。

この メニューの中 から、入力したい変数 の 項目の上 に マウスを移動 すると、下図のように 項目の右端 に、 詳細を参照 するための＞の形をした ボタンが表示 されます。

上図ではこの ボタンの右下 に「詳細を参照」という説明が表示されていますが、この説明は、マウス をこのボタン の上に移動 した 場合のみ で表示されます。

このボタン を クリック すると、下図のように 型アノテーション が 右に表示 されるようになります。この表示は右端の × ボタン を クリック することで消すことができます。

他にも、入力した 変数の上 に マウスを移動 することでも、下図のように 型アノテーション の ヒント が表示されます。

値を代入しない変数の型アノテーション

プログラムで、一度も 値を代入していない変数だけ を記述すると、下記のプログラムのように、その 変数が定義されていない（not defined）という エラーが発生 します。

実行結果

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[33], line 1
----> 1 x

NameError: name 'x' is not defined

一方、型アノテーション を設定する場合は、下記のプログラムのように、一度も 値を代入していない変数だけ を記述しても エラーにはなりません。

x: int

ただし、型アノテーション を設定しても、その変数に 値が代入 されたことには ならない ので、下記のプログラムのように、その変数を表示すると エラーが発生 します。

print(x)

実行結果

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[35], line 1
----> 1 print(x)

NameError: name 'x' is not defined

先程説明したように、NamedTuple では、下記のプログラムのように、型アノテーション を省略すると、エラーが発生 します。その理由は、型アノテーション を 設定せず に 変数の名前⁶だけ を記述した場合は、その 変数の値 を 参照する ことになりますが、値が 代入されていない変数 を参照することは できないから です。

そのことは、x という名前（name）が 定義されていない（is not defined）という エラーメッセージ から確認できます。

class Point(NamedTuple):   
    x
    y

実行結果

略
Cell In[36], line 2
      1 class Point(NamedTuple):   
----> 2     x
      3     y

NameError: name 'x' is not defined

tuple の型アノテーション

以前の記事で、list の 型アノテーション の 記述方法 について説明しましたが、tuple の 型アノテーション について 説明していなかった ので、この機会に説明します。

list は、すべての要素 に 同じデータ型 を代入して 利用する ことが 想定される ことが多いので、list の 型アノテーション では、list[str] のように、[] の中 に、その list の要素 の データ型 を 1 つ だけ記述します。

一方、tuple の場合は、それぞれの要素 に 異なるデータ型 を代入することがあるので、以下のような方法で 型アノテーション を記述します。

tuple[int, str, list] のように、それぞれの要素 に代入する データ型 を 先頭から順番 に , で 区切って記述 する
すべての要素 の データ型 が同じ場合は、tuple[int, ...] のように記述する。ただし、この場合は 要素の数 を指定することは できない ので、要素の数 が 少ない場合 は tuple[int, int, int] のように記述したほうが ヒントの意味 が明確になる

tuple の 型アノテーション の詳細については、下記のリンク先を参照して下さい。

dataclass

Python には、NamedTuple に よく似た 機能を持つ dataclass が用意されているので、この機会に説明します。興味がない方は読み飛ばしてもらっても構いません。

なお、この後で説明しますが、dataclass と NamedTuple は似ている点はありますが、異なる性質 を持つので 使い分ける必要がある 点に注意して下さい。

dataclass は、クラスから インスタンスを作成 する際に、特定の属性の値を設定する処理を 簡潔に記述 できる機能や、インスタンス の比較を行う機能などを持ちます。

わかりづらい と思いますので、具体例 を挙げながら説明します。

dataclass を使わない実装方法

インスタンス を作成する際に、x と y という 属性の値 を、実引数 で設定する クラス を、この後で説明する dataclass を 使わず定義 する場合は、下記プログラムのように __init__ メソッド を使って定義します。

なお、このクラスは 2 次元の座標 を表すデータとして考えることができるので、namedtuple での例の場合と同様に、Point という名前で定義しました。

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

この クラス から、下記のプログラムのように x と y 属性 に、実引数 で記述した 値が代入 されえた インスタンス を作成することができます。

p = Point(1, 2)
print(p.x, p.y)

実行結果

1 2

この方法 による クラスの定義 には、下記のような欠点があります。

属性の数が多くなった場合の欠点

属性の数 が 多くなった場合 は、上記の方法では、__init__ メソッドの記述が下記のように大変になります。

仮引数 を、属性の数 だけ記述する必要がある
代入文 を 属性の数 だけ記述する必要がある

`print` でインスタンスを表示した場合の欠点

下記のプログラムのように、print で インスタンスを表示 した場合に、インスタンスの属性 の値が 表示されず、あまり 意味のない情報 が表示される。

p = Point(1, 2)
print(p)

実行結果（at の後ろの数字は毎回異なります）

<__main__.Point object at 0x000001D513E31A90>

比較に関する欠点

下記のプログラムのように、インスタンスの すべての属性 が 同じ値を持つ 場合でも、== 演算子 で インスタンス を比較した場合に False になる。

p1 = Point(1, 2)
p2 = Point(1, 2)
print(p1 == p2)

実行結果

False

これは、自分で定義 した クラス から作成された インスタンス を == 演算子 で比較した場合は、インスタンス の オブジェクトの id が 比較される からです。以前の記事で説明したように、異なるオブジェクト には 異なる id が 割り当てられる ので False になります。

dataclass の使い方と利点

dataclass を利用することで 上記の欠点 を解消することができます。

なお、dataclass には、今回の記事 で紹介する以外にも、さまざまな機能 や性質があります。dataclass の詳細について興味がある方は、下記の リンク先 を参照して下さい。

dataclass のインポート

dataclass は dataclasses という モジュール で定義されているので、利用する際に、下記のプログラムを実行して インポート する必要があります。

from dataclasses import dataclass

dataclass によるクラスの定義とその利点

dataclass を利用した クラスの定義 は、NamedTuple と ほぼ同様 の方法で記述します。NamedTuple との違いは、以下の 2 点 です。

クラスの定義 の 直前の行 に @dataclass を 記述する
クラスの名前 の直後に (NamedTuple) を 記述しない

@dataclass は、以前の記事で、クラスメソッド を定義する際に クラスの定義 の直前に記述した @classmethod と同様の、デコレータ と呼ばれるもので、関数やメソッド に対して何らかの 機能を付け加える（飾り付ける（decorate））という機能を持ちます。

下記は、先程の Point を dataclass を使って定義するプログラムです。下記では記述していませんが、通常のクラス と同様に docstring を記述することも できます。

@dataclass
class Point:
    x: int
    y: int

先程と異なり、属性の数 が 増えた場合 でも、属性の名前: 型アノテーション を 列挙するだけ で済むので、__init__ メソッドを記述するより 簡潔に記述 できます。

NamedTuple と同様に、属性名: 型アノテーション = 式 を記述することで、属性のデフォルト値 を設定することが できます。また、NamedTuple と同様の理由で、型アノテーション を省略すると エラーが発生 する点に注意して下さい。

`print` によるインスタンスの表示の利点

dataclass を利用して定義された クラス から作成された インスタンス を print で表示すると、下記のプログラムのように、インスタンスの属性 の値が表示されます。

p = Point(1, 2)
print(p)

実行結果

Point(x=1, y=2)

`==` による比較の利点

dataclass を利用して定義された クラス から作成された インスタンス を == 演算子で比較すると、下記のプログラムのように、同じ名前 の 属性の値 が すべて等しい 場合に True が、一つでも値が異なれば False が計算されます。

p1 = Point(1, 2)
p2 = Point(1, 2)
p3 = Point(3, 4)
print(p1 == p2)
print(p1 == p3)

実行結果

True
False

クラスの定義の際に列挙していない属性の扱い

dataclass を利用して定義された クラス では、クラスの定義 の際に 列挙していない インスタンスの属性は、print での表示や、== 演算子 の対象とは なりません。この性質は 勘違いしやすい ので dataclass を利用する際には注意して下さい。

例えば、下記のプログラムは、インスタンス の 作成後 に、クラスの定義 の際に 列挙していない z という属性に 値を代入 していますが、z の値 は print では 表示されません。

p = Point(1, 2)
p.z = 3
print(p)

実行結果

Point(x=1, y=2)

また、下記のような インスタンス を == 演算子 で比較した場合でも、z は 比較の対象 とは ならない ので True になります。

同じ属性の値 を持つ、p1 と p2 を作成する
p1 と p2 の z という属性に 別の値 を代入する

p1 = Point(1, 2)
p2 = Point(1, 2)
p1.z = 3
p2.z = 5
print(p1 == p2)

実行結果

True

dataclass の使い道

dataclass は便利ですが、常に使えば良い という わけではありません。dataclass が 持つ性質 を うまく活用できる 場合に利用すると良いでしょう。

例えば、Marubatsu クラスの場合は、下記のような理由から dataclass を利用する メリット がないので、本記事では Marubatsu クラスでは dataclass を 利用しません。

Marubatsu クラスから作成された インスタンスの属性 の中で、インスタンスの作成時 に 実引数 で 値を設定 する 必要がある ものが 存在しない
Marubatsu クラスは、print で ゲーム盤の情報 を わかりやすく表示 する必要があるため、インスタンスの 属性の値 を そのまま表示 しても 意味がない
Marubatsu クラスの インスタンス を == 演算子 で比較する 必要がない

逆に言えば、上記で定義した Point のように、dataclass の利点を うまく活用できる ような クラス を定義する際には、dataclass を 積極的に利用 すると良いでしょう。

他にも、プログラム が 分かりやすくなる という利点から、dict で 表現できるデータ を、dataclass を定義して 記述する ということも 良く行われている ようです。

本記事でも、dataclass を うまく活用できる 場面があれば、利用する ことにします。

dataclass の仕組みと `init` メソッドに関する注意点

細かい話なので、dataclass を 当面使わない と思った人は 読み飛ばして も 構いません。

dataclass を利用する場合は、下記の点 に注意する必要があります。

自分で __init__ メソッドを 定義してはいけない。

その理由について説明します。

dataclass の仕組み

dataclass を利用して定義された クラス には、型アノテーション が設定された クラス属性 に 対応する処理 を行う __init__ メソッドが 自動的に定義 されます。

例えば、dataclass を利用して定義された Point クラスには、下記の __init__ メソッドが 自動的に定義 されます。

def __init__(self, x:int, y:int):
    self.x = x
    self.y = y

dataclass を利用することで、__init__ メソッドを定義する必要が なくなった のは、実は dataclass のほうで __init__ の 定義の記述 を、代わりに行ってくれている からです。

`init` メソッドを自分で定義してはいけない理由

dataclass のほうで __init__ の定義を記述するということは、自分で __init__ の定義が できなくなる ということです。例えば、下記のプログラムのように、dataclass を利用した クラス に、自分で __init__ メソッドを定義すると、dataclass が 自動的に定義 した __init__ メソッドの定義が、自分で記述 した __init__ メソッドの定義で 上書き されてしまうことになります。

@dataclass
class Point:
    x: int
    y: int

    def __init__(self):
        pass

上記の Point から インスタンス を作成すると、上記の __init__ メソッドが実行されます。従って、下記のプログラムで、これまで のように、x と y 属性に 1 と 2 が代入された Point の インスタンス を作成しようとすると、上記の __init__ メソッドが実行されるため、実引数の数 と、仮引数の数 が 一致しない ことを表す エラーが発生 します。

p = Point(1, 2)

実行結果

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[48], line 1
----> 1 p = Point(1, 2)

TypeError: Point.__init__() takes 1 positional argument but 3 were given

また、下記のプログラムのように、実引数 を 記述しない ことで Point の インスタンス を作成することはできますが、dataclass が定義した __init__ メソッドは 実行されない ため、インスタンス の x、y 属性に値は 代入されません。そのため、下記のプログラムを実行すると、x という属性が 定義されていない という エラーが発生 します。

p = Point()
print(p.x)

実行結果

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[49], line 2
      1 p = Point()
----> 2 print(p.x)

AttributeError: 'Point' object has no attribute 'x'

`__post_init__` メソッド

dataclass を利用して定義された クラス で、インスタンス を作成した際の処理を行いたい場合は、__post_init__ メソッドを定義します。__post_init__ メソッドは、dataclass が定義した __init__ メソッドが 実行された後⁷で 呼び出される メソッドで、仮引数 には self のみ を記述します。下記は、post init という メッセージを表示 する処理を行う __post_init__ メソッドを Point の定義 に追加したプログラムです。

@dataclass
class Point:
    x: int
    y: int

    def __post_init__(self):
        print("post init")

下記のプログラムを実行すると、実行結果 からわかるように、インスタンス を作成したs際に、post_init が 呼び出され、メッセージが表示 されます。

print(Point(1, 2))

実行結果

post init
Point(x=1, y=2)

dataclass と NamedTuple の違い

dataclass と NamedTuple は 似ています が、下記の点 が 異なる ので、使い分ける 必要があります。

ミュータブルである

dataclass を利用して定義された クラス から作成された インスタンス は、ミュータブル な データ です。従って、ハッシュ可能 なオブジェクト ではない ので、下記のプログラムのように、set の 要素に代入 すると エラーが発生 します。

print({Point(1, 2)})

実行結果

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[52], line 1
----> 1 print({Point(1, 2)})

TypeError: unhashable type: 'Point'

tuple ではない

dataclass を利用して定義された クラス から作成された インスタンス は、tuple ではない ので、下記のプログラムのように、展開によって インスタンス の属性を 取り出す ことは できません。この点は、NamedTuple より も不便と言えるでしょう。

p = Point(1, 2)
x, y = p

実行結果

post init
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[53], line 2
      1 p = Point(1, 2)
----> 2 x, y = p

TypeError: cannot unpack non-iterable Point object

下記のプログラムのように、クラスの定義 の直前に、@dataclass(frozen=True) を記述することで、定義した クラス から作成された データ を イミュータブル で、ハッシュ可能なオブジェクト にすることが できます。従って、下記のプログラムのように、set の要素 に代入することが できます。

@dataclass(frozen=True)
class Point:
    x: int
    y: int

print({Point(1, 2)})

実行結果

{Point(x=1, y=2)}

ただし、このようにした場合でも、インスタンス は tuple ではない ので、x, y = p のような展開を行うことは できません（先程と同様のエラーが発生します）。

frozen とは 凍結する という意味の英語で、形が変化する水 が 凍結する と 固まって変化しなくなる ことが、データを変更できない、イミュータブル なデータに 似ている ことから、キーワード引数 に この名前が付けられている ようです。

`enum_markpats` を利用した `ai6s` と `ai7s` の定義

enum_markpats を利用しない実装方法の例として残しておきたいので、本記事では採用しませんが、ai6s と ai7s を enum_markpats を利用して 簡潔に記述 することが できます。下記は、ai6s を enum_markpats を使って修正したプログラムです。

def ai6s(mb, debug=False):
    def eval_func(mb):
        # 自分が勝利している場合は、評価値として 1 を返す
        if mb.status == mb.last_turn:
            return 1

        markpats = mb.enum_markpats()
        # 相手が勝利できる場合は評価値として -1 を返す
        if Markpat(last_turn=0, turn=2, empty=1) in markpats:
            return -1
        # それ以外の場合は評価値として 0 を返す
        else:
            return 0

    return ai_by_score(mb, eval_func, debug=debug)

下記のプログラムで ai6 と対戦した結果、正しく動作 することが確認できます。

from ai import ai6, ai7

ai_match(ai=[ai6s, ai6])

実行結果（実行結果はランダムなので下記とは異なる場合があります）

ai6s VS ai6
count     win    lose    draw
o        3140    1702    5158
x        1704    3116    5180
total    4844    4818   10338

ratio     win    lose    draw
o       31.4%   17.0%   51.6%
x       17.0%   31.2%   51.8%
total   24.2%   24.1%   51.7%

下記は、ai7s を enum_markpats を使って修正したプログラムです。

def ai7s(mb, debug=False):
    def eval_func(mb):
        # 真ん中のマスに着手している場合は、評価値として 2 を返す
        if mb.last_move == (1, 1):
            return 2
            
        # 自分が勝利している場合は、評価値として 1 を返す
        if mb.status == mb.last_turn:
            return 1

        markpats = mb.enum_markpats()
        # 相手が勝利できる場合は評価値として -1 を返す
        if Markpat(last_turn=0, turn=2, empty=1) in markpats:
            return -1
        # それ以外の場合は評価値として 0 を返す
        else:
            return 0

    return ai_by_score(mb, eval_func, debug=debug)

下記のプログラムで ai7 と対戦した結果、正しく動作 することが確認できます。

ai_match(ai=[ai7s, ai7])

実行結果（実行結果はランダムなので下記とは異なる場合があります）

ai7s VS ai7
count     win    lose    draw
o        2962     406    6632
x         392    2933    6675
total    3354    3339   13307

ratio     win    lose    draw
o       29.6%    4.1%   66.3%
x        3.9%   29.3%   66.8%
total   16.8%   16.7%   66.5%

今回の記事のまとめ

今回の記事では、dict を ハッシュ可能なオブジェクト に変換する方法として、namedtuple と NamedTuple を 利用する方法 について説明しました。

また、NamedTuple を利用するように ai6s を定義する方法を説明しました。

本記事で入力したプログラム

以下のリンクから、本記事で入力して実行した JupyterLab のファイルを見ることができます。

以下のリンクは、今回の記事で更新した marubatsu.py です。

以下のリンクは、今回の記事で更新した ai.py です。

次回の記事

特定のクラス の性質を 受け継いだサブクラス を定義することを、クラスの継承 と呼びます。クラスの継承については今後の記事で紹介します ↩
後述の、デフォルト値 を設定した場合を 除きます ↩
__new__ は __init__ と 似た性質 を持つ 特殊メソッド で、インスタンス が 作成された際 に 自動的 に 呼び出されます。__new__ と __init__ の違いは複雑なので説明は省略します。興味がある方は、こちらのリンク先を参照して下さい ↩
デフォルト値 を 位置引数 で記述することは できません ↩
この部分の意味 については、NamedTuple を 利用する際 に 理解する必要 は ありません ので今回の記事では説明を省略します。なお、この部分 は関数の仮引数のように見えるかもしれませんが、仮引数ではありません。この部分の意味については今後の記事で説明します ↩
下記の場合は、正確には クラス属性 です ↩
post は、英語で ～の後の という意味を持ちます ↩

You get articles that match your needs
You can efficiently read back useful information
You can use dark theme

What you can do with signing up

Pythonで〇×ゲームのAIを一から作成する その54 namedtuple を使った dict の変換

目次と前回の記事

これまでに作成したモジュール

これまでに作成した AI

修正した count_marks の問題点

namedtuple の性質と使い方

namedtuple の性質

namedtuple のインポート

namedtuple のデータの作成手順

サブクラスとは何か

サブクラスを定義する理由

namedtuple のカスタムデータ型の定義

マークのパターンを表す namedtuple のカスタムデータ型の定義

namedtuple のインスタンスの作成

フィールド名のデフォルト値の設定方法

namedtuple の利用方法

インデックスによる要素の参照

要素の展開

名前による要素の参照

変数の値を利用した要素の参照

namedtuple を利用した ai8s の修正

Markpat の定義と保存場所

count_marks の修正

動作の確認

ai8s の修正

動作の確認

NamedTuple

NamedTuple のインポート

NamedTuple によるカスタムデータ型の定義

NamedTuple のインスタンスの作成

動作の確認

デフォルト値の設定方法

NamedTuple の利点

NamedTuple の限界

変数の型アノテーション

値を代入する変数の型アノテーション

値を代入しない変数の型アノテーション

tuple の型アノテーション

dataclass

dataclass を使わない実装方法

属性の数が多くなった場合の欠点

print でインスタンスを表示した場合の欠点

比較に関する欠点

dataclass の使い方と利点

dataclass のインポート

dataclass によるクラスの定義とその利点

print によるインスタンスの表示の利点

== による比較の利点

クラスの定義の際に列挙していない属性の扱い

dataclass の使い道

dataclass の仕組みと __init__ メソッドに関する注意点

dataclass の仕組み

__init__ メソッドを自分で定義してはいけない理由

__post_init__ メソッド

dataclass と NamedTuple の違い

ミュータブルである

tuple ではない

enum_markpats を利用した ai6s と ai7s の定義

今回の記事のまとめ

本記事で入力したプログラム

次回の記事

Pythonで〇×ゲームのAIを一から作成する　その54　namedtuple を使った dict の変換

修正した `count_marks` の問題点

namedtuple を利用した `ai8s` の修正

`Markpat` の定義と保存場所

`count_marks` の修正

`ai8s` の修正

`print` でインスタンスを表示した場合の欠点

`print` によるインスタンスの表示の利点

`==` による比較の利点

dataclass の仕組みと `init` メソッドに関する注意点

`init` メソッドを自分で定義してはいけない理由

`__post_init__` メソッド

`enum_markpats` を利用した `ai6s` と `ai7s` の定義