目次と前回の記事

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

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

これまでに作成した AI

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

関数名	アルゴリズム
`ai1`	左上から順に空いているマスを探し、最初に見つかったマスに着手する
`ai2`	ランダムなマスに着手する

`ai_match` の改良その 1（勝率などの比率の表示）

前回の記事で作成した、ai_match は、AI どうしの 評価を行うため にはいくつかの 問題点 があるので、今回の記事ではそれらの 問題を解決 するために ai_match を改良します。

ai_match は、〇の勝利数、× の勝利数、引き分け数を表示しますが、それらは、対戦回数 を表す match_num によって 変わる ので、その数から 強さを評価 することは困難です。

対戦の回数に 依存しない 強さの指標として良く使われるのが、勝率などの比率で、それぞれの回数を、対戦回数 で割ることで計算できます。例えば、下記の実行結果のように、対戦の回数が 10000 のような 割り算 を 計算しやすい数字 の場合は、は〇の勝率が 78.2 % であることを、暗算で 簡単に計算 できます。

from ai import ai_match, ai1, ai2

ai_match(ai=[ai1, ai2])

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

o 7820 x 1764 draw 416

一方、下記のプログラムのように match_num が 567 のような、割り算 を 計算しづらい 数値の場合は、〇の勝率などを暗算で計算することは困難です。

ai_match(ai=[ai1, ai2], match_num=567)

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

o 452 x 93 draw 22

`ai_match` の修正

そこで、ai_match を、〇の勝ち数、× の勝ち数、引き分けの数に 加えて、〇の勝率、× の勝率、引き分けの率 という、それぞれの比率を 計算して表示 するように修正することにします。下記はそのような計算を行うように ai_match を修正したプログラムです。

10 行目：回数であることを明確にするために、最初に "count" を表示 する
12 ~ 14 行目：それぞれの比率は、試合数 である match_num で割ることで計算できる。また、比率（ratio）であることを明確にするために、最初に "ratio" を表示 した

 1  from marubatsu import Marubatsu
 2  from collections import defaultdict
 3
 4  def ai_match(ai, match_num=10000):
 5      mb = Marubatsu()
 6      count = defaultdict(int)
 7      for _ in range(match_num):
 8          count[mb.play(ai, verbose=False)] += 1
 9
10      print("count", "o", count[Marubatsu.CIRCLE], "x", count[Marubatsu.CROSS],
11            "draw", count[Marubatsu.DRAW])
12      print("ratio", "o", count[Marubatsu.CIRCLE] / match_num,
13            "x", count[Marubatsu.CROSS] / match_num,
14            "draw", count[Marubatsu.DRAW] / match_num)

行番号のないプログラム

from marubatsu import Marubatsu
from collections import defaultdict

def ai_match(ai, match_num=10000):
    mb = Marubatsu()
    count = defaultdict(int)
    for _ in range(match_num):
        count[mb.play(ai, verbose=False)] += 1

    print("count", "o", count[Marubatsu.CIRCLE], "x", count[Marubatsu.CROSS],
          "draw", count[Marubatsu.DRAW])
    print("ratio", "o", count[Marubatsu.CIRCLE] / match_num,
          "x", count[Marubatsu.CROSS] / match_num,
          "draw", count[Marubatsu.DRAW] / match_num)

修正箇所

from marubatsu import Marubatsu
from collections import defaultdict

def ai_match(ai, match_num=10000):
    mb = Marubatsu()
    count = defaultdict(int)
    for _ in range(match_num):
        count[mb.play(ai, verbose=False)] += 1

-   print("o", count[Marubatsu.CIRCLE], "x", count[Marubatsu.CROSS],
+   print("count", "o", count[Marubatsu.CIRCLE], "x", count[Marubatsu.CROSS],
          "draw", count[Marubatsu.DRAW])
+   print("ratio", "o", count[Marubatsu.CIRCLE] / match_num,
+         "x", count[Marubatsu.CROSS] / match_num,
+         "draw", count[Marubatsu.DRAW] / match_num)

下記のプログラムを実行することで、それぞれの比率が表示されることが確認できます。

ai_match(ai=[ai1, ai2], match_num=567)

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

count o 434 x 107 draw 26
ratio o 0.7654320987654321 x 0.18871252204585537 draw 0.04585537918871252

比率の計算の改良

上記のプログラムでは、それぞれの比率を表示する 9 ~ 11 行目の プログラムの中 でそれぞれの比率を計算していますが、下記のプログラムのように、先にそれぞれの比率を計算しておくことで、9 ~ 11 行目のプログラムが少し わかりやすく、簡潔になります。

7 行目：それぞれの比率を計算して記録するための 空の dict を ratio とという名前の変数に代入する。なお、ratio は、count と 異なり、この後の処理で、値が代入されていないキーを参照 する ことはない ので、defaultdict を 使う必要 はない
8、9 行目：比率は「回数 ÷ 試合数」で計算できるので、count の それぞれ の キーの値 に対してその計算を行い、計算結果 を ratio の 対応するキー に代入する
13、14 行目：ratio を 使って それぞれの 比率を表示 する

 1  def ai_match(ai, match_num=10000):
 2      mb = Marubatsu()
 3      count = defaultdict(int)
 4      for _ in range(match_num):
 5          count[mb.play(ai, verbose=False)] += 1
 6
 7      ratio = {}
 8      for key in count.keys():
 9          ratio[key] = count[key] / match_num
10
11      print("count", "o", count[Marubatsu.CIRCLE], "x", count[Marubatsu.CROSS],
12            "draw", count[Marubatsu.DRAW])
13      print("ratio", "o", ratio[Marubatsu.CIRCLE], "x", ratio[Marubatsu.CROSS],
14            "draw", ratio[Marubatsu.DRAW])

行番号のないプログラム

def ai_match(ai, match_num=10000):
    mb = Marubatsu()
    count = defaultdict(int)
    for _ in range(match_num):
        count[mb.play(ai, verbose=False)] += 1

    ratio = {}
    for key in count.keys():
        ratio[key] = count[key] / match_num

    print("count", "o", count[Marubatsu.CIRCLE], "x", count[Marubatsu.CROSS],
          "draw", count[Marubatsu.DRAW])
    print("ratio", "o", ratio[Marubatsu.CIRCLE], "x", ratio[Marubatsu.CROSS],
          "draw", ratio[Marubatsu.DRAW])

修正箇所

def ai_match(ai, match_num=10000):
    mb = Marubatsu()
    count = defaultdict(int)
    for _ in range(match_num):
        count[mb.play(ai, verbose=False)] += 1

+   ratio = {}
+   for key in count.keys():
+       ratio[key] = count[key] / match_num

    print("count", "o", count[Marubatsu.CIRCLE], "x", count[Marubatsu.CROSS],
          "draw", count[Marubatsu.DRAW])
-   print("ratio", "o", count[Marubatsu.CIRCLE] / match_num,
-         "x", count[Marubatsu.CROSS] / match_num,
-         "draw", count[Marubatsu.DRAW] / match_num)
+   print("ratio", "o", ratio[Marubatsu.CIRCLE], "x", ratio[Marubatsu.CROSS],
+         "draw", ratio[Marubatsu.DRAW])

下記のプログラムを実行することで、正しい表示が行われることが確認できます。実行結果は先ほどと同様なので省略します。

ai_match(ai=[ai1, ai2], match_num=567)

結果を表示する処理の改良

上記のプログラムは、11 ~ 14 行目の print の 実引数の記述 が大変なので改良することにします。前回の記事では、最初は、回数の 集計結果 の表示を、下記のプログラムのように、for 文 を使って表示していました。

for key, value in count.items():
    print(key, value)

しかし、前回の記事の途中から、defaultdict を使って 集計を行う ようにした結果、上記の for 文 を使った場合は、表示の順番 が "o"、"x"、"draw" の 順番にならない場合 があります。先ほどのプログラムで、for 文 を 使わず に 集計結果を表示 したのは そのため です。

for 文 を使った場合でも、表示の順番 を固定したい場合は、下記のプログラムのように、表示の順番 を 表す list を作成し、その list を使って 繰り返しの処理 を行います。

15 行目：表示する count の キーの順番（order）を表す list を order_list に代入する
18 行目：これから回数を表示することを明確にするために、"count" を表示 する
19、20行目：for 文 と order_list を使って 繰り返し処理 を行うことで、order_list の キーの順番 で、count のキーと、キーの値 を表示する
22 ~ 24 行目：比率の表示を、18 ~ 20 行目と 同様の方法 で行う

なお、プログラムが長くなってわかりづらくなってきたのでコメントを追加しました。

 1  def ai_match(ai, match_num=10000):
 2      mb = Marubatsu()
 3
 4      # ai[0] VS ai[1] の対戦を match_num 回行い、通算成績を数える
 5      count = defaultdict(int)
 6      for _ in range(match_num):
 7          count[mb.play(ai, verbose=False)] += 1
 8
 9      # それぞれの比率を計算し、ratio に代入する
10      ratio = {}
11      for key in count.keys():
12          ratio[key] = count[key] / match_num
13
14      # 〇の勝利、×の勝利、引き分けの順番で表示することを表す list 
15      order_list = [Marubatsu.CIRCLE, Marubatsu.CROSS, Marubatsu.DRAW]
16
17      # 通算成績の回数の表示
18      print("count")
19      for key in order_list:
20          print(key, count[key])
21      # 通算成績の比率の表示
22      print("ratio")
23      for key in order_list:
24          print(key, ratio[key])

行番号のないプログラム

def ai_match(ai, match_num=10000):
    mb = Marubatsu()

    # ai[0] VS ai[1] の対戦を match_num 回行い、通算成績を数える
    count = defaultdict(int)
    for _ in range(match_num):
        count[mb.play(ai, verbose=False)] += 1

    # それぞれの比率を計算し、ratio に代入する
    ratio = {}
    for key in count.keys():
        ratio[key] = count[key] / match_num

    # 〇の勝利、×の勝利、引き分けの順番で表示することを表す list 
    order_list = [Marubatsu.CIRCLE, Marubatsu.CROSS, Marubatsu.DRAW]

    # 通算成績の回数の表示
    print("count")
    for key in order_list:
        print(key, count[key])
    # 通算成績の比率の表示
    print("ratio")
    for key in order_list:
        print(key, ratio[key])

修正箇所

def ai_match(ai, match_num=10000):
    mb = Marubatsu()

    # ai[0] VS ai[1] の対戦を match_num 回行い、通算成績を数える
    count = defaultdict(int)
    for _ in range(match_num):
        count[mb.play(ai, verbose=False)] += 1

    # それぞれの比率を計算し、ratio に代入する
    ratio = {}
    for key in count.keys():
        ratio[key] = count[key] / match_num

    # 〇の勝利、×の勝利、引き分けの順番で表示することを表す list 
+   order_list = [Marubatsu.CIRCLE, Marubatsu.CROSS, Marubatsu.DRAW]

    # 通算成績の回数の表示
-   print("count", "o", count[Marubatsu.CIRCLE], "x", count[Marubatsu.CROSS],
-         "draw", count[Marubatsu.DRAW])
+   print("count")
+   for key in order_list:
+       print(key, count[key])
    # 通算成績の比率の表示
-   print("ratio", "o", ratio[Marubatsu.CIRCLE], "x", ratio[Marubatsu.CROSS],
-         "draw", ratio[Marubatsu.DRAW])+   print("count")
+   print("ratio")
+   for key in order_list:
+        print(key, ratio[key])

下記のプログラムを実行し、表示内容を確認すると、それぞれの print で改行が 行われてしまう という問題があることが判明します。

ai_match(ai=[ai1, ai2], match_num=567)

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

count
o 442
x 90
draw 35
ratio
o 0.7795414462081128
x 0.15873015873015872
draw 0.06172839506172839

表示の修正その 1

この問題は、print で 改行を行わない ようにすれば良いので、以前の記事で説明したように、下記のプログラムの 3、5、7、9 行目の print の 実引数 に end="" を記述します。

1  def ai_match(ai, match_num=10000):
元と同じなので省略
2      # 通算成績の回数の表示
3      print("count", end="")
4      for key in order_list:
5          print(key, count[key], end="")
6      # 通算成績の比率の表示
7      print("ratio", end="")
8      for key in order_list:
9          print(key, ratio[key], end="")

行番号のないプログラム

def ai_match(ai, match_num=10000):
    mb = Marubatsu()

    # ai[0] VS ai[1] の対戦を match_num 回行い、通算成績を数える
    count = defaultdict(int)
    for _ in range(match_num):
        count[mb.play(ai, verbose=False)] += 1

    # それぞれの比率を計算し、ratio に代入する
    ratio = {}
    for key in count.keys():
        ratio[key] = count[key] / match_num

    # 〇の勝利、×の勝利、引き分けの順番で表示することを表す list 
    order_list = [Marubatsu.CIRCLE, Marubatsu.CROSS, Marubatsu.DRAW]

    # 通算成績の回数の表示
    print("count", end="")
    for key in order_list:
        print(key, count[key], end="")
    # 通算成績の比率の表示
    print("ratio", end="")
    for key in order_list:
        print(key, ratio[key], end="")

修正箇所

def ai_match(ai, match_num=10000):
元と同じなので省略
    # 通算成績の回数の表示
-   print("count")
+   print("count", end="")
    for key in order_list:
-       print(key, count[key])
+       print(key, count[key], end="")
    # 通算成績の比率の表示
-   print("ratio")
+   print("ratio", end="")
    for key in order_list:
-       print(key, ratio[key])
+       print(key, ratio[key], end="")

下記のプログラムを実行し、表示内容を確認すると、今度は、「"o" などの キーの表示 と、その前の表示 が くっついて表示 される」、「ratio の直前 で 改行されない」という 2 つの問題があることが判明します。

ai_match(ai=[ai1, ai2], match_num=567)

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

counto 430x 114draw 23ratioo 0.7583774250440917x 0.20105820105820105draw 0.04056437389770723

表示の修正その 2

この問題を解決するためには、適切な場所 に改行と 半角の空白 を入れる必要があります。その方法は 1 つではありませんが、本記事では下記のプログラムのように修正します。

5, 10 行目：print の 最初の実引数 に "" を記述することで、2 つ目の実引数のキーを 表示する前 に 半角の空白文字 を表示するようにする。これは、print に複数の 実引数 を記述すると、間に 半角の空白文字 を表示するという 性質を利用 している
6 行目：print() を記述することで、"ratio" の表示の 直前で改行 する。なお、6、8 行目 は、以前の記事で説明した、改行を表す \n という エスケープシーケンス を使って、print("\nratio") のように 1 行 に まとめて記述 することもできる

 1  def ai_match(ai, match_num=10000):
元と同じなので省略
 2      # 通算成績の回数の表示
 3      print("count", end="")
 4      for key in order_list:
 5          print("", key, count[key], end="")
 6      print()
 7      # 通算成績の比率の表示
 8      print("ratio", end="")
 9      for key in order_list:
10          print("", key, ratio[key], end="")

行番号のないプログラム

def ai_match(ai, match_num=10000):
    mb = Marubatsu()

    # ai[0] VS ai[1] の対戦を match_num 回行い、通算成績を数える
    count = defaultdict(int)
    for _ in range(match_num):
        count[mb.play(ai, verbose=False)] += 1

    # それぞれの比率を計算し、ratio に代入する
    ratio = {}
    for key in count.keys():
        ratio[key] = count[key] / match_num

    # 〇の勝利、×の勝利、引き分けの順番で表示することを表す list 
    order_list = [Marubatsu.CIRCLE, Marubatsu.CROSS, Marubatsu.DRAW]

    # 通算成績の回数の表示
    print("count", end="")
    for key in order_list:
        print("", key, count[key], end="")
    print()
    # 通算成績の比率の表示
    print("ratio", end="")
    for key in order_list:
        print("", key, ratio[key], end="")

修正箇所

def ai_match(ai, match_num=10000):
元と同じなので省略
    # 通算成績の回数の表示
    print("count", end="")
    for key in order_list:
-       print(key, count[key], end="")
+       print("", key, count[key], end="")
+   print()
    # 通算成績の比率の表示
    print("ratio", end="")
    for key in order_list:
-       print(key, ratio[key], end="")
+       print("", key, ratio[key], end="")

下記のプログラムを実行することで、今度は 意図通り に表示されることが確認できます。

ai_match(ai=[ai1, ai2], match_num=567)

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

count o 452 x 95 draw 20
ratio o 0.7971781305114638 x 0.1675485008818342 draw 0.03527336860670194

上記の 修正作業 は、以前の記事で紹介した、ゲーム盤の表示 を行う 関数を定義 する際に行った作業に 似ている のではないかと思った人がいるかもしれませんが、その通り です。

以前の記事で紹介したのと 同じような内容 をここで もう一度説明 したのは、画面に 文字を表示 するプログラムは、一回で 思い通り に 表示できない ことが多いためで、このような 修正の手順 をなるべく多く 体験しておく ことが重要だと思ったからです。

数値型のデータの種類

前回までの記事のプログラムでは、基本的には数値として、整数のみ 扱ってきましたが、今回の記事で、比率のような、小数点以下 の数値を 含む数値 を扱ったので、数値型 のデータの種類について 簡単に紹介 します。

Python には、数値を扱う 主な データ型 として 整数型（int）、浮動小数点数型（float）、複素数型（complex）の 3 つがあります。括弧の中 の英語は、それぞれの データ型 の Python での 正式な名称 で、その 名前と同じ組み込みクラス が定義されています。なお、このうちの複素数型は、本記事では利用する予定はないので説明は省略します。

数値を扱うデータ型の詳細については、下記のリンク先を参照して下さい。

整数型（int）

整数型 は、文字通り 整数のみを扱う データ型です。他の多くのプログラム言語では、整数型のデータで扱える数値の範囲が限られていますが、Python の数値型 のデータは、扱える 整数の範囲 に 制限はありません。

浮動小数点数型（float）

浮動小数点数型 は、小数点以下 を含む数値や、指数を使って表現¹された数値を扱うデータ型です。浮動小数点数は、仮数部 と呼ばれる、特定の桁数の数値 と、指数部 と呼ばれる、小数点の位置 を どれだけずらすか を表す 2 つのデータ から構成されます。指数部 を使って 小数点の位置 が浮動（移動）するので、浮動小数点数 と呼ばれます。

浮動小数点数型 の数値は、整数型と異なり、特定の桁数まで しか 数値を表現 することは できません。例えば、1 / 3 を 10 進数で表記すると、0.3333333・・・ のように、小数点以下 に 3 が 無限に続く数値 になりますが、無限に続く数値 をコンピューターで扱うことは 不可能 なので、下記のプログラムのように、1 / 3 を計算すると、特定の桁数まで しか数値が表示されません。数値を 何桁の数字 で表現するかを精度と呼びます。

print(1 / 3)

実行結果

0.3333333333333333

浮動小数点数 には精度があるので、1 / 3 のような、精度を超える ような 桁数の数値 を 正確に表現 することは できません。浮動小数点数 が表す数値と、本当の数値 の間の差の事を誤差と呼びます。コンピューター が行う数値計算のうち、特に、割り切れない割り算 を行うものや、浮動小数点数を扱う ものなどには、誤差がつきもの です。そのため、厳密な計算 を行いたい場合は、誤差の事を 考慮する必要 があります。

浮動小数点数 は、少々難しい概念 なので、上記の説明では意味が分からない人も多いのではないかと思います。ただし、厳密な数値計算 を行う際には、浮動小数点数 の 正確な知識 が必要となりますが、ai_match で計算する比率の計算では、厳密な数値計算 を 行う必要はない ので、現時点 では、単に 小数点以下を含む数値 を扱う データ型 であることだけを理解しておけばよいでしょう。より詳細な説明は、必要になった時点で行う予定です。

参考までに、浮動小数点数の Wikipedia のリンクを下記に記します。

整数型と浮動小数点数型どうしの計算

Python では、整数型 と 浮動小数点数型 のデータに対して、四則演算などの 多くの演算 を、データ型 を 意識することなく行う ことができます。また、その際の 計算結果 の データ型 は、原則として以下の表のようになります。なお、下記の表は あくまで原則 なので、下記の表とは 異なるデータ型 になる 場合がある 点に注意して下さい。

	計算結果のデータ型
int と int で計算結果が整数の場合	int
int と int で計算結果が整数でない場合	float
int と float	float
float と int	float
float と float	float

下記のプログラムは上記の演算の具体例です。なお、下記のプログラムでは、データ型 を調べるために、以前の記事で紹介した、type という組み込み関数を利用しています。

print(type(1 + 1))
print(type(1 / 2))
print(type(1 + 1.5))
print(type(1.5 + 1))
print(type(1.5 + 1.7))
print(type(1.5 * 2))   # 答えが整数であっても float になる
print(type(1.5 + 1.5)) # 答えが整数であっても float になる

実行結果

<class 'int'>
<class 'float'>
<class 'float'>
<class 'float'>
<class 'float'>
<class 'float'>
<class 'float'>

上記で、整数型と浮動小数点数型の計算結果のデータ型について説明しましたが、実際には、ほとんどの場合 で、数値の計算 を行う際に、計算を行う数値 と、計算結果の数値 の データ型 を 意識する必要 は ありません。

本記事で、これまで 整数型 と 浮動小数点数型 を 区別せず に、数値型 と記述してきたのは、このことが理由です。今後も 区別する必要がない 場合は、整数型 という 表記を続ける ことにします。ただし、整数型 と 浮動小数点型 の違いを 意識しない と、意図しない計算 が行われたり、エラーが発生 する場合があるので、そのような場合 は、整数型 と 浮動小数点数型 を 区別して表記 します。

`ai_match` の改良その 2（比率の表示の改良）

先程のプログラムでは、比率が 0.7971781305114638 のような、小数点以下 10 桁以上の数値で表示されますが、AI の 強さを測る ためには、小数点以下第 4 桁 を 四捨五入 した、0.797 程度の精度の数値が表示されれば十分です。また、0.797 よりも、79.7% のような、%（百分率） で表示したほうが わかりやすい でしょう。

先程、「ai_match で計算する比率の計算では、厳密な数値計算 を 行う必要はない」と説明したのは、上記のように、計算された 比率を表す数値 のうち、小数点以下第 4 桁 までしか 利用しない ためです。

書式と書式フォーマット済文字列リテラル

「数値型の データ を、小数点以下第 3 桁まで表示 する」のように、データ を 特定の形式 の 文字列に変換 する際の、形式の事を書式（format）と呼びます。書式は「文字列型 のデータを 5 文字 で 右揃え で表示する」など、任意の データ型 に対して設定できます。

Python では、書式フォーマット済文字列リテラル という 記述方法 で、指定したデータ を、指定した書式 の 文字列 に変換することができます。また、書式フォーマット済文字列リテラルは、複数のデータ を まとめて文字列 に変換する処理を、簡潔に 分かりやすく記述 することが できる ので、実際に 良く使われます。

書式フォーマット済文字列リテラルの詳細については、下記のリンク先を参照して下さい。

「フォーマット済文字リテラル」という表記は長いので、「f 文字列」や「f-string」と呼ぶ場合が多いようです。以後は、「f 文字列」と表記することにします。

print を使った方法の問題点

f 文字列 を説明する前に、これまでのプログラム利用してきた、複数のデータ を まとめて一度で表示 する方法の欠点について説明します。

これまでのプログラムでは、複数のデータ を まとめて一度 で表示する際に、print の 実引数 に、それぞれ の データを記述 していました。例えば、先程のプログラムでは、下記のように、print の 実引数 に、""、key、data[key] の 3 つ のデータを記述しています。

print("", key, data[key], end="")

この方法の欠点の一つは、print が それぞれ の 実引数 を表示する際に、間に 半角の空白文字 を 必ず表示 してしまう点にあります。上記の場合は、間に空白文字を記述したほうが良いので問題ありませんが、間に 半角の空白文字 を 表示したくない 場合は print の実引数にそれぞれのデータを記述するという方法は 利用できません。

他には、この方法では表示するデータの書式を 指定できない という欠点があります。

文字列の連結の問題点

複数の データ を、間に 空白を開けず に 文字列に変換 する方法として、文字列 を + 演算子 で連結するという方法がありますが、この方法にも いくつかの欠点 があります。

欠点の一つは、下記のプログラムのように、文字列型 のデータと、数値型 のデータを + 演算子 で連結すると、エラーが発生 するという点です。

applenum = 5
applevalue = 100
text = applenum + "個のりんごの値段は" + applenum * applevalue + "円です"
print(text)

実行結果

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[15], line 3
      1 applenum = 5
      2 applevalue = 100
----> 3 text = applenum + "個のりんごの値段は" + applenum * applevalue + "円です"
      4 print(text)

TypeError: unsupported operand type(s) for +: 'int' and 'str'

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

TypeError
データ型（Type）に関するエラー
can only concatenate str (not "int") to str
文字列型（str）には（to）、整数型（"int"）ではなく、文字列型（str）しか（only）結合（concatenate）できない（can）

エラーが発生しないようにするためには、下記のプログラムのように、組み込み関数 str を使って、文字列型 のデータに 変換してから結合 する必要がありますが、これは面倒です。

applenum = 5
applevalue = 100
text = str(applenum) + "個のりんごの値段は" + str(applenum * applevalue) + "円です"
print(text)

実行結果

5個のりんごの値段は500円です

また、+ 演算子 を使った結合には、他にも以下のような欠点があります。

プログラムが 長くなる ので わかりづらくなる
多くの 文字列 を結合する場合は、" を 数多く記述 する必要（上記では 4 つ " が記述されている）があり、どの " と " が ペアであるか が わかりづらくなる
データの書式を 指定できない

フォーマット済文字列リテラル（f 文字列）

上記の 問題点 は、f 文字列 を利用することで改善できます。

f 文字列 は、文字列 を囲う " や ' などの 記号の直前 に f を記述する 文字列のリテラル で、その中 に 任意の数 だけ {式} を記述することが できます。

f 文字列 の 中に記述 された {式} は、式の 計算結果 を表す 文字列 に 置き換え られます。例えば、先程のプログラムは、下記のように記述できます。

実行結果からわかるように、3 行目の {applenum} が "5" に、{applenum * applevalue} が、5 * 100 の 計算結果 である "500" という 文字列 に 置き換え られます。

applenum = 5
applevalue = 100
text = f"{applenum}個のりんごの値段は{applenum * applevalue}円です"
print(text)

実行結果

5個のりんごの値段は500円です

+ 演算子 で 文字列 を連結する下記のプログラム比較して、f 文字列 を利用した上記のプログラムには以下の利点があります。

text = str(applenum) + "個のりんごの値段は" + str(applenum * applevalue) + "円です"

str を 使って、数値型のデータを文字列に変換する 必要がない
" は、文字列全体を囲う 2 箇所だけ に 記述すれば良い
+ を使った式より 簡潔に記述 でき、プログラムの意味が 分かりやすくなる

書式指定

f 文字列 では、{} の中 の 式の直後 に、下記のように記述することで、{} の中の 式の計算結果 を表す 文字列 の書式を指定することができます。

{式:書式指定}

書式指定 には、様々な指定 を行うことができますが、本記事ではその中で 良く使われるもの を紹介します。他の書式指定について知りたい方は、下記のリンク先を参照して下さい。

本記事では、下記に関する書式指定の記述方法を紹介します。

揃え、符号、文字幅、精度、表現型

書式指定の記述は、以下の方法で行います。

書式指定の 種類ごと に 決められたルール で記述する
複数の種類 の 書式指定 を記述する場合は、間を空けず に、上記の順番 で記述する
それぞれ の種類の 書式指定 は省略することが できる。省略した場合は、それぞれの種類によって、決められた 規定値が指定 がされたものと みなされる

揃え

下記の指定を行うことができます。文字幅の中 での 揃えを指定 するので、多くの場合 は、後述の 文字幅を指定しない と 意味がない 指定になります。

揃えを行う際に、文字数が足りない部分 には、半角の空白文字 が挿入されます。

記号	意味
`<`	文字幅の中で、左揃えで文字列を生成するほとんどのデータ型は、揃えを指定しない場合は左揃えになる
`>`	文字幅の中で、右揃えで文字列を生成する数値型などの、一部のデータは、揃えを指定しない場合は右揃えになる
`^`	文字幅の中で、中央揃えで文字列を生成する

下記は、揃えを指定 したプログラムの例です。なお、下記の例では、揃えは文字幅を指定しないと意味をなさないので、後述の方法で 文字幅 を 9 に指定 しています。

applenum = 5
applevalue = 100
name = "りんご"
print(f"{name:<9}の値段は{applenum * applevalue:<9}円です") # りんご、値段を左揃えで表示
print(f"{name:>9}の値段の{applenum * applevalue:>9}円です") # りんご、値段を右揃えで表示
print(f"{name:^9}の値段の{applenum * applevalue:^9}円です") # りんご、値段を中央揃えで表示
# 揃えを指定しないと文字列型は左揃え、数値型は右揃えになる
print(f"{name:9}の値段の{applenum * applevalue:9}円です")

実行結果

りんご      の値段は500      円です
      りんごの値段の      500円です
   りんご   の値段の   500   円です
りんご      の値段の      500円です

符号

下記の指定を行うことで、数値型 のデータを 文字列型 のデータに変換する際に、符号を 入れるかどうか を指定できます。

記号	意味
`+`	正の数でも、負の数でも、0 でも、必ず符号を入れるようになる
`-`	負の数の場合のみ、符号を入れる符号の指定を記述しない場合は、この指定になる

下記は、符号を指定したプログラムの例です。

plusnum = 100
minusnum = -100
print(f"{plusnum}")    # 符号を指定しない場合は、負の数のみ符号が表示される
print(f"{minusnum}") 
print(f"{plusnum:+}")  # 符号として + を指定した場合は、常に符号が表示される
print(f"{minusnum:+}") 
print(f"{plusnum:-}")  # 符号として - を指定した場合は、負の数のみ符号が表示される
print(f"{minusnum:-}") # （符号を指定しない場合と同じになる）

実行結果

なお、下記のプログラムのように、数値型以外 のデータに対して 符号を記述 すると エラーが発生 します。

name = "りんご"
print(f"{name:+}")

実行結果

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[20], line 2
      1 name = "りんご"
----> 2 print(f"{name:+}")

ValueError: Sign not allowed in string format specifier

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

ValueError
値（value）に関するエラー
Sign not allowed in string format specifier
符号（Sing）は、文字列型（string）の書式（format）指定（specifier）として利用することはできない（not allowed in）

文字幅

文字列に変換 した際の、文字列の長さ の 最小値 を 整数で指定 します。文字幅を 指定しなかった場合 は文字列に変換した際の長さは 変化しません。

文字列に変換 した際に、変換した 文字列の長さ が、指定された 文字幅より短い 場合は、揃えの指定 に従って 文字列の配置 が決められ、足りない部分 の文字には 半角の空白文字 が挿入されます。文字幅の指定の 具体例 については前述の 揃えの所 を見て下さい。後述の 精度を指定した場合 の文字幅の指定の 具体例 は、次の 精度の所 を見て下さい。

なお、変換した 文字列の長さ が、指定した文字幅 より 長い場合 に、指定した文字幅に文字列が 切り詰められる ことは ありません。下記のプログラムのように、6 文字 の 文字列 が代入された name に対して、文字幅 を 3 に指定 しても、文字列が すべて表示 されます。

name = "りんごは赤い"
print(f"{name:3}")

実行結果

りんごは赤い

文字列の長さ を、指定した文字数 で 切り詰めたい 場合は、次の 精度で指定 します。

精度

精度の指定 は、数値型 のデータと 文字列型 のデータによって行う 処理が異なります。

数値型のデータの場合

精度は 浮動小数点数型（float）のデータに対して 設定できます が、後述で示すように、数値型 のデータに対して 精度を設定 すると エラーが発生 します。ただし、これも後述しますが、表現型の f を設定することで、整数型 に対しても 精度を設定 することが できます。

式の計算結果 が 浮動小数点数型（float）のデータの場合は、半角のピリオド . の直後 に 整数を記述 することで、文字列に変換した際の 小数点以下 の 桁数を指定 することができます。その際に、指定した 小数点以下 の 次の桁の数 で 四捨五入 を行います。精度を省略 した場合は、四捨五入は行われず、すべての桁数 が 文字列に変換 されます。

下記は、割り切れない 1 / 7 に対して、さまざまな精度 を指定したプログラムの例です。下記の 4 行目の 10.5 のように 文字幅 と精度の 両方を指定 した場合、見た目 から、整数の部分 の桁数が 10 桁、小数点以下 の桁数が 5 桁 のように 見えるかもしれません が、実際には 10 は 全体の文字列の長さ を表す点に 注意して下さい。

num = 1 / 7
print(f"1 / 7 = {num}です")        # 何も指定しない場合は、すべての桁数が表示される
print(f"1 / 7 = {num:.5}です")     # 小数点以下 5 桁まで表示する
print(f"1 / 7 = {num:10.5}です")   # 10 文字で、右揃えで小数点以下 5 桁まで表示する
print(f"1 / 7 = {num:<10.5}です")  # 10 文字で、左揃えで小数点以下 5 桁まで表示する
print(f"1 / 7 = {num:+10.5}です")  # 10 文字で、符号付きで小数点以下 5 桁まで表示する

実行結果

1 / 7 = 0.14285714285714285です
1 / 7 = 0.14286です
1 / 7 =    0.14286です
1 / 7 = 0.14286   です
1 / 7 =   +0.14286です

精度を指定 しても、必ず小数点以下に 指定した桁数 の 数字が埋められる わけでは ありません。例えば、下記のプログラムのように、1.1 に対して、精度に 3 を指定 しても、"1.1" という 文字列に変換 されます。1.1 を "1.100" のように、小数点以下 3 桁まで に 数字が記述 された 文字列に変換 したい場合は、後述の 表現型の f を指定します。

a = 1.1
print(f"a = {a:.3}")

実行結果

a = 1.1

整数型 のデータに対して、精度を指定 すると、下記のプログラムのように エラーが発生 します。整数型 のデータに対して 精度を指定する 場合は、後述の 表現型の f を指定します。

num = 10
print(f"{num:3.1}")

実行結果

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[24], line 2
      1 num = 10
----> 2 print(f"{num:3.1}")

ValueError: Precision not allowed in integer format specifier

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

ValueError
値（value）に関するエラー
Precision not allowed in integer format specifier
精度（Precision）は、整数型（integer）の書式（format）指定（specifier）として利用することはできない（not allowed in）

文字列型のデータの場合

文字列型 のデータに対して 精度を指定 すると、文字列の最大長 を指定したことになります。文字列の長さ が 精度より も長い場合は、先頭から精度分 の長さの 文字列 に 切り詰め られます。下記のプログラムは、文字列型 のデータに対して 精度を指定 した例です。

name = "りんごは赤い"
print(f"{name:.3}です")  # 先頭の 3 文字が表示される
print(f"{name:7.3}です") # 先頭の 3 文字が取り出され、7 文字の文字列として左揃えで表示される

実行結果

りんごです
りんご    です

表現型

データを 文字列 として、どのように表現 するかを、1 文字 の 半角のアルファベット で指定します。下記の表は 主な表現型 の一覧です。表の 利用可能なデータ型以外 のデータに対して 表現型を指定 すると、エラーが発生 します。

表現型	意味	利用可能なデータ型
s	文字列として表現する文字列に指定できる表現型はこれだけなので、一般的には省略する	文字列型
d	10 進数の整数として表現する	整数型
b	2 進数の整数として表現する	整数型
x	16 進数の整数として表現する	整数型
f	固定小数点数として表現する詳細は下記を参照	整数型浮動小数点数型
%	f と同じだが、百分率（100 倍して % を表記する）で表記する	整数型浮動小数点数型
e	指数表記	整数型浮動小数点数型
g	汎用表記数値の値によって、f と g を自動的に使い分ける	整数型浮動小数点数型

以下、いくつかの表現型の補足と 使用例 を記述します。

d、b、x

下記のプログラムのように、それぞれ、整数を 10 進数、2 進数、16 進数 として 文字列で表現 します。2 進数と 16 進数の意味については話が長くなるので省略します。

num = 100
print(f"{num:d} は 2 進数では {num:b}、16 進数では {num:x} と表記する")

実行結果

100 は 2 進数では 1100100、16 進数では 64 と表記する

f

数値を、固定小数点数 という表記の文字列に変換します。

固定小数点数 とは、数値を表現する際に、小数点 の 位置を固定 して表現する方法で、小数点以下 の桁数は、必ず精度で指定した数 だけ表記されます。f は 整数型 と、浮動小数点数型 の両方の データ型 を 固定小数点数 の表記に変換することが できます。なお、精度の指定 を省略した場合は、精度に 6 が指定 されたものと みなされます。

下記は、整数型 と 浮動小数点数型 のデータに対して、表現型 と、精度に さまざまな指定 して表示するプログラムで、以下の点に注目して下さい。

先ほどの場合と異なり、3 行目で 表現型 に f を指定 することで、整数型 のデータに対して 精度を指定 しても エラーは発生しない
同じ num2 という 浮動小数点数型 の数値に対して、4 行目の精度と 表現型 に f を指定 した場合と、5 行目の 精度のみを指定 した場合の 表示が異なる
6 行目のように、精度を省略 して 表現型 に f だけを記述 した場合は、7 行目のように、精度に 6 を指 した場合と 同じ文字列 に変換される

1  num1 = 1
2  num2 = 1.1
3  print(f"{num1:.3f}")  # 整数型に対して精度と f を指定した場合
4  print(f"{num2:.3f}")  # 浮動小数点数型に対して精度と f を指定した場合
5  print(f"{num2:.3}")   # 浮動小数点数型に対して精度のみを指定した場合
6  print(f"{num1:f}")    # 精度を省略した場合は、6 が指定されたものとみなされる
7  print(f"{num1:.6f}")  # 実際に精度に 6 を指定した場合。上記と同じ表示になる

行番号のないプログラム

num1 = 1
num2 = 1.1
print(f"{num1:.3f}")  # 整数型に対して精度と f を指定した場合
print(f"{num2:.3f}")  # 浮動小数点数型に対して精度と f を指定した場合
print(f"{num2:.3}")   # 浮動小数点数型に対して精度のみを指定した場合
print(f"{num1:f}")    # 精度を省略した場合は、6 が指定されたものとみなされる
print(f"{num1:.6f}")  # 実際に精度に 6 を指定した場合。上記と同じ表示になる

実行結果

一般的 に、数値型 のデータに対して 精度を指定 して表示する場合は、指定した桁数 を 必ず表示したい 場合が多いので、精度と f は セットで記述 することが多いと思います。

%

% は、数値を 百分率で表示 したい場合に指定します。数値を 100 倍 して、最後に % を表記 する点を除けば、f と同じ です。具体例は、ai_match を修正する際に示します。

e

数値を、指数表記 という形式の文字列に変換します。

10000000000 や、0.0000000001 のような、非常に大きな 数値や、0 に非常に近い 数値などを そのまま表記 すると長く、わかりづらい ので、指数表記 が良く 使われます。

指数表記 は、1e10 のように、数値の後に e と整数を表記し、e の前 の数値の 小数点 を、e の後 の 数値の数 だけ 右に移動 した数値であるという意味を持ちます。e の前 に表記する数値を 仮数部、e の後 に表記する整数を 指数部 と呼びます。

指数表記 で表記された数値は、下記の式 で表すことができます。

仮数部e指数部 = $仮数部 × 10^{指数部}$

指数表記を指定 した際に、精度の指定 を行うと、仮数部の表記 に適用されます。また、精度の指定 を省略すると、f と同様 に、精度に 6 が指定されたものとみなされます。

また、指数表記 で数値を 文字列に変換 する際に、指数部 が 正の整数 の場合は、正であること を 明確にする ために、+ が記述 されます。

下記は、10000000000 と 0.0000000001 を 指数表記 で表示するプログラムです。

num1 = 10000000000
num2 = 0.0000000001
print(f"{num1} の指数表記は {num1:.0e}") # 仮数部の小数点以下の表示を行わない指数表記
print(f"{num2} の指数表記は {num2:.0e}")
print(f"{num1} の指数表記は {num1:e}")   # 精度の指定を省略した場合
print(f"{num2} の指数表記は {num2:e}")

実行結果

10000000000 の指数表記は 1e+10
1e-10 の指数表記は 1e-10
10000000000 の指数表記は 1.000000e+10
1e-10 の指数表記は 1.000000e-10

g

数値を、汎用表記 という形式の文字列に変換します。

ただし、汎用表記 の表記の ルールは複雑 なので、説明は省略します。興味がある方は、下記のリンク先を下にスクロールした先にある、「利用可能な float と Decimal の表現型は以下です」の下にある表の、g の項目の説明を参照して下さい。

`ai_match` の修正

下記は、f 文字列 で ai_match を修正したプログラムです。

5、10 行目：f 文字列 を使って、キーと回数や比率を表示するように修正する。10 行目の比率の方は、書式指定 で、精度に 1、表現型に % を指定することで、百分率 で、小数点以下 1 桁まで表示 するようにする

 1  def ai_match(ai, match_num=10000):
元と同じなので省略
 2      # 通算成績の回数の表示
 3      print("count", end="")
 4      for key in order_list:
 5          print(f" {key} {count[key]}", end="")
 6      print()
 7      # 通算成績の比率の表示
 8      print("ratio", end="")
 9      for key in order_list:
10          print(f" {key} {ratio[key]:.1%}", end="")

行番号のないプログラム

def ai_match(ai, match_num=10000):
    mb = Marubatsu()

    # ai[0] VS ai[1] の対戦を match_num 回行い、通算成績を数える
    count = defaultdict(int)
    for _ in range(match_num):
        count[mb.play(ai, verbose=False)] += 1

    # それぞれの比率を計算し、ratio に代入する
    ratio = {}
    for key in count.keys():
        ratio[key] = count[key] / match_num

    # 〇の勝利、×の勝利、引き分けの順番で表示することを表す list 
    order_list = [Marubatsu.CIRCLE, Marubatsu.CROSS, Marubatsu.DRAW]

    # 通算成績の回数の表示
    print("count", end="")
    for key in order_list:
        print(f" {key} {count[key]}", end="")
    print()
    # 通算成績の比率の表示
    print("ratio", end="")
    for key in order_list:
        print(f" {key} {ratio[key]:.1%}", end="")

修正箇所

def ai_match(ai, match_num=10000):
元と同じなので省略
    # 通算成績の回数の表示
    print("count", end="")
    for key in order_list:
-       print("", key, count[key], end="")
+       print(f" {key} {count[key]}", end="")
    print()
    # 通算成績の比率の表示
    print("ratio", end="")
    for key in order_list:
-       print("", key, ratio[key], end="")
+       print(f" {key} {ratio[key]:.1%}", end="")

下記のプログラムを実行することで、比率が 百分率 で、小数点以下 1 桁 の数値で表示されることが確認できます。

ai_match(ai=[ai1, ai2], match_num=567)

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

count o 440 x 101 draw 26
ratio o 77.6% x 17.8% draw 4.6%

f 文字列を使わない方法

f 文字列 は、Python の バージョン 3.6 から利用できる ようになったものなので、それ以前 のバージョンでは、文字列 の format メソッド を使って 書式を指定 していました。そのため、それ以前のバージョン で記述された 書式指定 のプログラムを 理解するため には、format メソッド の 利用方法 について理解する必要があります。format メソッドの詳細について興味がある方は、下記のリンク先を参照して下さい。

なお、format メソッドより、f 文字列 のほうが 便利で分かりやすい ので、3.6 以降 のバージョンで format メソッド を 利用する必要 は 全くありません。

`ai_match` の改良その 3（回数と比率の処理をまとめる）

下記は、ai_match の、回数と比率の表示を行う部分です。2 ~ 5 行目 と、7 ~ 9 行目 の部分が良く似ているので、for 文 による 繰り返し処理 で まとめる ことができます。

for 文 によって処理を まとめるため には、2 ~ 5 行目 と、7 ~ 9 行目 の処理の 異なる部分 を 調べる必要 があるので、異なる部分が何であるかについて少し考えてみて下さい。

1  # 通算成績の回数の表示
2  print("count", end="")
3  for key in order_list:
4      print(f" {key} {count[key]}", end="")
5  print()
6  # 通算成績の比率の表示
7  print("ratio", end="")
8  for key in order_list:
9      print(f" {key} {ratio[key]:.1%}", end="")

2 ~ 5 行目と、7 ~ 9 行目の違いは以下の通りです。

2、7 行目 の 表示内容
5 行目 の print() が 9 行目の後 に 存在しない
4、9 行目 の count と ratio
9 行目 の ratio[key] の 書式指定 の .1% が 4 行目 には 存在しない

2 番目の違いの解消

上記の違いのうちの、2 番目の「5 行目 の print() が 9 行目の後 に 存在しない」という違いは、下記のプログラムのように、10 行目 に print() を追加 することで 簡単に解消 することができます。また、10 行目に print() を追加 しても、最後に空行が表示されるだけ なので、表示内容 に 大きな影響を与えない ので、下記のように修正することにします。

 1  # 通算成績の回数の表示
 2  print("count", end="")
 3  for key in order_list:
 4      print(f" {key} {count[key]}", end="")
 5  print()
 6  # 通算成績の比率の表示
 7  print("ratio", end="")
 8  for key in order_list:
 9      print(f" {key} {ratio[key]:.1%}", end="")
10  print()

修正箇所

    # 通算成績の回数の表示
    print("count", end="")
    for key in order_list:
        print(f" {key} {count[key]}", end="")
    print()
    # 通算成績の比率の表示
    print("ratio", end="")
    for key in order_list:
        print(f" {key} {ratio[key]:.1%}", end="")
+   print()

異なる部分のデータの抜き出し

繰り返し を使って 処理をまとめる ためには、異なる部分 を 抜き出したデータ を要素として持つ list を用意する必要があります。下記は、異なる部分を表にまとめたものです。

2、7 行目の "count" と、4、9 行目の count は 似ているように見える かもしれませんが、前者は 文字列、後者は 変数名 という、全く異なるデータ である点に注意して下さい。

行数	回数	比率
2、7 行目の文字列	`"count"`	`"ratio"`
4、9 行目の変数	`count`	`ratio`
4、9 行目の書式指定	なし	`.1%`

書式指定の違いの解消

上記の違いのうち、書式指定 に関しては、片方は 存在しない ので、このままでは、うまく まとめる ことが できません。そこで、回数のほうの count[key] にも 書式指定を記述 することにします。count[key] には、整数型 のデータが代入されているので、下記のプログラムの 4 行目のように、10 進数を表記 する 書式指定 の d を記述 することにします。

 1  # 通算成績の回数の表示
 2  print("count", end="")
 3  for key in order_list:
 4      print(f" {key} {count[key]:d}", end="")
 5  print()
 6  # 通算成績の比率の表示
 7  print("ratio", end="")
 8  for key in order_list:
 9      print(f" {key} {ratio[key]:.1%}", end="")
10  print()

修正箇所

    # 通算成績の回数の表示
    print("count", end="")
    for key in order_list:
-       print(f" {key} {count[key]}", end="")
+       print(f" {key} {count[key]:d}", end="")
    print()
    # 通算成績の比率の表示
    print("ratio", end="")
    for key in order_list:
        print(f" {key} {ratio[key]:.1%}", end="")
    print()

上記の修正によって、それぞれの違いが以下の表のようになります。

行数	回数	比率
2、7 行目の文字列	`"count"`	`"ratio"`
4、9 行目の変数	`count`	`ratio`
4、9 行目の書式指定	`d`	`.1%`

異なる部分のデータを要素とする list の作成

次に、異なる部分 のデータを 集めたデータ を作成し、そのデータ を要素とする list を作成 することにします。異なる部分 のデータを 集めたデータ の データ構造 としては、list、tuple、dict などを利用する方法が考えられますが、dict はキーを記述するのが面倒なので、今回の記事では、簡単に記述 できる tuple を利用 することにします。

list を利用することもできますが、list は 同じ種類のデータ を扱うという目的で利用するのが 一般的 なので、今回の記事では tuple を利用することにします。

異なる部分を集めたデータは、以下の表のようになります。

	異なるデータを集めた tuple
回数の表示処理	`("count", count, "d")`
比率の表示処理	`("ratio", ratio, "r")`

下記のプログラムのように、この 2 つのデータを要素として持つ list を、diff_list という名前の変数に代入します。diff は差異を表す difference の略です。

diff_list = [ ("count", count, "d"), ("ratio", ratio, "r") ]

回数と比率の表示処理を繰り返し処理でまとめる

この list を使って、回数と比率 の 表示処理 は、下記プログラムのように記述できます。

2 行目：diff_list から順番に 要素を取り出し、取り出した tuple の 3 つの要素 を title、data、format の 3 つの変数 に代入するという 繰り返し処理 を行う
3 行目：元は "count" や "ratio" が記述されていた部分を title に 置き換える
4 行目：元は count や ratio が記述されていた部分を data に 置き換える。元は d や .1% が記述されていた部分を {format} に 置き換える

1  diff_list = [ ("count", count, "d"), ("ratio", ratio, "r") ]
2  for title, data, format in diff_list:
3      print(title, end="")
4      for key in order_list:
5          print(f" {key} {data[key]:{format}}", end="")
6      print()

行番号のないプログラム

diff_list = [ ("count", count, "d"), ("ratio", ratio, "r") ]
for title, data, format in diff_list:
    print(title, end="")
    for key in order_list:
        print(f" {key} {data[key]:{format}}", end="")
    print()

修正箇所

下記の for 文 の ブロックの中 の 修正箇所 は、回数の表示の処理 のプログラムに対する修正箇所です。

+diff_list = [ ("count", count, "d"), ("ratio", ratio, "r") ]
+for title, data, format in diff_list:
-   print("count", end="")
+   print(title, end="")
    for key in order_list:
-       print(f" {key} {count[key]}", end="")
+       print(f" {key} {data[key]:{format}}", end="")
    print()

書式指定の部分を式で記述する方法

上記のプログラムの 4 行目の補足ですが、f 文字列 の中の、書式指定 の部分にも、{式} を記述することができ、その場合も その部分 が 式 の 計算結果 で 置き換わります。この場合は、{} の中 に {} が入れ子になる 点に 注意が必要 です。

例えば、下記のプログラムの 3 行目と 4 行目は 同じ処理 を行います。

num = 0.5
format = ".1%"
print(f"{num:.1%}")
print(f"{num:{format}}")

実行結果

50.0%
50.0%

`ai_match` の修正

下記は、ai_match を上記のように修正したプログラムです。

def ai_match(ai, match_num=10000):
元と同じなので省略
    # 通算成績の回数と比率の表示
    diff_list = [ ("count", count, "d"), ("ratio", ratio, ".1%") ]
    for title, data, format in diff_list:
        print(title, end="")
        for key in order_list:
            print(f" {key} {data[key]:{format}}", end="")
        print()

行番号のないプログラム

def ai_match(ai, match_num=10000):
    mb = Marubatsu()

    # ai[0] VS ai[1] の対戦を match_num 回行い、通算成績を数える
    count = defaultdict(int)
    for _ in range(match_num):
        count[mb.play(ai, verbose=False)] += 1

    # それぞれの比率を計算し、ratio に代入する
    ratio = {}
    for key in count.keys():
        ratio[key] = count[key] / match_num

    # 〇の勝利、×の勝利、引き分けの順番で表示することを表す list 
    order_list = [Marubatsu.CIRCLE, Marubatsu.CROSS, Marubatsu.DRAW]

    # 通算成績の回数と比率の表示
    diff_list = [ ("count", count, "d"), ("ratio", ratio, ".1%") ]
    for title, data, format in diff_list:
        print(title, end="")
        for key in order_list:
            print(f" {key} {data[key]:{format}}", end="")
        print()

下記のプログラムを実行することで、集計結果が正しく表示されることが確認できます。

ai_match(ai=[ai1, ai2], match_num=567)

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

count o 437 x 97 draw 33
ratio o 77.1% x 17.1% draw 5.8%

今回の記事のまとめ

長くなったので、ai_match の改良の続きは次回の記事で行うことにします。

今回の記事では、比率の表示 を行うように ai_match を改良しました。

また、その際に、__フォーマット済文字列リテラル__を使って数値の 書式を指定 する方法について紹介しました。この方法は 良く使われる ので、覚えておくことをお勧めします。

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

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

今回の記事では、marubatsu.py は修正していないので、marubatsu_new.py はありません。

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

次回の記事

指数を使った数値の表記については、今回の記事の「書式の指定」の所で説明します ↩