Python♪format()メソッドの基本的な使い方

str.format()メソッドでは、キーワードによる指定、表示幅の指定などが可能ですが、どのように組み合わせて記述すればよいのでしょうか。また、「ディクショナリの要素の出力は?」「vars()関数とは?」など、具体例がなければ分かりにくいことばかりです。そこで、多くのサンプルコードにより説明を試みます。

1. str.format()メソッドの基本的な3タイプ

str.format()メソッドは、print(‘x = {}, y = {}’. format(x, y))の様な使い方をします。print(‘x = {}, y = {}’. format(x, y))の赤字の部分が、str.format()のstrの部分です。print(‘x = {}, y = {}‘. format(x, y))では、str側の{}とforrmat()のカッコの中のx,yが対応するのですが、str側の{}の部分の書式は、基本的な書式として「{}タイプ」「{0},{1}タイプ」「{key}タイプ」の3種類のタイプがあります。以下、順を追って説明します。

(1) {}タイプ

まずは、{}タイプ「str側:{参照位置無指定}」「format側:位置引数」について説明します。str.format()メソッドのstrの部分はstr型になります。コード01の4行目では、’x = {}, y = {}’の部分です。strの部分には2カ所{}という部分があります。一方、format()のカッコの中にはx, yの2つの変数があります。
このstr側の{}の部分が、format側のx,yの値に置き換わります。str側の{}では、format側のどの値を使うかは明示されておらず、format側の値を前から順番に使用します。コード01では、最初の{}は、format側の1番目のxの値である66に置き換わります。次の{}は、2番目のyの値である9999に置き換わります。

#コード01
x = 66
y = 9999
print('x = {}, y = {}'. format(x, y))
#出力01
x = 66, y = 9999

つまり、コード02のように、str側の{}の数がformat()内の値の数よりも少ないと、{}から読み出せる値がなくなり、エラーとなってしまいます。

#コード02
x = 66
y = 9999
#エラー(format内の値の数より、str側の{}の数が少ない。)
#print('x = {}, y = {}, y = {}'. format(x, y))

str側の{}の位置と、format側の値の位置とが対応しており、位置でどの引数を使うかが決まるので、format側の引数は「位置引数」と言います。

(2) {0}、{1}タイプ

次は、{0},{1}タイプ「str側:{参照位置の指定}」「format側:位置引数」について説明します。今度は、str側の{}の中に数字が入っています。この数字はformat()のカッコの中の値の参照位置を0から始まる番号で指定します。コード03では、{0}がx、{1}がyを指定します。先ほどの参照位置の指定がない場合と異なり、具体的な位置を指定できるので、str側で同じ値を何度でも指定することができ、順序も自由にできます。

#コード03
x=66
y=9999
print('x = {0}, y = {1}, x = {0}'. format(x, y))
#出力03
x = 66, y = 9999, x = 66

これも、format()の値の位置で指定するので、format側の引数は「位置引数」です。

(3) {key}タイプ

最後は{key}タイプ「str側:{キーワード}」「format側:キーワード引数」です。str側の{}の中にはキーワードが入っています。format側は「キーワード = 値」という書式です。このタイプも、具体的な位置を指定できるので、str側で同じ値を何度でも指定することができ、順序も自由にできます。

#コード04
x=66
y=9999
print('y = {key2}, x = {key1}, y = {key2}'.format(key1 = x, key2 = y))
#出力04
y = 9999, x = 66, y = 9999

これは、format()の値をキーワードで指定するので、format側の引数は「キーワード引数」といいます。

(4) {}タイプと{0}タイプは併用できない

str側では「{}タイプ(参照位置無指定)」と、「{0},{1}タイプ(参照位置の指定)」を併用できません。コード05の7, 8行目のコードではエラーになってしまいます。

#コード05
x = 66
y = 9999
z = 'aaa'
print('x = {0}, y = {1}, z = {2}'.format(x, y, z))
#エラー(str側:参照位置無指定タイプと参照位置を指定するタイプは併用できない)
#print('x = {0}, y = {}, z = {}'.format(x, y, z))
#print('x = {}, y = {}, z = {2}'.format(x, y, z))
#出力05
x = 66, y = 9999, z = aaa

(5) format側の「キーワード引数」は「位置引数」の後に

「{}タイプ」と「{key}タイプ」、あるいは「{0}, {1}タイプ」と「{key}タイプ」を併用する場合、str側の順番は自由ですが、format側のカッコの中は、必ず、「キーワード引数」を「位置引数」の後に配置しなければなりません。コード06の9行目はformat()の中でキーワード引数である「key1 = y」の後に、位置引数である「z」があるためエラーになります。

#コード06
x=66
y=9999
z='aaa'
#「str側:順序問わず」「format側:キーワード引数は、必ず位置引数の後に配置する」
print('y = {1}, z = {key1}, x = {0}'.format(x, y, key1 = z))
print('z = {key1}, x = {}, y = {}'.format(x, y, key1 = z))
#エラー(format側のキーワード引数は、必ず位置引数の後に配置する)
#print('x = {}, y = {key1}, z = {}'.format(x, key1 = y, z))
#出力06
y = 9999, z = aaa, x = 66
z = aaa, x = 66, y = 9999

(6) キーワード引数は、キーワード以外で呼び出せない

format側のキーワード引数は、str側の{}、や{0}では呼び出せません。「{key}タイプ」のキーワードで呼び出す必要があります。コード07の3行目では、format側の「key1 = z」をstr側の{2}で呼び出しているため、エラーになります。

#コード07
x=66
y=9999
z='aaa'
#エラー(format側のキーワード引数は、str側ので{}や{0}では呼び出せない。)
#print('x = {0}, y = {1}, z = {2}'.format(x, y, key1 = z))

(7) format側の値はすべて使う必要はない

format側の値はすべて使う必要はありません。コード08では、format側の「z」を使用していませんが、エラーにはなりません。

#コード08
x=66
y=9999
z='aaa'
#フォーマット側の引数を全て使う必要はない
print('x = {0}, z = {key1}'.format(x, y, key1 = z))
#出力08
x = 66, z = aaa

2. ディクショナリの要素を出力する方法

str.format()メソッドでは、ディクショナリの要素を出力ことができます。

(1) ディクショナリの要素の出力法(その1)

コード09の4行目「{0[aa]}」の「0」はformat側の位置を指定する番号です。「{0[aa]}」の「aa」は、ディクショナリのキーです。「’aa’」ではなく「aa」となることに注意しましょう。

#コード09
x = {'aa': 11, 'bb': 22}
y = {'cc': 33, 'dd': 44}
print('{0[aa]}, {1[dd]}'.format(x, y))
#出力09
11, 44

(2) キーワードが「’数字’」の場合は呼び出せない?

コード10の2行目のディクショナリのキー「’aa’」、「22」に対して、str.format()メソッドのstr側は、{0[aa]}、{0[22]}となります。{0[“aa”]}、{0[“22”]}とはなりません。また、「’33’」に対しては、{0[“33”]}でも、{0[33]}でもエラーになります。

#コード10
x = {'aa': 11, 22: 22, '33': 33}
print('{0[aa]}, {0[22]}'.format(x))
#エラーになる
#print('{0["aa"]}'.format(x))
#print('{0["33"]}'.format(x))
#print('{0[33]}'.format(x))
#出力10
11, 22

(3) ディクショナリの要素を単純に出力する場合との比較

コード11の5行目はディクショナリの要素を単純にprint()で出力しています。4行目のstr.format()メソッドと比較しましょう。上で述べた内容と重複しますが、str.format()メソッドでは、文字列のキーであっても両側に「’」がつきません。また、キーが「22」は呼び出せますが、「’33’」は呼び出せません。

#コード11
x = {'aa': 11, 22: 22, '33': 33}
#キー'33'はstr.format()メソッドでは呼び出せない
print('{0[aa]} {0[22]}'.format(x))
print(x['aa'], x[22], x['33'])
#出力11
11 22
11 22 33

(4) ディクショナリを「**」表記でキーワード引数として渡す

ディクショナリを「**」表記でキーワード引数として渡す方法があります。コード12の4行目がその書式です。フォーマット側を「**」表記とし、str側は、{キー}となります。「キーワード」ではなく、ディクショナリの要素の「キー」です。なお、キーの両側には「’」は不要です。コード12の6~9行目は、全てエラーになります。
複数のディクショナリに対してもキーのみで呼び出すことができます。なお、コード10では、キーが数字の場合も扱えましたが、「**」表記では、キーが数字の場合は扱えません。

#コード12
x = {'aa': 11, 22: 22, '33': 33}
y = {'bb': 44}
print('{aa}, {bb}'.format(**x, **y))
#エラーになる
#print('{"aa"}'.format(**x))
#print('{22}'.format(**x))
#print('{"33"}'.format(**x))
#print('{33}'.format(**x))
#出力12
11, 44

コード13のように、同じキーがあるとエラーになります。

#コード13
#エラー(キー'aa'が重複している)
#x = {'aa': 11, 'bb': 22}
#y = {'aa': 44}
#print('{bb}'.format(**x, **y))

3. {:フォーマット指定子}による書式指定

str側の{}の中で「:」のあとに書式指定のオプション(フォーマット指定子)を加えることにより、{}に置き換わる値の書式を指定することができます。それぞれformat側の値の型が限定されており、それ以外の値を使うとエラーになります。

(1) 主なフォーマット指定子

主なフォーマット指定子は以下の通りです。{:.3f}は、コロン「:」の後のピリオド「.」を忘れないようにしましょう。

フォーマット
指定子
使用例 出力書式 format側
の値の型
d {:d} 10進数の整数 整数
b {:b} 2進数の整数 整数
o {:o} 8進数の整数 整数
x {:x} 16進数の整数
(英字部分は小文字)
整数
X {:X} 16進数の整数
(英字部分は大文字)
整数
f {:.3f}
{:f}
小数
(小数点以下の桁数指定)
(桁数無指定{:f}→桁数6)
整数、小数

以下、「{}タイプ」「{0}, {1}タイプ」「{key}タイプ」をフォーマット指定子を用いて、書式設定した例です。

#コード14
x=66
y=9999
print('10進数')
print('{:d} (整数), {:f} (少数), {:.3f} (少数の桁数指定)')
print('{:d}, {:f}, {:.3f}'.format(x, x, x))
print('{0:d}, {0:f}, {0:.3f}'.format(x))
print('{key1:d}, {key1:f}, {key1:.3f}'.format(key1 = x))

print('{:b} (2進法), {:o} (8進法)')
print('{:b}, {:o}'.format(x,y))
print('{0:b}, {1:o}'.format(x,y))
print('{key1:b}, {key2:o}'.format(key1 = x, key2 = y))

print('{:x} (16進法、小文字), {:X} (16進法、大文字)')
print('{:x}, {:X}'.format(y,y))
print('{0:x}, {1:X}'.format(y,y))
print('{key1:x}, {key2:X}'.format(key1 = y, key2 = y))
#出力14
10進数
{:d} (整数), {:f} (少数), {:.3f} (少数の桁数指定)
66, 66.000000, 66.000
66, 66.000000, 66.000
66, 66.000000, 66.000
{:b} (2進法), {:o} (8進法)
1000010, 23417
1000010, 23417
1000010, 23417
{:x} (16進法、小文字), {:X} (16進法、大文字)
270f, 270F
270f, 270F
270f, 270F

文字列や小数に対してフォーマット指定子「d」は使えません。コード15はエラーになります。

#コード15
#エラー(文字列や少数にdは使えない)
#print('{:d}'.format('11'))
#print('{:d}'.format(33.3))

(2)  フォーマット指定子「f」は四捨五入?

フォーマット指定子「f」を用いて、小数点以下の桁数を丸めた場合、四捨五入になるのでしょうか?コード16に対する出力16を見てください。「なんちゃて四捨五入」になっています。詳しくは述べませんが、5未満は切り捨て、5より大きい値は切り上げになっていますが、丁度5の場合は切り捨てになる場合も、切り上げになる場合もあります。四捨五入の結果が欲しい場合には注意してください。なお、フォーマット指定子「f」による丸め方は、round()関数と同じです。round()関数も同様のことが言えますので、気をつけましょう。

#コード16
print('{:.2f}'.format(0.014), round(0.014, 2))
print('{:.2f}'.format(0.015), round(0.015, 2))
print('{:.2f}'.format(0.016), round(0.016, 2))
print('{:.2f}'.format(0.025), round(0.025, 2))

print('{:.1f}'.format(0.14), round(0.14, 1))
print('{:.1f}'.format(0.15), round(0.15, 1))
print('{:.1f}'.format(0.16), round(0.16, 1))
print('{:.1f}'.format(0.25), round(0.25, 1))

print('{:.0f}'.format(1.4), round(1.4, 0))
print('{:.0f}'.format(1.5), round(1.5, 0))
print('{:.0f}'.format(1.6), round(1.6, 0))
print('{:.0f}'.format(2.5), round(2.5, 0))
#出力16
0.01 0.01
0.01 0.01
0.02 0.02
0.03 0.03
0.1 0.1
0.1 0.1
0.2 0.2
0.2 0.2
1 1.0
2 2.0
2 2.0
2 2.0

(3) 表示最小幅の指定

「:整数」とすることで、表示最小幅を指定することができます。コード17では、「{}タイプ」「{0}, {1}タイプ」「{key}タイプ」の表示最小幅を設定した例です。なお、フォーマット指定子「X」「f」と併用した場合の例も示します。数値は右寄せ、文字列は左寄せになっています。

#コード17
x=66
y=9999
z='aaa'

print('{:10} (最小幅10), {:10X} (最小幅10、16進法、大文字)')
print('{:10}, {:10X}'.format(x,y))
print('{0:10}, {1:10X}'.format(x,y))
print('{key1:10}, {key2:10X}'.format(key1 = x, key2 = y))

print('{:10.3f} (最小幅10、小数点以下3文字), {:15f} (小数点以下3文字)')
print('{:10.3f}, {:15f}'.format(x,y))
print('{0:10.3f}, {1:15f}'.format(x,y))
print('{key1:10.3f}, {key2:15f}'.format(key1 = x, key2 = y))

print('数値は右寄せ{:10}, 文字列は左寄せ{:10}'.format(x,z))
#出力17
{:10} (最小幅10), {:10X} (最小幅10、16進法、大文字)
        66,       270F
        66,       270F
        66,       270F
{:10.3f} (最小幅10、小数点以下3文字), {:15f} (小数点以下3文字)
    66.000,     9999.000000
    66.000,     9999.000000
    66.000,     9999.000000
数値は右寄せ        66, 文字列は左寄せaaa

(4) 指定した表示最小幅を超えた場合

表示最小幅の指定なので、指定した幅を超えた場合、超えた部分は削除されるのではなく、指定幅を超えて表示されます。コード18では、表示最小幅は{:10}により10を指定しましたが、98765432109876543210は20桁であり、出力は20桁のまま出力されています。

#コード18
print('{:10}{}'.format(98765432109876543210, 'aa'))
#出力18
98765432109876543210aa

4.「!a, !s, !r」による型変換

「!a, !s, !r」を用いれば、「:」に続くフォーマット指定子のフォーマット変換前に書式の型を変換することができます。「!s」や「!r」では、format側がリストやディクショナリであっても使用することが可能ですので、幅広く利用できます。

(1) 型変換の内容と書式

型変換の指定 使用例 型変換の内容
!a {!a} ascii()
!s {!s} str()
!r {!r} repr()

以下、「{}タイプ」「{0}, {1}タイプ」「{key}タイプ」での使用例です。最小幅の指定を併用した例も示します。
なお、表記位置としては、「:」がない場合には{key1!a}のように最後に配置し、「:」がある場合には、例えば{0[aa]!r:10}のように「:」の直前に配置します。

#コード19
x='aaa'
y=[2,3]

print('{!a} (ascii()を適用), {!s} (str()を適用), {!r} (repr()を適用)')
print('x = {!a}, y = {!s}, y = {!r}'.format(x,y,y))
print('x = {0!a}, y = {1!s}, y = {1!r}'.format(x,y))
print('x = {key1!a}, y = {key2!s}, y = {key2!r}'.format(key1 = x, key2 = y))

print('{:10}, {!a:10}, {!s:10}, {!r:10}')
print('x = {:10}, y = {!a:10}end'.format(x, y))
print('x = {!s:10}, y = {!r:10}end'.format(x, y))

z = {'aa': 11.1111, 'bb': 22}
w = {'cc': 33, 'dd': 44}
print('{0[aa]!r:10}, {1[dd]}'.format(z, w))
#出力19
{!a} (ascii()を適用), {!s} (str()を適用), {!r} (repr()を適用)
x = 'aaa', y = [2, 3], y = [2, 3]
x = 'aaa', y = [2, 3], y = [2, 3]
x = 'aaa', y = [2, 3], y = [2, 3]
{:10}, {!a:10}, {!s:10}, {!r:10}
x = aaa       , y = [2, 3]    end
x = aaa       , y = [2, 3]    end
11.1111   , 44

(2) フォーマット指定の前に値の型変換を行う

「!a, !s, !r」は、「:」に続くフォーマット指定子のフォーマット変換前に書式の型を変換します。したがって、例えば{!s:10d}では、format側の値が整数であっても、最初に!sによりstr型に変換されるため、文字列を扱えない「d」でエラーとなります。

#コード20
#エラー(!s,!a,!rを使った時は、dの書式設定の前にstr型に変換される)
#print('x = {!s:10d}'.format(10))

5. vars()関数と「**」表記の併用

vars()関数と「**」表記を併用することで、便利な使い方ができます。

(1) 関数内のローカル変数の出力

vars()関数は、関数で使用しているローカルシンボルテーブル(ローカル変数、ローカル変数に代入された値などを含む)をディクショナリ型で返します。コード21aは一般的な表記方法ですが、コード21bのように、format側に**vars()を記述し、str側の{}の中に、ローカル変数名を記述することでローカル変数を出力することができます。
なお、この場合、vars()は関数内で用い、vars()のカッコ内にはなにも記述しません。

(a)通常の出力例

#コード21a
def xxx():
   aa = 999
   bb = 'abc'
   print('aa={0}, bb={1}'.format(aa, bb))

xxx()
#出力21a
aa=999, bb=abc

(b) vars()関数と「**」表記の併用

#コード21b
def xxx():
   aa = 999
   bb = 'abc'
   print(vars())
   print('aa={aa}, bb={bb}'.format(**vars()))

xxx()
#出力21b
{'bb': 'abc', 'aa': 999}
aa=999, bb=abc

(2) クラス内の変数の出力

vars()関数は、モジュール、クラス、インスタンスなどの、 __dict__ 属性を返します。この場合、vars()のカッコの中には、モジュール、クラス、インスタンスなどを記述します。
一般的な出力例はコード22aですが、コード22bのように、format側に**vars()を記述し、str側の{}の中に、クラスの中の変数名を記述することでクラス内の変数の値を出力することができます。

(a)通常の出力例

#コード22a
class Class_xxx:
    def __init__(self):
        self.aa = 999
        self.bb = 'abc'

xxx = Class_xxx()
print ('aa={0}, bb={1}'.format(xxx.aa, xxx.bb))
#出力22a
aa=999, bb=abc

(b) vars()関数と「**」表記の併用

#コード22b
class Class_xxx:
    def __init__(self):
        self.aa = 999
        self.bb = 'abc'

xxx = Class_xxx()
print(vars(xxx))
print(xxx.__dict__)
print ('aa={aa}, bb={bb}'.format(**vars(xxx)))
#出力22b
{'aa': 999, 'bb': 'abc'}
{'aa': 999, 'bb': 'abc'}
aa=999, bb=abc

(3) ローカルシンボルテーブルの更新

コード23では、5行目で、vars()関数をvars_tmpに代入しました。その後、新しいローカル変数ccを7行目で定義しましたが、8行目ではvars_tmpの内容は変わっていません。しかし、9行目で、vars()関数を使用することにより、vars_tmpの内容も更新され、10行目では、更新されたvars_tmpの内容が出力されています。

#コード23
def xxx():
   aa = 999
   bb = 'abc'
   vars_tmp=vars()
   print('01', vars_tmp)
   cc = 111
   print('02', vars_tmp)
   print('03', vars())
   print('04', vars_tmp)
xxx()
#出力23
01 {'bb': 'abc', 'aa': 999}
02 {'bb': 'abc', 'aa': 999}
03 {'bb': 'abc', 'aa': 999, 'cc': 111, 'vars_tmp': {...}}
04 {'bb': 'abc', 'aa': 999, 'cc': 111, 'vars_tmp': {...}}

以上が、str.format()メソッドによる出力の基本的な使い方です。他にも、様々な表記方法がありますので、必要に応じてPython標準ライブラリなどを調べて、自分に合った機能を使ってみましょう。