目次と前回の記事

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

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

これまでに作成した 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

前回の記事で修正した `enum_markpats` の問題点

前回の記事の最後で、enum_markpats の 返り値 を list から set に変更するために、下記のような修正を行いました。

4 行目：markpats に代入する値を、空の list から 空の set に修正する
9、11、15、18 行目：append メソッドを、add メソッドに修正する

 1  from marubatsu import Marubatsu
 2
 3  def enum_markpats(self):
 4      markpats = set()
 5  
 6      # 横方向と縦方向の判定
 7      for i in range(self.BOARD_SIZE):
 8          count = self.count_marks(coord=[0, i], dx=1, dy=0)
 9          markpats.add(count)
10          count = self.count_marks(coord=[i, 0], dx=0, dy=1)
11          markpats.add(count)
12      # 左上から右下方向の判定
14      count = self.count_marks(coord=[0, 0], dx=1, dy=1)
15      markpats.add(count)
16      # 右上から左下方向の判定
17      count = self.count_marks(coord=[2, 0], dx=-1, dy=1)
18      markpats.add(count)
19
20      return markpats
21
22  Marubatsu.enum_markpats = enum_markpats

行番号のないプログラム

from marubatsu import Marubatsu

def enum_markpats(self):
    markpats = set()
 
    # 横方向と縦方向の判定
    for i in range(self.BOARD_SIZE):
        count = self.count_marks(coord=[0, i], dx=1, dy=0)
        markpats.add(count)
        count = self.count_marks(coord=[i, 0], dx=0, dy=1)
        markpats.add(count)
    # 左上から右下方向の判定
    count = self.count_marks(coord=[0, 0], dx=1, dy=1)
    markpats.add(count)
    # 右上から左下方向の判定
    count = self.count_marks(coord=[2, 0], dx=-1, dy=1)
    markpats.add(count)

    return markpats

Marubatsu.enum_markpats = enum_markpats

修正箇所

from marubatsu import Marubatsu

def enum_markpats(self):
-   markpats = []
+   markpats = set()
 
    # 横方向と縦方向の判定
    for i in range(self.BOARD_SIZE):
        count = self.count_marks(coord=[0, i], dx=1, dy=0)
-       markpats.append(count)
+       markpats.add(count)
        count = self.count_marks(coord=[i, 0], dx=0, dy=1)
-       markpats.append(count)
+       markpats.add(count)
    # 左上から右下方向の判定
    count = self.count_marks(coord=[0, 0], dx=1, dy=1)
-   markpats.append(count)
+   markpats.add(count)
    # 右上から左下方向の判定
    count = self.count_marks(coord=[2, 0], dx=-1, dy=1)
-   markpats.append(count)
+   markpats.add(count)

    return markpats

Marubatsu.enum_markpats = enum_markpats

しかし、以前の記事で enum_markpats の実装を確認する際に記述した下記のプログラムを実行すると、実行結果 のような エラーが発生 することがわかりました。

from pprint import pprint

mb = Marubatsu()

print(mb)
pprint(mb.enum_markpats())

mb.move(1, 1)
print(mb)
pprint(mb.enum_markpats())

mb.move(0, 0)
print(mb)
pprint(mb.enum_markpats())

mb.move(1, 0)
print(mb)
pprint(mb.enum_markpats())

実行結果

略
Cell In[1], line 9
      7 for i in range(self.BOARD_SIZE):
      8     count = self.count_marks(coord=[0, i], dx=1, dy=0)
----> 9     markpats.add(count)
     10     count = self.count_marks(coord=[i, 0], dx=0, dy=1)
     11     markpats.add(count)

TypeError: unhashable type: 'collections.defaultdict'

このエラーは、ハッシュ可能でない defaultdict を set の 要素に追加 しようとしたことが原因なので、count_marks が ハッシュ可能なオブジェクト を返すように修正する必要があります。どのように修正すれば良いかについて少し考えてみて下さい。

dict のハッシュ可能なオブジェクトへの変換その 1

これまでに紹介した、複数の データ を扱うことができる ハッシュ可能 な データ型 には tuple があるので、まず defaultdict を tuple に変換 する方法を 考える ことにします。

defaultdict は、既定値 に関する処理以外では dict と 同じ性質 を持ちます。今回の記事で紹介する、defaultdict を tuple に変換 する方法では、既定値 に 関する処理 は 行わない ので、dict と defaultdict は、同じ方法 で tuple に変換 できます。

本記事では、以後は 既定値 に関する処理を 行わない 場面で、dict と記述した場合は、defaultdict を含める ことにします。

`count_marks` の修正

count_marks の 返り値 である defaultdict（以後は dict と表記）は、〇、×、空の数を表す 3 つのデータ を 持ちます。従って、その dict を、それらの 3 つの値 を要素として持つ tuple に変換 することが可能です。変換後 の tuple の 3 つの要素 が表すデータの順番は、どのような順番でもかまいませんが、何らかの順番 を 決める必要 があります。そこで、本記事では〇、×、空の順番で、数えた数 を要素として持つ tuple に変換 することにし、下記のプログラムのように、count_marks を修正します。

11 行目：count から Marubatsu.CIRCLE、Marubatsu.CROSS、Marubatsu.EMPTY の順で キーの値 を 取り出し、それらを要素 とする tuple を 返り値 として返すようにする

 1  from collections import defaultdict
 2
 3  def count_marks(self, coord, dx, dy):     
 4      x, y = coord   
 5      count = defaultdict(int)
 6      for _ in range(self.BOARD_SIZE):
 7          count[self.board[x][y]] += 1
 8          x += dx
 9          y += dy
10
11      return count[Marubatsu.CIRCLE], count[Marubatsu.CROSS], count[Marubatsu.EMPTY]
12
13  Marubatsu.count_marks = count_marks

行番号のないプログラム

from collections import defaultdict

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

    return count[Marubatsu.CIRCLE], count[Marubatsu.CROSS], count[Marubatsu.EMPTY]

Marubatsu.count_marks = count_marks

修正箇所

from collections import defaultdict

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

-   return count
+   return count[Marubatsu.CIRCLE], count[Marubatsu.CROSS], count[Marubatsu.EMPTY]

Marubatsu.count_marks = count_marks

動作の確認

改めて先程の下記のプログラムを実行すると、エラー が 発生しなくなります。また、実行結果 から、同じ マークのパターン のデータが 重複しなくなった ことが確認できます。

mb = Marubatsu()

print(mb)
pprint(mb.enum_markpats())

mb.move(1, 1)
print(mb)
pprint(mb.enum_markpats())

mb.move(0, 0)
print(mb)
pprint(mb.enum_markpats())

mb.move(1, 0)
print(mb)
pprint(mb.enum_markpats())

実行結果

Turn o
...
...
...

{(0, 0, 3)}
Turn x
...
.O.
...

{(1, 0, 2), (0, 0, 3)}
Turn o
X..
.o.
...

{(0, 1, 2), (1, 0, 2), (1, 1, 1), (0, 0, 3)}
Turn x
xO.
.o.
...

{(0, 0, 3), (2, 0, 1), (0, 1, 2), (1, 0, 2), (1, 1, 1)}

`count_marks` の問題点

初心者の方は気づいていない人が多いと思いますが、実は、上記の count_marks の修正により、新しい問題 が発生しています。それが何かについて少し考えてみて下さい。

具体的には、下記のプログラムのように、ai6s どうし で対戦を行うと エラーが発生 するという問題です。

from ai import ai_match, ai2, ai6s, ai7s

ai_match(ai=[ai6s, ai6s])

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

略
    442 for i in range(mb.BOARD_SIZE):
    443     count = mb.count_marks(coord=[0, i], dx=1, dy=0)
--> 444     if count[mb.turn] == 2 and count[Marubatsu.EMPTY] == 1:
    445         return -1
    446     count = mb.count_marks(coord=[i, 0], dx=0, dy=1)

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

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

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

エラーメッセージ から、この エラー は、下記の 2 行目 で 発生する ことが分かります。

        count = mb.count_marks(coord=[0, i], dx=1, dy=0)
--->    if count[mb.turn] == 2 and count[Marubatsu.EMPTY] == 1:

上記の 1 行目 の処理で、count には count_marks の 返り値 が代入されますが、その データ型 は先程 count_marks を修正したため tuple になります。

2 行目 の count[mb.turn] の インデックス に記述されている mb.turn には、"o" または "x" という 文字列 が代入されています。tuple の インデックス は整数でなければならないので、2 行目の count[mb.turn] を計算する際に、上記の エラーが発生 します。

この エラー が発生するようになった原因は、ai6s が count_marks の 返り値 が dict であることを前提に処理を行っているにも 関わらず、count_marks の 返り値 を dict から tuple に修正してしまったためです。

互換性（compatibility）とは何か

このように、関数の入力、処理、出力などの 仕様を変更 すると、それを利用 する プログラム が 動作しなくなる という問題が発生する場合が あります。

関数に限らず、モジュール、ソフトウェア、ハードウェア などのものを、別のもの に 置き換える ことが できる ことを、互換性がある（互換性を持つ）と呼ぶ。

例えば、さまざまなメーカー が 乾電池 を発売していますが、（単3電池など）同じ型 の電池であれば、メーカー や 製品の種類 が 異なって いても 置き換える ことが できます。このように、異なる製品 であっても、同じ型 の電池には 互換性 が あります。

互換性の考え方

互換性 を 考える 際に重要となるのは、対象となるものを 利用する際 に重要となる性質です。例えば、電池には さまざまな性質 がありますが、下記の表のように、電池を 電池として利用する 際に 重要となる性質 と、そうでない性質 があります。

重要な性質
- 大きさ（形状）
- 電圧（ボルト数）
- 容量（どれくらい長持ちするか）
- 値段
重要でない性質
- 重さ
- 表面のデザイン

互換性 を 考える際 には、重要な性質のみ を考慮し、重要でない 性質は無視します。

ただし、下記のような場合など、状況によって、重要となる性質 が 変わる 場合があるので、互換性 に関しては、どのような性質 を対象としているかを 考える必要 があります。

短い間 でしか利用しない場合は、容量はあまり 重要ではない
購入済 の電池の中から 選択する よう場合は、値段はあまり 重要はない
見栄え を考慮する必要があるのであれば、デザイン は重要になる

別の例として、過去は重要 であったが、現在では 古すぎて重要ではない 性質を、互換性 の 対象から除外する ことが良くあります。

具体例 としては、2000 年頃 の パソコン で 良く使われていた 記憶装置に、フロッピーディスク がありますが、現在発売 されている パソコン で フロッピーディスク が 使えるものはない でしょう。フロッピーディスクの事が良くわからない人は、最近のパソコンで利用できなくなりつつある CD や DVD を思い浮かべて下さい。

従って、2000 年頃 は パソコンの互換性 を考える際に フロッピーディスクは重要 でしたが、現在では フロッピーディスク は 互換性の対象 とは なりません。

互換性の分類

互換性 は、いくつかに分類されます。互換性の一部の分類は、互換性が対象とする性質を前回の記事で紹介した集合として 考える と わかりやすい でしょう。

互換性 に関する分類は、この後で補足しますが、定義とは 異なる意味 で 使われる場合 があります。そのため、互換性 に関する用語の 使われ方 が 変だと思った場合 は、文脈など からその意味を 判断する必要 があります。

具体例として、下記の性質を持つ 同じ会社 が発売した時計を例に挙げて説明します。

製品名	時刻の表示	日付の表示	アラーム機能	発売年
時計 A	〇			2019
時計 B	〇	〇		2020
時計 C	〇	〇	〇	2021
時計 D	〇		〇	2022
時計 E	〇			2023

なお、後から発売 された 時計 E は、時計 A と 同じ性質 を持ちますが、時計 A とは デザインが異なる 製品だと思ってください。

完全互換（full compatible）

あるもの が、別のもの が持つ機能を すべて備えている ことを 完全互換 と呼びます。互換性が対象 とする性質を集合として考えると、包含関係 を持ちます。

なお、上記の時計の例にはありませんが、値段のように、数字で表される性質 の場合は、同じか、より優れた 性質を表す数字である場合を 完全互換 とみなします。時計の値段の場合は、安いほう が 優れている とみなすことができるので、あるものの値段が、別のものの値段以下の場合に 完全互換 と みなします。

上記の 時計の例 の場合、以下の 組み合わせ は 完全互換性 を持ちます。時計 A と 時計 E のように、両者の性質 が同じである場合も 完全互換 に 含みます。

「B、C、D、E」は A に対して 完全互換性を持つ
C は B に対して 完全互換性を持つ
C は D に対して 完全互換性を持つ
「A、B、C、D」は E に対して 完全互換性を持つ

X と Y を Python の set（集合）として 考える と、X が Y に対して完全互換性を持つ 場合は、X >= Y が True になります。

上位互換（upper compatible）

上位互換 は、完全互換 と 似ています が、両者の性質 が同じである場合は 含みません。これは、「上位」という用語が、より優れている という意味を表すからです。

上記の 時計の例 の場合、以下の 組み合わせ は 上位互換性 を持ちます。時計 A と 時計 E のように、両者の性質 が同じ場合は 上位互換性 を 持ちません。

「B、C、D」は A に対して 上位互換性を持つ
C は B に対して 上位互換性を持つ
C は D に対して 上位互換性を持つ
「B、C、D」は E に対して 上位互換性を持つ

X と Y を Python の set（集合）として 考える と、X が Y に対して上位互換性を持つ 場合は、X > Y が True になります。

実際には、完全互換 を 上位互換 と 同じ意味 で使われる場合があります。

下位互換（lower compatible）

下位互換 は、上位互換 の逆で、あるもの が、別のもの の一部の 性質のみ を持つことを表します。上位互換 の場合と同様に、両者の性質 が同じである場合は 含みません。

上記の 時計の例 の場合、以下の 組み合わせ は 下位互換性 を持ちます。

「A、E」は B に対して 下位互換性を持つ
「A、B、D、E」は C に対して 下位互換性を持つ
「A、E」は D に対して 下位互換性を持つ

時計 B と 時計 D は、お互いが持たない機能 を持つので、下位互換 ではありません。

X と Y を Python の set（集合）として 考える と、X が Y に対して下位互換性を持つ 場合は、X < Y が True になります。

後方互換（backward compatible）

同じ目的 で 作られたもの の中で、後から作られたもの が、それより前 に 作られたもの に対して 何らか の 互換性がある ことを、後方互換 と呼びます。

時計の例 の場合、すべての時計 は 時間を表示 するという 機能を持つ ので、下記のように、後から作られた 時計は、それより前 に作られた時計に対して 後方互換性 を持ちます。

「B、C、D、E」は A に対して 後方互換性を持つ
「C、D、E」は B に対して 後方互換性を持つ
「D、E」は C に対して 後方互換性を持つ
E は D に対して 後方互換性を持つ

例えば、E は D に 対して 上位互換性 を 持たない 事からわかるように、後方互換 と 上位互換 は 異なる意味 の用語です。他の 同様の例 として、機能を下げる ことによって 値段を下げた、廉価版 の製品が 後から発売 されることも良くあります。

しかし、後から作られた ものが、前に作られた ものの 改良版 である ことが多い ので、後方互換性 と 上位互換性 が 同じ意味 で使われる 場合がある 点に注意が必要です。

前方互換（forward compatible）

同じ目的 で 作られたもの の中で、前に作られたもの が、それより後 に 作られたもの に対して 互換性がある ことを、前方互換 と呼びます。

時計の例 の場合、すべての時計 は 時間を表示 するという 機能を持つ ので、下記のように、前に作られた 時計は、それより後 に作られた時計に対して 前方互換性 を持ちます。

A は B に対して 前方互換性を持つ
「A、B」は C に対して 前方互換性を持つ
「A、B、C」は D に対して 前方互換性を持つ
「A、B、C、D」は E に対して 前方互換性を持つ

過去に作られたものが、未来に作られたものの性質を すべて持つ ことは ほとんどない ので、一般的 に 前方互換性 と 完全互換性 や 上位互換性 は同時に 満されません。

非互換（incompatible）

2 つのもの が 共通の性質 を 持たない ことを、非互換 と呼びます。先ほどの 時計の例 では 非互換性 を持つ製品の 組み合わせ は ありません。

個別の性質の互換性

ここまでで説明した互換性の分類は、ものがもつ 性質の全体 を考慮したものですが、それとは別 に、個別の性質 に対して 互換性 と 非互換性 を 考える 場合があります。

例えば、「アラーム機能」という 性質だけ に注目した場合、時計 C と 時計 D は 互換性 を 持ちます が、時計A と 時計 C は 非互換性 を持ちます。

バージョンと互換性

変更前 と 変更後 の仕様を 区別する ための用語を バージョン（version）と呼びます。バージョン を 新しくする ことを バージョンアップ と呼びます。また、何らかの理由で、古いバージョン を 利用する ことを バージョンダウン と呼びます。

バージョン は 一般的 に数字を使って区別することが多く、仕様を 新しくするたび に 数字を増やす のが 一般的 です。

例えば、ソニーのプレーステーション（PlayStation。以後は PS と表記する）というゲーム機は PS1、PS2、PS3、PS4、PS5 という順番でバージョンが付けられています。

Microsoft 社の Office というソフトのバージョンは、Office 2023 のように、発売した年号 でバージョンが付けられています²。

数字以外 をバージョンにする場合もあります。例えば、Microsoft 社の Windows という OS のバージョンはかなり 変則的 で、Windos 95 のように 発売した年（1995年）の 下2桁 でバージョンをつけたり、Windows XP や Windows Me などのように、アルファベット でバージョンをつけたこともありました。なお、Windows 7 以降は、8、10、11 のように 数字の順番 でバージョンをつけています。

なお、数字の順番 でバージョンをつける際に、特定の数字 が 飛ばされる こともあります。例えば Windows 8 の次のバージョンは Windows 10 です。

メジャーバージョンとマイナーバージョン

バージョン を .（半角のピリオド）で 区切って、複数の 数字や記号 を使って 付ける 場合があります。例えば、Python の バージョン は 3.11 のように記述します。また、複数の . を使ってで 2.1.3 のように、3 つ以上 に 分ける こともあります。

バージョンの最初の 数字や記号 を メジャーバージョン、次の 数字や記号 を マイナーバージョン と呼びます。メジャーバージョン や マイナーバージョン の意味は、場合によって異なります が、一般的 には下記のような意味を持ちます。

メジャーバージョン は、一般的 に仕様が 根本的に変わる ような場合に 変えられる ので、メジャーバージョン が 異なる場合 は、一般的 に 多くの性質 の 互換性 が 保たれない と 考えたほうが良い でしょう。なお、メジャーバージョン に 0 がつけられている場合は、一般的 に、正式公開前 の 未完成 の バージョン であることを表します。

マイナーバージョン は、機能の追加 や、大きな不具合の修正 などが行われた場合に 変えられます。多くの機能 は 互換性 が 保たれます が、一部の機能 は 保たれない こともあるので、マイナーバージョン が 変わった場合 は、更新情報 などを見ることを お勧めします。

それ以降 のバージョンの 数字や記号 は、互換性 を 保った ままの、微細な変更 が行われた際に変えられる場合が多く、あまり 気にする必要はない ことが多いでしょう。

例えば、Python の場合は メジャーバージョン が 2 から 3 に 変わった際 に、仕様が 大幅に変更 されました。従って、Python の バージョン 2 で作られた プログラム は、バージョン 3 では 多くの場合 でそのままでは 正しく動作しない と 考えたほうが良い でしょう。

本記事 では marubatsu.py や ai.py などの モジュール を 毎回の記事 で更新し、Github 内 の 記事の番号 と同じ 053 のような名前の フォルダ に モジュール の ファイルを保存 しています。本記事では モジュール に バージョン をつけて 区別していません が、フォルダ名 の番号を マイナーバージョン と みなす ことが できます。

なお、長くなるので説明は省略しますが、github には、フォルダにわけてバージョンを管理するよりも洗練された バージョン管理 の 機能を持ちます。興味がある方は調べてみると良いでしょう。

プログラムにおける互換性

下記は、今回の記事の最初で説明した、互換性 の定義を再掲したものです。

関数に限らず、モジュール、ソフトウェア、ハードウェア などのものを、別のもの に 置き換える ことが できる ことを、互換性がある（互換性を持つ）と呼ぶ。

上記の定義から、プログラム の場合は、関数や モジュール の機能が 共通していても、それらを 異なるバージョン で 置き換えた時 に 動作しなくなる 場合は、互換性がある とは みなされません。例えば、count_marks は、今回の記事の 修正前 と、修正後 で、いずれも マークの数を数えるという 共通の機能を持ちますが、バージョンアップ することで ai8s が 正しく動作しなくなる ので 互換性 があるとは みなされません。

プログラム での 互換性 は、モジュール など、他人が作成 した プログラム を 利用する際 に 特に重要 となる概念です。実際に Python そのものの バージョン や、モジュール の バージョン が 異なる と、同じプログラム が正しく 動作しなくなる 場合がある理由は、そのプログラム が利用している モジュール に 互換性がない ことが原因です。

互換性の確認方法

モジュール が バージョンアップ した際に、その モジュール の すべて の 関数の仕様 が変化することは ほとんどありません。どの関数 の 仕様が変化 したかについては、更新情報 を記した ドキュメント が 示される のが 一般的 です。例えば、下記のリンクは Python の バージョン 3.11 の 更新情報 が記述されている 公式のドキュメント です。

モジュールの ドキュメント の関数などの 仕様の説明 の所にも、一般的 に バージョン による 仕様の変更 に関する情報が記述されます。例えば、下記は組み込み型のクラスである、float の 仕様を説明 する 公式ドキュメント への リンク ですが、その 説明の中 に、下記のような バージョン による 仕様の変更 の情報が記述されています。

「バージョン 3.7 で変更: x は位置専用引数になりました」

バージョンの確認の重要性

Python に限らず、プログラム や モジュール を 一般に公開 する際に、その プログラムを作成 した プログラム言語 の バージョン や、モジュール の バージョン などを明記する 場合が多い のは、互換性 が原因です。本記事でも、初回の記事でそれらを明記しています。

他人が作成 したモジュールを バージョンアップ した際に、プログラム が 動作しなくなった場合 は、互換性 が原因である 可能性が高い ことを覚えておいたほうが良いでしょう。

互換性 は、ソフトウェア だけでなく、ハードウェア にも存在します。例えばプレーステーション（PS）というゲーム機は、PS1 と PS2 の間で 互換性があった ため、PS2 で PS1 のソフトを そのまま遊ぶ ことが できました が、PS3 と PS4 の間には 互換性がない ので、PS4 で PS3 のソフトをそのまま遊ぶことは できません。

プログラムの後方互換性

プログラムでは、後方互換性 が 特に重要 です。例えば関数や モジュール の 仕様を更新 して バージョンアップ した際に、新しいバージョンが 後方互換性 かつ 完全互換性 を持つ場合は、古いバージョン を使って作られた プログラム を 変更することなく、そのまま利用 することが できます。上記のノート で紹介した、PS2 で PS1 のゲーム を そのまま遊べる のは、PS2 が PS1 に対して 後方互換性 と 完全互換性 を持つからです。一方、今回の記事で バージョンアップ した count_marks は、後方互換性 を 持たない ため、バージョンアップ前 の count_marks を利用していた ai6s を実行すると エラーが発生 します。

モジュール などの バージョンアップ を行っても、プログラム が そのまま動作 することが多いのは、後方互換性 と 完全互換性 があるように モジュール が 作られている 場合が多いからです。例えば、Windows という OS は、ほとんどの機能 に対して 後方互換性 があるように 作られている ので、古いバージョン Windowsで 作られた ソフトの多くは、新しいバージョン の Windows で そのまま実行 することが できます。

一般的 に、バージョンアップ時 に 互換性 と表記した場合は、後方互換性 と 完全互換性 の 両方の性質 を 持つ場合 の事を表します。本記事 でも以後は、バージョンアップ時 の 互換性 という用語を、そのような意味で使用することにします。

プログラムの前方互換性

過去のバージョン で、未来のバージョン の機能を利用できるという、前方互換性 の性質を実現することは、未来の予測 が 難しい ため、一般的 には困難です。また、プログラム の場合は、最近ではインターネットから 簡単にバージョンアップ が できるようになった ので、前方互換性 の性質が 求められる 場面はあまり 多くありません。そのため、バージョンアップ時 に 前方互換性 を 考慮しない ことが良くあります。本記事 でも、関数や モジュール の バージョンアップ時 に 前方互換性 は 考慮しません。

前方互換性 は、例えば ソフトウェア が有料な場合など、バージョンアップ が 簡単でない場合 などで 必要とされます。前方互換性 は、将来の バージョンアップ を 想定する ように 仕様を設計 するなどの方法で実現します。前方互換性 があるソフトウェアの 代表例 として、Microsoft 社の Office の製品が挙げられます。実際に Word などの Office の製品は、新しいバージョン で 作られた文章 を、古いバージョン で 開いて編集 することが可能です。他にも、先程例とした挙げた Windows にも 前方互換性 があり、例えば Windows 11 で作成したソフトを、多くの場合 で Windows 10 で実行 することができます。

なお、前方互換性 は、一般的 に 新しいバージョン の 一部の機能 しか利用できないという限界があります。当たり前ですが、過去のバージョン の 仕様を作成 した際に、未来のバージョン で 追加される機能 を 完全に想定 するのは ほぼ不可能 だからです。実際に Office 製品では、古いバージョン で 新しいのバージョン で作られた文書を 開いて編集 することは できますが、新しいバージョン で追加された 新しい機能 を利用することは できません。

具体例として、Excel という表計算ソフトは 前方互換性 を 持ちます が、IFS という関数は Excel 2016 で 新しく追加 された機能なので、それ以前のバージョン で この関数を利用 した ファイル を 開いた際 に、この関数 は 正しく動作しません。

互換性の問題を解決する方法

以後は、互換性 を、後方互換性 と 完全互換性 を持つという意味で使用します。

他人が作成 した モジュール を 利用する側 の立場では、互換性 が あれば、モジュールの バージョン が 変わっても、自分が記述 した プログラム を変更する 必要がない ので、互換性 が あったほうが便利 です。

一方、自分で作成 した モジュール を一般に 公開する側 の立場では、仕様を変更 する際に、その 前後のバージョン で 互換性を持つ のは、それほど簡単な話ではないので、互換性 を持つことが、必ずしも 望ましい とは かぎりません。

仕様を変更 した際に、互換性 の問題を 解決する ための、さまざまな方法 があります。本記事では、そのうちの、良く使われる いくつかの方法について紹介します。

仕様を変更したモジュールを利用しているプログラムを修正する

この方法は 仕様を変更 した モジュール が、互換性 を全く 持たない 方法です。

プログラムの中で、仕様を変更 した モジュール を利用する 記述の数 が 少ない 場合は、プログラム のほうを、新しい仕様 に 合わせて修正 するという方法があります。例えば、プログラムの中で モジュール を利用する 記述の数 が 1 つ の場合などです。

本記事 でも、これまでに 多くの関数 の仕様を 何度も変更 してきましたが、ほとんどの場合 で その関数 を利用する記述が 少なかった ので、この方法で修正 を行ってきました。

しかし、プログラムの中で 仕様を変更 した モジュール を利用する 記述の数 が 多くなる と、それらを すべて修正 するのが大変になります。また、その モジュール を 一般に公開 していた場合は、その モジュール を 誰がどれだけ利用 しているかが わからない ので、そのような場合は この方法 による影響を予測することは困難です。

なお、この方法には、上記のような欠点は ありますが、互換性より も 仕様の修正 のほうが重要な場合や、互換性 を持たせることが 困難な場合 などで、実際に 行われます。

具体的には、バグを修正 するために 互換性 をどうしても 保てない場合 があります。特に セキュリティ に 関するバグ など、互換性 を 持つより も バグの修正 のほうが 重要な場合 は、互換性 を あきらめる ことになります。

他の例としては、仕様が古くなった 場合などで、モジュール や ソフトウェア そのものを、一から 設計し直したほう が 良い場合 などがあり、そのような更新を行う場合は、一般的 に メジャーバージョン を更新します。

あまりよい例えではないかもしれませんが、何十年も前の 古いクーラー を、修理しながら だましだまし 使っていく のを やめて、新しいクーラー を買うという場合に似ています。新しいクーラーなので、今まで とは 異なる使い方 を 覚える必要 がありますが、性能や 電気代 などの面で 得になる でしょう。

別の関数として定義する

モジュール内 の 関数の仕様 を変更する際に、その 関数そのもの を修正するの ではなく、元の関数 をそのまま 残したまま、別の名前 の関数として 定義する という方法があります。この方法は、元の関数 が そのまま残る ので、互換性 を持つ方法です。

一方、この方法には、下記のような問題があります。

修正前 と 修正後 の プログラム が ほとんど同じ場合 は、似たような処理 を行う関数が 2 つ定義 されてしまう
それぞれ の関数に 別の名前 を 付ける必要 があるため、修正を何度も 重ねていく と、同じような名前 の関数が 複数定義 されてしまうため、区別が大変 になる

count_marks に この方法を適用 する場合、下記の 2 つ の メソッドを定義 する事になります。2 つ目 の count_marks_by_tuple が tuple で マークのパターン を返すメソッドですが、count_marks と 異なる のは、最後の return 文だけ です。

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

        return count    

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

        return count[Marubatsu.CIRCLE], count[Marubatsu.CROSS], count[Marubatsu.EMPTY]

count_marks_by_tuple の場合は、下記のプログラムのように 工夫する ことで、同じような関数 を 2 つ定義 する 問題を解決 できますが、このような工夫を 常に行える とは 限りません。また、この方法では 名前の問題 を 解決できません。

2 行目：count_marks を 呼び出して、dict の マークのパターン を計算する
3 行目：dict を tuple に変換した値を返す

def count_marks_by_tuple(self, coord, dx, dy):
    count = self.count_marks(self, coord, dx, dy):
    return count[Marubatsu.CIRCLE], count[Marubatsu.CROSS], count[Marubatsu.EMPTY]

関数のデフォルト引数を利用して互換性を持つ

関数の名前 を 変更せず に、仮引数 を使って 互換性を持つ という方法があります。この方法では、仮引数 に 代入された値 によって、その関数が 修正前の処理 を行うか、修正後の処理 を行うかを 変更できる ようにします。また、その際に、その 仮引数 を デフォルト引数 とし、デフォルト値 に 修正前の処理 を行う 値を設定 することで、その 関数を利用 していた プログラム を 修正する必要 が なくなります。本記事 では この方法 で count_marks の 互換性を持つ ようにすることにします。

なお、この方法 は実際に 良く使われる 方法ですが、修正を重ねる たびに、関数の中 で 互換性を持つ ための記述が 増えていく ことになるので、下記のような問題が 発生しやすく なります。そのため、ある程度以上 古くなった 過去の仕様に関する 互換性 を 切り捨てて プログラムを 整理する ということも 良く行われます。

関数の 仮引数 が 増えた 結果、使い方 が 分かりづらくなる
関数で 行われる処理 が 複雑になる ため 分かりづらくなる
上記の 2 つが原因で、バグが 発生しやすく なる

モジュール の ドキュメント などで、非推奨（deprecated）という用語をよく見かけますが、これは その機能 を 互換性のため に しばらく残しておく が、将来のバージョン で 利用できなくなる予定 であるということを表します。そのような機能は、いつ使えなくなる か わからない ので、なるべく 使用しないほうが良い でしょう。

例えば、Python の 公式ドキュメント の組み込み関数 int の説明には、下記のような、非推奨 に関する記述があります。

「バージョン 3.11 で変更: __trunc__() への処理の委譲は非推奨になりました」

互換性を持つ `count_marks` の修正

互換性を持つ ように、count_marks を修正するためには、互換性のため の 仮引数 の名前を 考える 必要があります。そこで、その 仮引数 を以下のように定義する事にします。

名前：返り値 の データ型（datatype）を表すので、datatype という名前にする
意味："dict" という 文字列 の場合は dict を返し、それ以外 の場合は tuple を返す
規定値：それまでに dict が返される と想定してこの関数を利用していた プログラム を 修正しなくても済む ように、"dict" を規定値 とする

上記以外にも、仮引数 を下記のように定義する方法も 考えられます。もっと良い 仮引数の定義の方法を 思いついた人 は その方法 を採用しても かまいません。

実際に 返される 値の データ型 が defaultdict であることを考慮して、"dict" または "defaultdict" が代入された場合に dict を返す ようにする
文字列 ではなく、dict という 組み込み型のクラス そのものが代入された場合に、dict を返す ようにする
仮引数 の名前を例えば、return_by_dict のようにし、True が代入された場合に dict を、False が代入された場合に tuple を返す ようにする

下記のプログラムは、仮引数 に datatype を追加した count_marks の定義です。

1 行目：デフォルト値 を "dict" とする デフォルト引数 datatype を追加する
9、10 行目：datatype が "dict" の場合に、dict が代入 された count をそのまま返す
11、12 行目：そうでない 場合に、count を tuple に変換 した値を返す

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

行番号のないプログラム

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[Marubatsu.CIRCLE], count[Marubatsu.CROSS], count[Marubatsu.EMPTY]

Marubatsu.count_marks = count_marks

修正箇所

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

-   return count[Marubatsu.CIRCLE], count[Marubatsu.CROSS], count[Marubatsu.EMPTY]
+   if datatype == "dict":
+       return count
+   else:
+       return count[Marubatsu.CIRCLE], count[Marubatsu.CROSS], count[Marubatsu.EMPTY]

Marubatsu.count_marks = count_marks

上記の count_marks は、datatype に "dict" 以外 のデータが代入されている場合に tuple が 返されます。そのため、例えば datatype に "int" という 文字列 が代入されている場合でも、整数型ではなく、tuple が 返されます。その点が 気になる 方は、最後の if 文 を下記のプログラムのように修正して下さい。

ただし、下記のように 厳密な処理 を 記述しなくても、互換性を持つ という目的を 達成できる ので、元のプログラム のままでも 問題はない でしょう。本記事 でも、下記のプログラムのようには 修正しない ことにします。

3、4 行目：datatype が "tuple" の場合に tuple を返す ようにする
5 ～ 7 行目：datatype が "dict" でも、"tuple" でもない 場合は「不正（invalid）なデータ型」という意味の エラーメッセージを表示 して None を返す

略
1  if datatype == "dict":
2      return count
3  elif datatype == "tuple":
4      return count[Marubatsu.CIRCLE], count[Marubatsu.CROSS], count[Marubatsu.EMPTY]
5  else:
6      print("invalid datatype", datatype)
7      return None

`count_marks` の互換性の確認

count_marks が 互換性を持つ ようになったので、今度は下記のプログラムを実行しても エラー が 発生しなくなり、実行結果 から ai6s が 正しく動作 することも確認できます。

ai_match(ai=[ai6s, ai6s])

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

ai6s VS ai6s
count     win    lose    draw
o        3060    1726    5214
x        1761    3100    5139
total    4821    4826   10353

ratio     win    lose    draw
o       30.6%   17.3%   52.1%
x       17.6%   31.0%   51.4%
total   24.1%   24.1%   51.8%

`enum_markpats` の修正と確認

count_marks の 仕様に合わせて、enum_markpats を下記のように修正します。

6、8、11、14 行目：count_marks に キーワード引数 datatype="tuple" を記述する³

 1  def enum_markpats(self):
 2      markpats = set()
 3
 4      # 横方向と縦方向の判定
 5      for i in range(self.BOARD_SIZE):
 6          count = self.count_marks(coord=[0, i], dx=1, dy=0, datatype="tuple")
 7          markpats.add(count)
 8          count = self.count_marks(coord=[i, 0], dx=0, dy=1, datatype="tuple")
 9          markpats.add(count)
10      # 左上から右下方向の判定
11      count = self.count_marks(coord=[0, 0], dx=1, dy=1, datatype="tuple")
12      markpats.add(count)
13      # 右上から左下方向の判定
14      count = self.count_marks(coord=[2, 0], dx=-1, dy=1, datatype="tuple")
15      markpats.add(count)
16
17      return markpats
18
19  Marubatsu.enum_markpats = enum_markpats

行番号のないプログラム

def enum_markpats(self):
    markpats = set()
 
    # 横方向と縦方向の判定
    for i in range(self.BOARD_SIZE):
        count = self.count_marks(coord=[0, i], dx=1, dy=0, datatype="tuple")
        markpats.add(count)
        count = self.count_marks(coord=[i, 0], dx=0, dy=1, datatype="tuple")
        markpats.add(count)
    # 左上から右下方向の判定
    count = self.count_marks(coord=[0, 0], dx=1, dy=1, datatype="tuple")
    markpats.add(count)
    # 右上から左下方向の判定
    count = self.count_marks(coord=[2, 0], dx=-1, dy=1, datatype="tuple")
    markpats.add(count)

    return markpats

Marubatsu.enum_markpats = enum_markpats

修正箇所

def enum_markpats(self):
    markpats = set()
 
    # 横方向と縦方向の判定
    for i in range(self.BOARD_SIZE):
-       count = self.count_marks(coord=[0, i], dx=1, dy=0)
+       count = self.count_marks(coord=[0, i], dx=1, dy=0, datatype="tuple")
        markpats.add(count)
-       count = self.count_marks(coord=[i, 0], dx=0, dy=1)
+       count = self.count_marks(coord=[i, 0], dx=0, dy=1, datatype="tuple")
        markpats.add(count)
    # 左上から右下方向の判定
-   count = self.count_marks(coord=[0, 0], dx=1, dy=1)
+   count = self.count_marks(coord=[0, 0], dx=1, dy=1, datatype="tuple")
    markpats.add(count)
    # 右上から左下方向の判定
-   count = self.count_marks(coord=[2, 0], dx=-1, dy=1)
+   count = self.count_marks(coord=[2, 0], dx=-1, dy=1, datatype="tuple")
    markpats.add(count)

    return markpats

Marubatsu.enum_markpats = enum_markpats

次に、修正した enum_markpats が 正しく動作するか を、先程のプログラムで確認します。実行結果は先ほどと同じなので省略しますが、正しく動作 することが確認できます。

mb = Marubatsu()

print(mb)
pprint(mb.enum_markpats())

mb.move(1, 1)
print(mb)
pprint(mb.enum_markpats())

mb.move(0, 0)
print(mb)
pprint(mb.enum_markpats())

mb.move(1, 0)
print(mb)
pprint(mb.enum_markpats())

`ai8s` の修正方法その 1

enum_markpats が 返す値 が、dict を要素 とする list から、tuple を要素 とする list に変更されたので、それに合わせて ai8s の下記のプログラムの 5、8 行目 の 条件式 の部分を修正する必要があります。どのように修正すれば良いかについて少し考えてみて下さい。

 1  def ai8s(mb, debug=False):
 2      def eval_func(mb):
略
 3          markpats = mb.enum_markpats()
 4          # 相手が勝利できる場合は評価値として -1 を返す
 5          if {mb.turn: 2, Marubatsu.EMPTY: 1} in markpats:
 6              return -1
 7          # 次の自分の手番で自分が勝利できる場合は評価値として 1 を返す
 8          elif {mb.last_turn: 2, Marubatsu.EMPTY: 1} in markpats:
 9              return 1
10          # それ以外の場合は評価値として 0 を返す
11          else:
12              return 0
略

まず、2 つある条件式のうち、5 行目 の下記の 条件式 を修正する方法を 考えます。

if {mb.turn: 2, Marubatsu.EMPTY: 1} in markpats:
    return -1

上記は、「自 0 敵 2 空 1」という、敵が勝利できる マークのパターン を表す dict が markpats の 要素に存在するか どうかを判定しています。従って、これを、そのマークのパターン を表す tuple に変更 する必要があります。

enum_markpats が返す、マークのパターン の一覧の中の tuple の要素には、「〇、×、空」の順でマークの数が代入されます。従って、「自 0 敵 2 空 1」を表す tuple は、自分の手番 の 種類によって、下記のように 異なります。

自分の手番 が〇の場合は、「自 0 敵 2 空 1」は、「〇 0 × 2 空 1」なので、 このマークのパターン を表す tuple は (0, 2, 1) である
自分の手番 が × の場合は、「自 0 敵 2 空 1」は、「〇 2 × 0 空 1」なので、このマークのパターン を表す tuple は (2, 0, 1) である

下記は、自分の手番 が〇と × の 場合に分けて 上記の 条件式を修正 したプログラムです。なお、mb は 相手の手番 の局面なので、自分の手番 が 〇であるか どうかは、mb.turn == Marubatsu.CROSS で判定する 必要がある 点に注意して下さい。

        # 相手が勝利できる場合は評価値として -1 を返す
        if mb.turn == Marubatsu.CROSS and (0, 2, 1) in markpats:
            return -1
        if mb.turn == Marubatsu.CIRCLE and (2, 0, 1) in markpats:
            return -1

また、or 演算子 を利用することで、下記のプログラムのように 1 つの if 文 に まとめる こともできます。or 演算子 のほうが、and 演算子より も 優先順位 が低いので、1 つの if 文 に まとめる際 に、元の条件式 を () で囲う必要 がある点に注意が必要です。

        # 相手が勝利できる場合は評価値として -1 を返す
        if (mb.turn == Marubatsu.CROSS and (0, 2, 1) in markpats) or \
           (mb.turn == Marubatsu.CIRCLE and (2, 0, 1) in markpats):
            return -1

`ai8s` の修正

もう一つ の 条件式 も 同様の方法 で記述できるので、ai8s を下記のプログラムのように修正します。

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 (mb.turn == Marubatsu.CROSS and (0, 2, 1) in markpats) or \
           (mb.turn == Marubatsu.CIRCLE and (2, 0, 1) in markpats):
            return -1
        # 次の自分の手番で自分が勝利できる場合は評価値として 1 を返す
        elif (mb.turn == Marubatsu.CROSS and (2, 0, 1) in markpats) or \
           (mb.turn == Marubatsu.CIRCLE and (0, 2, 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 {mb.turn: 2, Marubatsu.EMPTY: 1} in markpats:        
+       if (mb.turn == Marubatsu.CROSS and (0, 2, 1) in markpats) or \
+          (mb.turn == Marubatsu.CIRCLE and (2, 0, 1) in markpats):
            return -1
        # 次の自分の手番で自分が勝利できる場合は評価値として 1 を返す
-       elif {mb.last_turn: 2, Marubatsu.EMPTY: 1} in markpats:
+       elif (mb.turn == Marubatsu.CROSS and (2, 0, 1) in markpats) or \
+          (mb.turn == Marubatsu.CIRCLE and (0, 2, 1) in markpats):
            return 1
        # それ以外の場合は評価値として 0 を返す
        else:
            return 0

    return ai_by_score(mb, eval_func, debug=debug)

動作の確認

前回の記事で、enum_markpats を実装した際に ai8s2 という、ai8s とは 異なる名前 で ルール 8 の AI を定義 したので、今回は何故 そのようにしないのか と 思った人がいるかも しれません。前回の記事で ai8s と 異なる名前 で AI を定義 したのは、enum_markpats を 利用するように修正 した AI が 正しく動作するか どうかを、enum_markpats を 利用しない修正前 の ai8s と 対戦して確認 できるように するため でした。一方、今回の場合 は、修正前 の ai8s も enum_markpats を 利用しています。そのため、元の ai8s そのものが 動作しなく なっており、ai8s を 残しておいても意味がない からです。従って、修正した ai8s が 正しく動作するか どうかは、別の方法 で確認する必要があります。

その方法は、ai8s VS ai2 と ai8s VS ai7s の対戦を行い、以前の記事 で行った 同じ組み合わせ の 対戦結果 と比較して成績が ほぼ変わらない ことを 確認する という方法です。

下記は ai2 との対戦です。

ai_match(ai=[ai8s, ai2])

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

ai8s VS ai2
count     win    lose    draw
o        9847      10     143
x        8934     246     820
total   18781     256     963

ratio     win    lose    draw
o       98.5%    0.1%    1.4%
x       89.3%    2.5%    8.2%
total   93.9%    1.3%    4.8%

下記は ai7s との対戦です。

ai_match(ai=[ai8s, ai7s])

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

ai8s VS ai7s
count     win    lose    draw
o        3365     384    6251
x         378    2871    6751
total    3743    3255   13002

ratio     win    lose    draw
o       33.7%    3.8%   62.5%
x        3.8%   28.7%   67.5%
total   18.7%   16.3%   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.5	0.1	1.4	89.3	2.5	8.2	93.9	1.3	4.8
前回の VS `ai7s`	33.4	3.9	62.6	3.9	28.8	67.3	18.7	16.4	65.0
今回の VS `ai7s`	33.7	3.8	62.5	3.8	28.7	67.5	18.7	16.3	65.8

`ai8s` の修正方法その 2

先程の ai8s は、自分の手番 によって 異なる tuple で 判定を行う必要 があるため、プログラム が長く、分かりづらくなる という欠点があります。その原因は、count_marks が返す tuple の要素が「〇 × 空」のように マークを基準 に 数えている のに対し、判定を 行う際 の マークのパターン では「自敵空」のように、マークではなく、誰の手番 であるかを基準に 数えている からです。そのため、この欠点は、count_marks が返す tuple の要素 を、誰の手番 であるかを基準に 数える ように修正することで解消できます。

`count_marks` の修正

count_marks を下記のプログラムのように修正します。

12 行目：直前の手番 のマーク、現在の手番 のマーク、空のマス の順で 数えた数 を要素として持つ tuple を返す ように修正する

「直前の手番 のマーク、現在の手番 のマーク、空のマス」の順番は、上記以外 の順番にしても かまいません が、その場合はこの後で ai8s のプログラムを、その順番 に 合わせて修正 する必要があります。

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

行番号のないプログラム

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]

Marubatsu.count_marks = count_marks

修正箇所

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 == defaultdict:
        return count
    else:
-       return count[Marubatsu.CIRCLE], count[Marubatsu.CROSS], count[Marubatsu.EMPTY]
+       return count[self.last_turn], count[self.turn], count[Marubatsu.EMPTY]


Marubatsu.count_marks = count_marks

`ai8s` の修正

上記の修正 を行うことで、「自 x 敵 y 空 z」という マークのパターン を、常に (x, y, z) という tuple で表現できるようになります。従って、ai8s は、下記のプログラムのように、手番に 関わらず、同じ条件式 で 簡潔に記述 できます。なお、mb は 相手の手番 の局面なので、自分の手番 は、mb の 直前の手番 で表される点に注意して下さい。

13 行目：「自 0 敵 2 空 1」は、常に (0, 2, 1) という tuple で表現 できる
16 行目：「自 2 敵 0 空 1」は、常に (2, 0, 1) という tuple で表現 できる

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

行番号のないプログラム

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:
            return -1
        # 次の自分の手番で自分が勝利できる場合は評価値として 1 を返す
        elif (2, 0, 1) in markpats:
            return 1
        # それ以外の場合は評価値として 0 を返す
        else:
            return 0

    return ai_by_score(mb, eval_func, debug=debug)

修正箇所

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 (mb.turn == Marubatsu.CROSS and (0, 2, 1) in markpats) or \
-          (mb.turn == Marubatsu.CIRCLE and (2, 0, 1) in markpats):
+       if (0, 2, 1) in markpats:
            return -1
        # 次の自分の手番で自分が勝利できる場合は評価値として 1 を返す
-       elif (mb.turn == Marubatsu.CROSS and (2, 0, 1) in markpats) or \
-          (mb.turn == Marubatsu.CIRCLE and (0, 2, 1) in markpats):
+       elif (2, 0, 1) in markpats:
            return 1
        # それ以外の場合は評価値として 0 を返す
        else:
            return 0

    return ai_by_score(mb, eval_func, debug=debug)

動作の確認

先程と同様 に、ai2、ai7s と対戦することで、正しく修正されているか どうかを確認します。まず、ai2 と対戦します。

ai_match(ai=[ai8s, ai2])

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

ai8s VS ai2
count     win    lose    draw
o        9832      11     157
x        8895     245     860
total   18727     256    1017

ratio     win    lose    draw
o       98.3%    0.1%    1.6%
x       88.9%    2.5%    8.6%
total   93.6%    1.3%    5.1%

次に、ai7s と対戦します。

ai_match(ai=[ai8s, ai7s])

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

ai8s VS ai7s
count     win    lose    draw
o        3355     433    6212
x         366    2904    6730
total    3721    3337   12942

ratio     win    lose    draw
o       33.6%    4.3%   62.1%
x        3.7%   29.0%   67.3%
total   18.6%   16.7%   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.3	0.1	1.6	88.9	2.5	8.6	93.6	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.6	4.3	62.1	3.7	29.0	67.3	18.6	16.7	64.7

`ai8s` の処理速度の検証

前回の記事で list を使って ai8s を実装した場合と、set を使って実装した場合の 処理時間 を比較すると説明しました。先程 set で ai8s を実装したので、実際に比較します。

筆者のパソコン では、下記のプログラムで ai8s どうし を対戦すると 約 47.2 秒 かかりました。以前の記事で list を使って実装した ai8s2 どうし の対戦では、約 45.5 秒 かかったので、list と set で ほとんど処理速度 が 変わらない ことが分かります。

ai_match(ai=[ai8s, ai8s])

処理速度 がほとんど 変わらない原因 は、ai8s では、list や set の 要素の数 が 最大で 8 であり、前回の記事で説明したように、list や set の 要素の数 が 10 前後 のような 少ない場合 は、処理速度 に差が ほとんどない からだと思われます。

今回の記事のまとめ

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

また、互換性 という 概念を説明 し、関数や モジュール の 仕様を修正 した際の、互換性の問題 への いくつかの対処法 について説明しました。

次回の記事では、dict を tuple 以外 の ハッシュ可能なオブジェクト に 変換する方法 などについて説明します。

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

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

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

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

次回の記事

indices は、index（インデックス）の 複数形 です ↩
Office 365 という、クラウドの Office 製品は例外です。クラウドと 365 の意味を説明すると長くなるので省略しますが、興味がある方は調べてみると良いでしょう ↩
実際には、"dict" 以外 であれば、キーワード引数の datatype に代入する値に 何を記述しても構いません が、分かりやすさ を重視して "tuple" を記述 しました ↩