str()【文字列型】

メモ


str()【文字列型】コンストラクタ

構文

class str(object='')

class str(object=b'', encoding='utf-8', errors='strict')

objectオブジェクト
encodingエンコード (指定値については、encode()【エンコード】参照)
errors変換不可エラー処理 (指定値については、encode()【エンコード】参照)

print("({})".format(str()))
print("({})".format(str("STRING")))
print("({})".format(str(-123456)))
print("({})".format(str(-123.456)))
b1 = b"bin"
print("({})".format(str(b1)))
print("({})".format(str(b1, "utf-8")))

b2 = b"abc\x80xyz"
print("({})".format(str(b2, errors="backslashreplace")))
print("({})".format(str(b2, errors="ignore")))
【出力例】
()
(STRING)
(-123456)
(-123.456)
(b'bin')
(bin)
(abc\x80xyz)
(abcxyz)

upper()【大文字変換】・ lower()【小文字変換】
swapcase()【大小文字切替】・ casefold()【小文字変換 (特殊文字対応)】3.3

メモ

構文

str.upper()
str.lower()
str.swapcase()
str.casefold() 3.3

戻り値変換後の文字列

s = "xYzXyZxYzXyZßẞ"
print(s, "\t【変換前:半角・全角・エスツェット (ドイツ語)】")
print(s.upper(), "\t【upper()】")
print(s.lower(), "\t【lower()】")
print(s.swapcase(), "\t【swapcase()】")
print(s.casefold(), "\t【casefold()】")
【出力例】
xYzXyZxYzXyZßẞ   【変換前:半角・全角・エスツェット (ドイツ語)】
XYZXYZXYZXYZSSẞ  【upper()】
xyzxyzxyzxyzßß   【lower()】
XyZxYzXyZxYzSSß  【swapcase()】
xyzxyzxyzxyzssss 【casefold()】

capitalize()【先頭大文字変換】・title()【タイトルケース変換】

メモ

構文

str.capitalize()
str.title()

戻り値変換後の文字列

s1 = "the quick brown fox jumps over the lazy dog."
s2 = "THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG."
s3 = "cats and dogs"
s4 = "CATS AND DOGS"
s5 = "we're the world"

print(s1)
print(s2)
print(s3)
print(s4)
print(s5)

print("\ncapitalize()")
print(s1.capitalize())
print(s2.capitalize())
print(s3.capitalize())
print(s4.capitalize())
print(s5.capitalize())

print("\ntitle()")
print(s1.title())
print(s2.title())
print(s3.title())
print(s4.title())
print(s5.title())
【出力例】
the quick brown fox jumps over the lazy dog.
THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG.
cats and dogs
CATS AND DOGS
we're the world

capitalize()
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
Cats and dogs
Cats and dogs
We're the world

title()
The Quick Brown Fox Jumps Over The Lazy Dog.
The Quick Brown Fox Jumps Over The Lazy Dog.
Cats And Dogs
Cats And Dogs
We'Re The World

isupper()【大文字判定】・islower()【小文字判定】
istitle()【タイトルケース判定】

メモ

構文

str.isupper()
str.islower()
str.istitle()

戻り値判定結果 (True / False)

dic = {
    "空文字列": "",
    "大小文字混在": "abcXYZ",
    "区別なし文字のみ": "123",
    "全て大文字": "ABCXYZΑΒΓ",
    "大文字 + 区別なし文字": "ABC123XYZ",
    "全て小文字": "abcabcαβγ",
    "小文字 + 区別なし文字": "abc123",
}

for key, value in dic.items():
    print("{0} {1}【{2}】'{3}' ".format(
        value.isupper(), value.islower(), key, value))
【出力例】
False False【空文字列】'' 
False False【大小文字混在】'abcXYZ' 
False False【区別なし文字のみ】'123' 
True False【全て大文字】'ABCXYZΑΒΓ' 
True False【大文字 + 区別なし文字】'ABC123XYZ' 
False True【全て小文字】'abcabcαβγ' 
False True【小文字 + 区別なし文字】'abc123' 
lst = [
    "123",
    "The quick brown fox jumps over the lazy dog.",
    "THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG.",
    "The Quick Brown Fox Jumps Over The Lazy Dog.",
    "cats and dogs",
    "CATS AND DOGS",
    "Cats And Dogs",
]

for s in lst:
    print(s.istitle(), s)
【出力例】
False 123
False The quick brown fox jumps over the lazy dog.
False THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG.
True The Quick Brown Fox Jumps Over The Lazy Dog.
False cats and dogs
False CATS AND DOGS
True Cats And Dogs

isascii()【ASCII 判定】3.7・isalpha()【レター文字判定】・isalnum()【レター文字・数字判定】

メモ

構文

str.isascii() 3.7
str.isalpha()
str.isalnum()

戻り値判定結果 (True / False)

import copy

dic = {
    "空文字列": "",
    "ASCII (U+0000 ~ U+007F)": '!#1Az"',
    "英字 (半角)": "abcXYZ",
    "英字 (全角)": "abcXYZ",
    "英数字 (半角)": "abc123XYZ",
    "英数字 (全角)": "abc123XYZ",
    "ひらがな": "ひらがな",
    "カタカナ": "カタカナ",
    "漢字": "漢字",
    "ラテン文字": "αβγπΣ",
    "記号 (全角)": "!#",
}

print("isascii() isalpha() isalnum()")
old = [True, False, False]
r = copy.copy(old)
for key, value in dic.items():
    r[0] = value.isascii()
    r[1] = value.isalpha()
    r[2] = value.isalnum()
    if r != old:
        print()
    old = copy.copy(r)
    print("{0:5} {1:5} {2:5} ('{3}')【{4}】".format(
        str(r[0]), str(r[1]), str(r[2]), value, key))
【出力例】
isascii() isalpha() isalnum()
True  False False ('')【空文字列】
True  False False ('!#1Az"')【ASCII (U+0000 ~ U+007F)】

True  True  True  ('abcXYZ')【英字 (半角)】

False True  True  ('abcXYZ')【英字 (全角)】

True  False True  ('abc123XYZ')【英数字 (半角)】

False False True  ('abc123XYZ')【英数字 (全角)】

False True  True  ('ひらがな')【ひらがな】
False True  True  ('カタカナ')【カタカナ】
False True  True  ('漢字')【漢字】
False True  True  ('αβγπΣ')【ラテン文字】

False False False ('!#')【記号 (全角)】

isdecimal()【数字判定 (10進数字)】
isdigit()【数字判定 (10進数字 + 修飾10進数字)】
isnumeric()【数字判定 (10進数字 + 修飾10進数字 + その他数字)】

メモ

  • 数字の判定
    メソッドおおよその範囲・仕様
    isdecimal()
    【数字判定 (10進数字)】
    アラビア数字 (0 ~ 9) 系統の数字
    仕様:カテゴリ Nd (Number, Decimal Digit)
    isdigit()
    【数字判定 (10進数字 + 修飾10進数字)】
    上記に加え、修飾された 9 までの数字 (丸数字・丸括弧数字 等)
    仕様:プロパティ値 Numeric_Type=Digit または Decimal
    isnumeric()
    【数字判定 (10進数字 + 修飾10進数字 + その他数字)】
    上記に加え、その他数字 (ローマ数字・漢数字・分数・10以上の数字 等)
    仕様:プロパティ値 Numeric_Type=Digit または Decimal または Numeric
  • 関連

構文

str.isdecimal()
str.isdigit()
str.isnumeric()

戻り値判定結果 (True / False)

def chars(start, end):
    return "".join([chr(i) for i in range(start, end+1)])


def display(dic):
    for key, value in dic.items():
        print("{0} {1} {2} ('{3}')【{4}】".format(
            value.isdecimal(), value.isdigit(), value.isnumeric(), value, key))


print("【数字以外】")
dic0 = {
    "空文字列": "",
    "英数混在": "123ABC",
    "符号付き": "-123",
    "小数点付き": "123.456",
}
display(dic0)

print("\n【10進数字】")
dic1 = {
    "半角アラビア数字 (U+0030~U+0039)": chars(0x0030, 0x0039),
    "全角アラビア数字 (U+FF10~U+FF19)": chars(0xFF10, 0xFF19),
    "アラビア・インド数字 (U+0660~U+0669)": chars(0x0660, 0x0669),
    "デーヴァナーガリー数字 (U+0966~U+096F)": chars(0x0966, 0x096F),
}
display(dic1)

print("\n【修飾10進数字】")
dic2 = {
    "丸数字 (U+24EA・U+2460~U+2468)": "\u24EA" + chars(0x2460, 0x2468),
    "丸サンセリフ数字 (U+2780~U+2788)": chars(0x2780, 0x2788),
    "黒丸数字 (U+24FF・U+2776~U+277E)": "\u24FF" + chars(0x2776, 0x277E),
    "黒丸サンセリフ数字 (U+278A~U+2792)": chars(0x278A, 0x2792),
    "二重丸数字 (U+24F5~U+24FD)": chars(0x24F5, 0x24FD),
    "丸括弧数字 (U+2474~U+247C)": chars(0x2474, 0x247C),
    "ピリオド付き数字 (U+2488~U+2490)": chars(0x2488, 0x2490),
    "上付き数字 (U+2070・U+00B9・U+00B2・U+00B3・U+2074~U+2079)": "\u2070" + "\u00B9" + "\u00B2" + "\u00B3" + chars(0x2074, 0x2079),
    "下付き数字 (U+2080~U+2089)": chars(0x2080, 0x2089),
}
display(dic2)

print("\n【その他数字】")
dic3 = {
    "ローマ数字(U+2160~U+2182)": chars(0x2160, 0x2182),
    "漢数字": "〇一二三十百千万億兆",
    "丸漢数字 1~10 (U+3280~U+3289)": chars(0x3280, 0x3289),
    "大字": "零壱弐参肆伍陸漆捌玖拾什陌佰阡仟萬",
    "丸括弧漢数字 1~10 (U+3220~U+3229)": chars(0x3220, 0x3229),
    "分数": chars(0x00BC, 0x00BE) + chars(0x2152, 0x215F),
    "丸数字 10~20 (U+2469~U+2473)": chars(0x2469, 0x2473),
    "丸数字 21~35 (U+3251~U+325F)": chars(0x3251, 0x325F),
    "丸数字 36~50 (U+32B1~U+32BF)": chars(0x32B1, 0x32BF),
    "丸サンセリフ数字 10 (U+2789)": "\u2789",
    "黒丸数字 10~20 (U+277F・U+24EB~U+24F4)": "\u277F" + chars(0x24EB, 0x24F4),
    "黒丸サンセリフ数字 10 (U+2793)": "\u2793",
    "二重丸数字 10 (U+24FE)": "\u24FE",
    "丸括弧数字 10~20 (U+247D~U+2487)": chars(0x247D, 0x2487),
    "ピリオド付き数字 10~20 (U+2491~U+249B)": chars(0x2491, 0x249B),
}
display(dic3)
【出力例】
【数字以外】
False False False ('')【空文字列】
False False False ('123ABC')【英数混在】
False False False ('-123')【符号付き】
False False False ('123.456')【小数点付き】

【10進数字】
True True True ('0123456789')【半角アラビア数字 (U+0030~U+0039)】
True True True ('0123456789')【全角アラビア数字 (U+FF10~U+FF19)】
True True True ('٠١٢٣٤٥٦٧٨٩')【アラビア・インド数字 (U+0660~U+0669)】
True True True ('०१२३४५६७८९')【デーヴァナーガリー数字 (U+0966~U+096F)】

【修飾10進数字】
False True True ('⓪①②③④⑤⑥⑦⑧⑨')【丸数字 (U+24EA・U+2460~U+2468)】
False True True ('➀➁➂➃➄➅➆➇➈')【丸サンセリフ数字 (U+2780~U+2788)】
False True True ('⓿❶❷❸❹❺❻❼❽❾')【黒丸数字 (U+24FF・U+2776~U+277E)】
False True True ('➊➋➌➍➎➏➐➑➒')【黒丸サンセリフ数字 (U+278A~U+2792)】
False True True ('⓵⓶⓷⓸⓹⓺⓻⓼⓽')【二重丸数字 (U+24F5~U+24FD)】
False True True ('⑴⑵⑶⑷⑸⑹⑺⑻⑼')【丸括弧数字 (U+2474~U+247C)】
False True True ('⒈⒉⒊⒋⒌⒍⒎⒏⒐')【ピリオド付き数字 (U+2488~U+2490)】
False True True ('⁰¹²³⁴⁵⁶⁷⁸⁹')【上付き数字 (U+2070・U+00B9・U+00B2・U+00B3・U+2074~U+2079)】
False True True ('₀₁₂₃₄₅₆₇₈₉')【下付き数字 (U+2080~U+2089)】

【その他数字】
False False True ('ⅠⅡⅢⅣⅤⅥⅦⅧⅨⅩⅪⅫⅬⅭⅮⅯⅰⅱⅲⅳⅴⅵⅶⅷⅸⅹⅺⅻⅼⅽⅾⅿↀↁↂ')【ローマ数字(U+2160~U+2182)】
False False True ('〇一二三十百千万億兆')【漢数字】
False False True ('㊀㊁㊂㊃㊄㊅㊆㊇㊈㊉')【丸漢数字 1~10 (U+3280~U+3289)】
False False True ('零壱弐参肆伍陸漆捌玖拾什陌佰阡仟萬')【大字】
False False True ('㈠㈡㈢㈣㈤㈥㈦㈧㈨㈩')【丸括弧漢数字 1~10 (U+3220~U+3229)】
False False True ('¼½¾⅒⅓⅔⅕⅖⅗⅘⅙⅚⅛⅜⅝⅞⅟')【分数】
False False True ('⑩⑪⑫⑬⑭⑮⑯⑰⑱⑲⑳')【丸数字 10~20 (U+2469~U+2473)】
False False True ('㉑㉒㉓㉔㉕㉖㉗㉘㉙㉚㉛㉜㉝㉞㉟')【丸数字 21~35 (U+3251~U+325F)】
False False True ('㊱㊲㊳㊴㊵㊶㊷㊸㊹㊺㊻㊼㊽㊾㊿')【丸数字 36~50 (U+32B1~U+32BF)】
False False True ('➉')【丸サンセリフ数字 10 (U+2789)】
False False True ('❿⓫⓬⓭⓮⓯⓰⓱⓲⓳⓴')【黒丸数字 10~20 (U+277F・U+24EB~U+24F4)】
False False True ('➓')【黒丸サンセリフ数字 10 (U+2793)】
False False True ('⓾')【二重丸数字 10 (U+24FE)】
False False True ('⑽⑾⑿⒀⒁⒂⒃⒄⒅⒆⒇')【丸括弧数字 10~20 (U+247D~U+2487)】
False False True ('⒑⒒⒓⒔⒕⒖⒗⒘⒙⒚⒛')【ピリオド付き数字 10~20 (U+2491~U+249B)】

isspace()【空白判定】・isprintable()【印字可能判定】・isidentifier()【識別子判定】

メモ

  • 空白・印字可能・識別子の判定
    メソッド備考
    isspace()【空白判定】 1個以上の全ての文字が空白文字か否か
    仕様:
      定義が "Other" または "Separator"
      双方向プロパティが "WS" または "B" または "S"
    isprintable()【印字可能判定】 空文字列 または 1個以上の全ての文字が印字可能か否か
    仕様:
      定義が "Other" または "Separator" 以外 (Space:0x20 を除く)
    isidentifier()【識別子判定】有効な識別子か否か
    (予約済み識別子の判定:keyword.iskeyword()【キーワード判定】)
  • 関連

構文

str.isspace()
str.isprintable()
str.isidentifier()

戻り値判定結果 (True / False)

dic = {
    "空文字列": "",
    "文字": "abc",
    "半角スペース": " ",
    "全角スペース": " ",
    "タブ": "\t",
}
for key, value in dic.items():
    print("{0} ('{1}') 【{2}】".format(value.isspace(), value, key))
【出力例】
False ('') 【空文字列】
False ('abc') 【文字】
True (' ') 【半角スペース】
True (' ') 【全角スペース】
True (' ') 【タブ】
lst = ["", "abc", "(SP) ", "(tab)\t"]
for s in lst:
    print("{0} ('{1}')".format(s.isprintable(), s))
【出力例】
True ('')
True ('abc')
True ('(SP) ')
False ('(tab) ')
import keyword

lst = ["", "123abc", "abc", "i", "CLASS", "変数", "if", "class"]
for s in lst:
    print("{0} {1} ('{2}')".format(s.isidentifier(), keyword.iskeyword(s), s))
【出力例】
False False ('')
False False ('123abc')
True False ('abc')
True False ('i')
True False ('CLASS')
True False ('変数')
True True ('if')
True True ('class')

center()【中央揃え】・rjust()【右揃え】
zfill()【ゼロパディング】

メモ

  • 中央揃え・右揃え・ゼロパディングに変換
    メソッド備考
    center()【中央揃え】中央揃え (パディング文字の指定が可)
    rjust()【右揃え】右揃え (パディング文字の指定が可)
    zfill()【ゼロパディング】ゼロパディング (符号付きは符号の後ろ)
  • 関連

構文

str.center(width [, fillchar])
str.rjust(width [, fillchar])
str.zfill(width)

戻り値変換後の文字列 (長さ以下の場合、元の文字列)
width長さ
fillcharパディング文字 (デフォルト:SP-0x20)

s = "STRING"
print(s.center(9))
print(s.center(9, '#'))
print(s.center(3))

print(s.rjust(9))
print(s.rjust(9, '#'))
print(s.rjust(3))
【出力例】
  STRING 
##STRING#
STRING
   STRING
###STRING
STRING
s1 = "123"
s2 = "-123"
s3 = "+123"
print(s1.zfill(6))
print(s2.zfill(6))
print(s3.zfill(6))
print(s1.zfill(2))
【出力例】
000123
-00123
+00123
123

strip()【両側削除】・lstrip()【左側削除】・rstrip()【右側削除】

メモ

  • 文字列の両側あるいは片側から指定した文字を削除
    メソッド備考
    strip()【両側削除】指定した文字集合に含まれている文字を両側から削除
    lstrip()【左側削除】指定した文字集合に含まれている文字を左側から削除
    rstrip()【右側削除】指定した文字集合に含まれている文字を右側から削除
  • 関連

構文

str.strip([chars])
str.lstrip([chars])
str.rstrip([chars])

戻り値削除後の文字列
chars削除する文字集合 (省略・None:空白文字を削除)

s1 = "  STRING  "
print("'{0}'".format(s1))
print("'{0}'".format(s1.strip()))
print("'{0}'".format(s1.lstrip()))
print("'{0}'".format(s1.rstrip()))

s2 = "abcSTRINGxyz"
chars = "zyxcba"
print("'{0}'".format(s2))
print("'{0}'".format(s2.strip(chars)))
print("'{0}'".format(s2.lstrip(chars)))
print("'{0}'".format(s2.rstrip(chars)))
【出力例】
'  STRING  '
'STRING'
'STRING  '
'  STRING'
'abcSTRINGxyz'
'STRING'
'STRINGxyz'
'abcSTRING'

startswith()【先頭文字列判定】・endswith()【後尾文字列判定】

メモ

  • 先頭 または 後尾 の文字列の判定
    メソッド備考
    startswith()【先頭文字列判定】先頭文字列の判定 (複数文字列の判定可 / 比較開始位置・比較終了位置の指定可)
    endswith()【後尾文字列判定】後尾文字列の判定 (複数文字列の判定可 / 比較開始位置・比較終了位置の指定可)
  • 関連

構文

str.startswith(prefix[, start[, end]])
str.endswith(suffix[, start[, end]])

戻り値判定結果 (True / False)
prefix比較文字列 または 比較文字列のタプル
suffix比較文字列 または 比較文字列のタプル
start比較開始位置インデックス
end比較終了位置インデックス

s = "start__end"
print(s)

print("startswith()")
print("(A)", s.startswith("start"))
print("(B)", s.startswith("end"))
print("(C)", s.startswith("start", 1))
print("(D)", s.startswith("end", 7))
print("(E)", s.startswith("start", 0, 2))
print("(F)", s.startswith(("start", "_")))
print("(G)", s.startswith(("start", "end")))

print("endswith()")
print("(A)", s.endswith("start"))
print("(B)", s.endswith("end"))
print("(C)", s.endswith("end", -2))
print("(D)", s.endswith("end", 5))
print("(E)", s.endswith("end", 2, 7))
print("(F)", s.endswith(("start", "_")))
print("(G)", s.endswith(("start", "end")))
【出力例】
start__end
startswith()
(A) True
(B) False
(C) False
(D) True
(E) False
(F) True
(G) True
endswith()
(A) False
(B) True
(C) False
(D) True
(E) False
(F) False
(G) True

find()【順方向検索 (例外なし)】・index()【順方向検索 (例外あり)】
rfind()【逆方向検索 (例外なし)】・rindex()【逆方向検索 (例外あり)】

メモ

構文

str.find(sub[, start[, end]])
str.index(sub[, start[, end]])

str.rfind(sub[, start[, end]])
str.rindex(sub[, start[, end]])

戻り値一致位置インデックス (-1:一致なし)
sub検索文字列
start検索範囲開始位置インデックス (0≦:先頭から / <0:後尾から)
end検索範囲終了位置インデックス (0≦:先頭から / <0:後尾から)
例外ValueError (一致なし)

s = "cats and dogs, cats and dogs"

print("find()")
print(s.find("cat"))
print(s.find("dog"))
print(s.find("mouse"))
print(s.find("cat", 1))
print(s.find("cat", 1, 17))

print("\nindex()")
print(s.index("cat"))
print(s.index("dog"))
try:
    print(s.index("mouse"))
except ValueError as e:
    print(type(e), e.args)
print(s.index("cat", 1))
try:
    print(s.index("cat", 1, 17))
except ValueError as e:
    print(type(e), e.args)

print("\nrfind()")
print(s.rfind("cat"))
print(s.rfind("dog"))
print(s.rfind("mouse"))
print(s.rfind("cat", 1))
print(s.rfind("cat", 1, 17))

print("\nrindex()")
print(s.rindex("cat"))
print(s.rindex("dog"))
try:
    print(s.rindex("mouse"))
except ValueError as e:
    print(type(e), e.args)
print(s.rindex("cat", 1))
try:
    print(s.rindex("cat", 1, 17))
except ValueError as e:
    print(type(e), e.args)
【出力例】
find()
0
9
-1
15
-1

index()
0
9
<class 'ValueError'> ('substring not found',)
15
<class 'ValueError'> ('substring not found',)

rfind()
15
24
-1
15
-1

rindex()
15
24
<class 'ValueError'> ('substring not found',)
15
<class 'ValueError'> ('substring not found',)

split()【順方向分割】・rsplit()【逆方向分割】
splitlines()【行分割】

メモ

構文

str.split(sep=None, maxsplit=-1)
str.rsplit(sep=None, maxsplit=-1)
str.splitlines([keepends])

戻り値分割後のリスト
sep区切り文字列 (省略:1個以上の空白文字 / 先頭・後尾空白は削除)
maxsplit最大分割回数 (リスト要素数:maxsplit + 1)
keepends行保持の有無 (省略:行の保持なし / True / False)

行は下記で分割 (終末の行は対象外)

行表現備考
\n改行
\r復帰
\r\n改行 + 復帰
\v
\x0b
垂直タブ 3.2
\f
\x0c
改ページ 3.2
\x1cファイル区切り
\x1dグループ区切り
\x1eレコード区切り
\x85改行 (C1 制御コード)
\u2028行区切り
\u2029段落区切り

s1 = "The quick brown fox jumps over the lazy dog."
s2 = "  The  quick  brown  fox  jumps  over  the  lazy  dog.  "
s3 = "111,,333,444,555,,,888,999,"

print("split()")
print("(A)", s1.split())
print("(B)", s1.split(maxsplit=3))
print("(C)", s2.split())
print("(D)", s2.split(maxsplit=3))
print("(E)", s3.split(","))
print("(F)", s3.split(",", maxsplit=3))
print("(G)", s3.split(",,"))

print("\nrsplit()")
print("(A)", s1.rsplit())
print("(B)", s1.rsplit(maxsplit=3))
print("(C)", s2.rsplit())
print("(D)", s2.rsplit(maxsplit=3))
print("(E)", s3.rsplit(","))
print("(F)", s3.rsplit(",", maxsplit=3))
print("(G)", s3.rsplit(",,"))
【出力例】
split()
(A) ['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog.']
(B) ['The', 'quick', 'brown', 'fox jumps over the lazy dog.']
(C) ['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog.']
(D) ['The', 'quick', 'brown', 'fox  jumps  over  the  lazy  dog.  ']
(E) ['111', '', '333', '444', '555', '', '', '888', '999', '']
(F) ['111', '', '333', '444,555,,,888,999,']
(G) ['111', '333,444,555', ',888,999,']

rsplit()
(A) ['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog.']
(B) ['The quick brown fox jumps over', 'the', 'lazy', 'dog.']
(C) ['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog.']
(D) ['  The  quick  brown  fox  jumps  over', 'the', 'lazy', 'dog.']
(E) ['111', '', '333', '444', '555', '', '', '888', '999', '']
(F) ['111,,333,444,555,,', '888', '999', '']
(G) ['111', '333,444,555,', '888,999,']
s = "The quick brown\rfox\njumps over\nthe lazy\r\ndog.\n"

tbl = str.maketrans({"\r": "\\r", "\n": "\\n"})
print(s.translate(tbl))
print(s.splitlines())
print(s.splitlines(True))
【出力例】
The quick brown\rfox\njumps over\nthe lazy\r\ndog.\n
['The quick brown', 'fox', 'jumps over', 'the lazy', 'dog.']
['The quick brown\r', 'fox\n', 'jumps over\n', 'the lazy\r\n', 'dog.\n']

partition()【順方向2分割】・rpartition()【逆方向2分割】

メモ

  • 区切り文字列で2分割
    メソッド備考
    partition()【順方向2分割】順方向で2分割
    rpartition()【逆方向2分割】逆方向で2分割
  • 関連

構文

str.partition(sep)
str.rpartition(sep)

戻り値タプル (区切りの前部分, 区切り文字列, 区切りの後ろ部分)
(分割不可:元の文字列と2つの空文字列)
sep区切り文字列

s = "The quick brown fox jumps over the lazy dog."
print(s.partition(" "))
print(s.partition("-"))
print(s.rpartition(" "))
print(s.rpartition("-"))
【出力例】
('The', ' ', 'quick brown fox jumps over the lazy dog.')
('The quick brown fox jumps over the lazy dog.', '', '')
('The quick brown fox jumps over the lazy', ' ', 'dog.')
('', '', 'The quick brown fox jumps over the lazy dog.')

replace()【置換】

メモ

構文

str.replace(old, new[, count])

戻り値置換後の文字列
old置換前文字列
new置換後文字列
count置換数

s = "The quick brown fox jumps over the lazy dog."
print(s.replace("fox", "cat"))
print(s.replace("o", "O"))
print(s.replace("o", "O", 2))
【出力例】
The quick brown cat jumps over the lazy dog.
The quick brOwn fOx jumps Over the lazy dOg.
The quick brOwn fOx jumps over the lazy dog.

join()【結合】

メモ

  • 文字列の結合
    • セパレータ:メソッドを呼び出す文字列
  • 関連

構文

str.join(iterable)

戻り値結合後の文字列
iterableイテラブルオブジェクト
例外TypeError (非文字列)

lst = ["cat", "dog", "fox"]
print("".join(lst))
print(",".join(lst))
print(", ".join(lst))

dic = {"animal1": "cat", "animal2": "dog", "animal3": "fox"}
print(", ".join(dic))
【出力例】
catdogfox
cat,dog,fox
cat, dog, fox
animal1, animal2, animal3

expandtabs()【タブ展開】

メモ

構文

str.expandtabs(tabsize= 8)

戻り値タブ文字をスペースに置換した文字列
tabsize展開するスペース個数

s = "*\t***\t*****\t*******"
print(s.translate({0x09: "\\t"}))
print("+123456789+123456789+123456789")
print(s.expandtabs())
print(s.expandtabs(4))
【出力例】
*\t***\t*****\t*******
+123456789+123456789+123456789
*       ***     *****   *******
*   *** *****   *******

encode()【エンコード】

メモ

構文

str.encode(encoding="utf-8", errors="strict")

戻り値エンコードされたバイト列オブジェクト
encodingエンコーディング (標準エンコーディング 下記に一部抜粋)
errorsエラー処理 (下記が指定可能)
"strict":UnicodeError 例外
"ignore":無視
"replace":'?' で置換
"xmlcharrefreplace":XML 文字参照で置換 (&#nnnn;)
"backslashreplace":バックスラッシュ付きエスケープシーケンスで置換 ("\\uxxxx")
codecs.register_error() で登録された関数:登録関数呼び出し
例外UnicodeError

標準エンコーディング (抜粋)

エンコーディング別名備考
ascii646
us-ascii
ASCII
cp932932
ms932
mskanji
ms-kanji
コードページ 932
euc_jpeuc-jp
eucjp
ujis
u-jis
日本語EUC
shift_jisshift-jis
csshiftjis
shiftjis
sjis
s_jis
Shift_JIS
utf_7utf-7
U7
unicode-1-1-utf-7
UTF-7
utf_8utf-8
U8
UTF
utf8
UTF-16
utf_16utf-16
U16
utf16
UTF-16
utf_32utf-32
U32
utf32
UTF-32

s = "あいう"
print(s)
for c in s:
    unicode = ord(c)
    utf8 = c.encode()
    sjis = c.encode("shift-jis")
    print("{0} 0x{1:04X} {2} {3}".format(c, unicode, utf8, sjis))
print(s.encode())

try:
    print(s.encode("ascii", "strict"))
except UnicodeError as e:
    print(type(e), e.args)
print(s.encode("ascii", "ignore"))
print(s.encode("ascii", "replace"))
print(s.encode("ascii", "xmlcharrefreplace"))
print(s.encode("ascii", "backslashreplace"))
【出力例】
あいう
あ 0x3042 b'\xe3\x81\x82' b'\x82\xa0'
い 0x3044 b'\xe3\x81\x84' b'\x82\xa2'
う 0x3046 b'\xe3\x81\x86' b'\x82\xa4'
b'\xe3\x81\x82\xe3\x81\x84\xe3\x81\x86'
<class 'UnicodeEncodeError'> ('ascii', 'あいう', 0, 3, 'ordinal not in range(128)')
b''
b'???'
b'&#12354;&#12356;&#12358;'
b'\\u3042\\u3044\\u3046'

count()【出現回数】

メモ

構文

str.count(sub[, start[, end]])

戻り値出現回数
sub検索文字列
start検索範囲開始位置インデックス (0≦:先頭から / <0:後尾から)
end検索範囲終了位置インデックス (0≦:先頭から / <0:後尾から)

s1 = "The quick brown fox jumps over the lazy dog.".lower()
r1 = "0123456789+123456789+123456789+123456789+123"
r2 = "4321+987654321+987654321+987654321+987654321"
print(s1)
print(r1)
print(r2)

print(s1.count(" "), "'(SP)'")
print(s1.count("the"), "'the'")
print(s1.count("the", 1), "'the', 1")
print(s1.count("o"), "'o'")
print(s1.count("o", 12, -2), "'o', 12, -2")
print(s1.count("o", 13, -3), "'o', 13, -3")
print(s1.count("mouse"), "'mouse'")

for i in range(ord('a'), (ord('z') + 1)):
    c = chr(i)
    count = s1.count(c)
    if 1 < count:
        print(c, count)

s2 = "AAAAAA"
print(s2)
print(s2.count("AA"))
print(s2.count("AA", 1))
【出力例】
the quick brown fox jumps over the lazy dog.
0123456789+123456789+123456789+123456789+123
4321+987654321+987654321+987654321+987654321
8 '(SP)'
2 'the'
1 'the', 1
4 'o'
4 'o', 12, -2
2 'o', 13, -3
0 'mouse'
e 3
h 2
o 4
r 2
t 2
u 2
AAAAAA
3
2

translate()【文字変換】・maketrans()【文字変換テーブル作成】

メモ

  • 文字列中の文字を変換
    メソッド備考
    translate()【文字変換】文字を変換
    static maketrans()
    【文字変換テーブル作成】
    translate()【文字変換】で使用する文字変換テーブルを簡単に作成
    (静的メソッド)
  • 関連

構文

str.translate(table)
static str.maketrans(x[, y[, z]])

戻り値変換後の文字列
table文字変換テーブル ( Unicode コードポイントで __getitem__() を実装するオブジェクト )
x引数の個数による
引数が1個:辞書 (【1文字】, 【Unicode コードポイント・文字列・None】)
引数が複数:文字列 (1文字毎に対応)
yx と同じ長さの文字列 (変換する1文字毎に対応)
z文字列 (1文字毎に削除)

s = "The quick brown fox jumps over the lazy dog."
print(s)

tbl1 = str.maketrans({'x': "(X)", 'y': "(Y)", 'z': "(Z)", 'e': None})
print(tbl1)
print(s.translate(tbl1))

tbl2 = str.maketrans("abcxyz", "ABCXYZ")
print(tbl2)
print(s.translate(tbl2))

tbl3 = str.maketrans("o", "_", "abc")
print(tbl3)
print(s.translate(tbl3))

#      SP        x             y   Y     z     Z
lst = {' ': "=", 0x78: "(X)", 'y': 0x59, 0x7A: 0x5A}
tbl4 = str.maketrans(lst)
print(tbl4)
print(s.translate(tbl4))
【出力例】
The quick brown fox jumps over the lazy dog.
{120: '(X)', 121: '(Y)', 122: '(Z)', 101: None}
Th quick brown fo(X) jumps ovr th la(Z)(Y) dog.
{97: 65, 98: 66, 99: 67, 120: 88, 121: 89, 122: 90}
The quiCk Brown foX jumps over the lAZY dog.
{111: 95, 97: None, 98: None, 99: None}
The quik r_wn f_x jumps _ver the lzy d_g.
{32: '=', 120: '(X)', 121: 89, 122: 90}
The=quick=brown=fo(X)=jumps=over=the=laZY=dog.
# 参考
s = "The quick brown fox jumps over the lazy dog."
print(s)
array = ' '*0x61 + "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
lst = list(array)
lst[0x20] = '-'  # SP
lst[0x54] = 't'  # 'T'
lst[0x2E] = '@'  # '.'
tbl1 = "".join(lst)
print(s.translate(tbl1))

#                  'x'          'y'          'z'          'o'
print(s.translate({0x78: "(X)", 0x79: "(Y)", 0x7A: "(Z)", 0x6F: None}))
【出力例】
The quick brown fox jumps over the lazy dog.
tHE-QUICK-BROWN-FOX-JUMPS-OVER-THE-LAZY-DOG@
The quick brwn f(X) jumps ver the la(Z)(Y) dg.

format()【書式化】・format_map()【書式化 (マッピング)】3.2

メモ

構文

str.format(*args, **kwargs)
str.format_map(mapping) 3.2

str (呼び出し文字列)置換フィールドを含んだ文字列
戻り値置換フィールドを置換した文字列
*args置換フィールドに対応する位置引数
**kwargs置換フィールドに対応するキーワード引数
mapping置換フィールドに対応する辞書

置換フィールド{[field_name][!conversion][:format_spec]}
同一置換フィールドを複数指定可能
{} を通常の文字とするには、二重表現 {{}}
入れ子:format_specには置換フィールドの指定可能 (例:フィールド幅を置換フィールドで指定)
field_name対応する引数の指定 
field_name備考
省略 3.1引数の位置を 0から順に割り当て
フィールド名キーワード引数
引数の位置番号引数の位置 (0~)
(上記の後に属性・個別要素を複数指定可)
.属性名属性
[要素番号]要素 (番号指定)
[要素名]要素 (名前指定)
(要素名はクォート無し:数字文字列の要素名は不可)
!conversion型変換
conversion備考
sstr()【文字列型】 呼び出し
rrepr()【印字可能文字列変換】 呼び出し
aascii()【印字可能文字列変換 (エスケープ)】 呼び出し
:format_spec書式指定 (フィールド幅・文字揃え・埋め方・精度 等)
[[fill]align][sign][#][0][width][grouping_option][.precision][type]
fill埋め込み文字 (省略:空白文字)
align揃え
align備考
<左揃え
>右揃え
=符号の後ろをパディング (数値型のみ)
^中央揃え
sign符号 (数値型のみ)
sign備考
+正数・負数ともに符号出力
-負数のみ符号出力 (デフォルト)
(SP)負数は符号出力、正数は空白
#別形式
備考
整数 (2進数)0b~
整数 (8進数)0o~
整数 (16進数)0x~・0X~
整数 (10進数)
浮動小数点数
複素数
小数点以下に数字が無くても小数点文字を出力
但し、g・G 指定では小数点文字と0を出力
0ゼロパディング (数値型のみ有効)
width最小フィールド幅
grouping_optionグルーピング指定
grouping_option備考
_  3.6 浮動小数点数の表現型・整数の表現型 d【10進数】:3 桁毎の区切りにアンダースコア
整数の表現型 b【2進数】・o【8進数】・x【16進数 (小文字)】・X【16進数 (大文字)】:4 桁毎の区切りにアンダースコア
,  3.13 桁毎の区切りにカンマ
.precision精度・最大フィールド幅
備考
浮動小数点数 (f・F)小数点以下の桁数
浮動小数点数 (g・G)小数点の前後の桁数
非数型最大フィールド幅
type表現型
文字列
type備考
s文字列 (デフォルト) 通常省略
省略s【文字列】 と同じ
整数
type備考
b2進数
c文字 (数値に対応する Unicode 文字に変換)
d10進数
o8進数
x16進数 (小文字)
X16進数 (大文字)
n10進数 (現在ロケールの区切り文字挿入)
省略d【10進数】 と同じ
浮動小数点数・整数 (n・省略 以外)
type備考
e指数表記 (e【指数】は小文字)
E指数表記 (E【指数】は大文字)
f固定小数点数表記 (nan【非数】・inf【無限大】は小文字)
F固定小数点数表記 (NAN【非数】・INF【無限大】は大文字)
g 固定小数点数表記 但し、表現が困難になると指数表記 (詳細は、 書式指定ミニ言語仕様 type 参照)
(e【指数】・nan【非数】・inf【無限大】は小文字)
G 固定小数点数表記 但し、表現が困難になると指数表記 (詳細は、 書式指定ミニ言語仕様 type 参照)
(E【指数】・NAN【非数】・INF【無限大】は大文字)
n数値
%固定小数点数表記でパーセンテージ表記
省略

print("{} {} {}【フィールド省略】".format("P0", "P1", "P2"))
print("{p2} {p1} {p0} {p2}【フィールド名指定】".format(p0="P0", p1="P1", p2="P2"))
print("{2} {1} {0} {2}【引数の位置番号指定】".format("P0", "P1", "P2"))
x = 2
y = 3
z = x * y
s = "{0} * {1} = {result}【引数の位置番号指定・フィールド名指定】"
print(s.format(x, y, result = z))
print("{{{}}} {{{}}} {{{}}}【{{と}}の出力】".format("P0", "P1", "P2"))

dic = {"p0": "P0", "p1": "P1", "p2": "P2"}
print("{p2} {p1} {p0} {p2}【format_map()】".format_map(dic))

print("【置換フィールドの入れ子】")
s = "({:*<{width}s}) ({:*>{width}s}) ({:*^{width}s})"
print(s.format("A0", "A1", "A2", width=4))
print(s.format("A0", "A1", "A2", width=8))

dic = {"b0": "B0", "b1": "B1", "b2": "B2", "width": 6}
s = "({b0:*<{width}s}) ({b1:*>{width}s}) ({b2:*^{width}s})"
print(s.format_map(dic))
【出力例】
P0 P1 P2【フィールド省略】
P2 P1 P0 P2【フィールド名指定】
P2 P1 P0 P2【引数の位置番号指定】
2 * 3 = 6【引数の位置番号指定・フィールド名指定】
{P0} {P1} {P2}【{と}の出力】
P2 P1 P0 P2【format_map()】
【置換フィールドの入れ子】
(A0**) (**A1) (*A2*)
(A0******) (******A1) (***A2***)
(B0****) (****B1) (**B2**)
class FldA:
    def __init__(self, attr):
        self.attr0 = attr


fld1 = FldA("ATTR0")
setattr(fld1, "attr1", "ATTR1")
print("{0.attr0} {0.attr1}【属性名】".format(fld1))

fld2 = [123, 456]
print("{0[0]} {0[1]}【要素番号】".format(fld2))

fld3 = {"item1": "ITEM1", "item2": "ITEM2", "item3": "ITEM3"}
print("{0[item1]} {0[item2]} {0[item3]}【要素名】".format(fld3))

fld41 = FldA("ATTR41")
fld42 = FldA("ATTR42")
fld4 = [fld41, fld42]
setattr(fld4[0], "attr4a", "ATTR4A")
setattr(fld4[1], "attr4b", "ATTR4B")
s= "{0[0].attr0} {0[0].attr4a} {0[1].attr0} {0[1].attr4b}【要素番号+属性名】"
print(s.format(fld4))
【出力例】
ATTR0 ATTR1【属性名】
123 456【要素番号】
ITEM1 ITEM2 ITEM3【要素名】
ATTR41 ATTR4A ATTR42 ATTR4B【要素番号+属性名】
lst = [
    "{}",
    "{:10}",
    "{:<10s}",
    "{:>10s}",
    "{:^10s}",
    "{:*<10s}",
    "{:*>10s}",
    "{:*^10s}",
    "{:*^5.5s}",
    "{:*^4.7s}",
]
for s in lst:
    fmt1 = s.format("STRING")
    fmt2 = s.format("str")
    print("({}) ({})\t'{}'".format(fmt1, fmt2, s))
【出力例】
(STRING) (str)  '{}'
(STRING    ) (str       )   '{:10}'
(STRING    ) (str       )   '{:&lt;10s}'
(    STRING) (       str)   '{:&gt;10s}'
(  STRING  ) (   str    )   '{:^10s}'
(STRING****) (str*******)   '{:*&lt;10s}'
(****STRING) (*******str)   '{:*&gt;10s}'
(**STRING**) (***str****)   '{:*^10s}'
(STRIN) (*str*) '{:*^5.5s}'
(STRING) (str*) '{:*^4.7s}'
lst = [
    "{}",
    "{:,d}",
    "{:_d}",
    "{:15d}",
    "{:<15d}",
    "{:>15d}",
    "{:=15d}",
    "{:^15d}",
    "{:*<15d}",
    "{:*>15d}",
    "{:*=15d}",
    "{:*^15d}",
    "{:15d}",
    "{:+015d}",
    "{:-015d}",
    "{: 015d}",
    "{:15_d}",
    "{:15,d}",
    "{:015d}",
    "{:015_d}",
    "{:015,d}",
]
for s in lst:
    fmt1 = s.format(123456789)
    fmt2 = s.format(-123456789)
    print("({}) ({})\t'{}'".format(fmt1, fmt2, s))
【出力例】
(123456789) (-123456789)    '{}'
(123,456,789) (-123,456,789)    '{:,d}'
(123_456_789) (-123_456_789)    '{:_d}'
(      123456789) (     -123456789) '{:15d}'
(123456789      ) (-123456789     ) '{:&lt;15d}'
(      123456789) (     -123456789) '{:&gt;15d}'
(      123456789) (-     123456789) '{:=15d}'
(   123456789   ) (  -123456789   ) '{:^15d}'
(123456789******) (-123456789*****) '{:*&lt;15d}'
(******123456789) (*****-123456789) '{:*&gt;15d}'
(******123456789) (-*****123456789) '{:*=15d}'
(***123456789***) (**-123456789***) '{:*^15d}'
(      123456789) (     -123456789) '{:15d}'
(+00000123456789) (-00000123456789) '{:+015d}'
(000000123456789) (-00000123456789) '{:-015d}'
( 00000123456789) (-00000123456789) '{: 015d}'
(    123_456_789) (   -123_456_789) '{:15_d}'
(    123,456,789) (   -123,456,789) '{:15,d}'
(000000123456789) (-00000123456789) '{:015d}'
(000_123_456_789) (-00_123_456_789) '{:015_d}'
(000,123,456,789) (-00,123,456,789) '{:015,d}'
lst = [
    "{:b}",
    "{:12b}",
    "{:012b}",
    "{:*<12b}",
    "{:*>12b}",
    "{:*=12b}",
    "{:*^12b}",
    "{:+012b}",
    "{:-012b}",
    "{: 012b}",
    "{:#b}",
    "{:_b}",
    "{:#_b}",
    "{:#012_b}",
]
for s in lst:
    fmt1 = s.format(0b101010)
    fmt2 = s.format(-0b101010)
    print("({}) ({})\t'{}'".format(fmt1, fmt2, s))
【出力例】
(101010) (-101010)  '{:b}'
(      101010) (     -101010)   '{:12b}'
(000000101010) (-00000101010)   '{:012b}'
(101010******) (-101010*****)   '{:*<12b}'
(******101010) (*****-101010)   '{:*>12b}'
(******101010) (-*****101010)   '{:*=12b}'
(***101010***) (**-101010***)   '{:*^12b}'
(+00000101010) (-00000101010)   '{:+012b}'
(000000101010) (-00000101010)   '{:-012b}'
( 00000101010) (-00000101010)   '{: 012b}'
(0b101010) (-0b101010)  '{:#b}'
(10_1010) (-10_1010)    '{:_b}'
(0b10_1010) (-0b10_1010)    '{:#_b}'
(0b0_0010_1010) (-0b0010_1010)  '{:#012_b}'
lst = [
    "{:o}",
    "{:12o}",
    "{:012o}",
    "{:*<12o}",
    "{:*>12o}",
    "{:*=12o}",
    "{:*^12o}",
    "{:+012o}",
    "{:-012o}",
    "{: 012o}",
    "{:#o}",
    "{:_o}",
    "{:#_o}",
    "{:#012_o}",
]
for s in lst:
    fmt1 = s.format(0o1234567)
    fmt2 = s.format(-0o1234567)
    print("({}) ({})\t'{}'".format(fmt1, fmt2, s))
【出力例】
(1234567) (-1234567)    '{:o}'
(     1234567) (    -1234567)   '{:12o}'
(000001234567) (-00001234567)   '{:012o}'
(1234567*****) (-1234567****)   '{:*<12o}'
(*****1234567) (****-1234567)   '{:*>12o}'
(*****1234567) (-****1234567)   '{:*=12o}'
(**1234567***) (**-1234567**)   '{:*^12o}'
(+00001234567) (-00001234567)   '{:+012o}'
(000001234567) (-00001234567)   '{:-012o}'
( 00001234567) (-00001234567)   '{: 012o}'
(0o1234567) (-0o1234567)    '{:#o}'
(123_4567) (-123_4567)  '{:_o}'
(0o123_4567) (-0o123_4567)  '{:#_o}'
(0o0_0123_4567) (-0o0123_4567)  '{:#012_o}'
lst = [
    ("{:x}", "{:X}"),
    ("{:12x}", "{:12X}"),
    ("{:012x}", "{:012X}"),
    ("{:*<12x}", "{:*<12X}"),
    ("{:*>12x}", "{:*>12X}"),
    ("{:*=12x}", "{:*=12X}"),
    ("{:*^12x}", "{:*^12X}"),
    ("{:+012x}", "{:+012X}"),
    ("{:-012x}", "{:-012X}"),
    ("{: 012x}", "{: 012X}"),
    ("{:#x}", "{:#X}"),
    ("{:_x}", "{:_X}"),
    ("{:#_x}", "{:#_X}"),
    ("{:#012_x}", "{:#012_X}"),
]
for (s1, s2) in lst:
    fmt1 = s1.format(0x123ABC)
    fmt2 = s1.format(-0x123ABC)
    fmt3 = s2.format(0x123ABC)
    fmt4 = s2.format(-0x123ABC)
    print("({}) ({}) ({}) ({}) '{} {}'".format(fmt1, fmt2, fmt3, fmt4, s1, s2))
【出力例】
(123abc) (-123abc) (123ABC) (-123ABC) '{:x} {:X}'
(      123abc) (     -123abc) (      123ABC) (     -123ABC) '{:12x} {:12X}'
(000000123abc) (-00000123abc) (000000123ABC) (-00000123ABC) '{:012x} {:012X}'
(123abc******) (-123abc*****) (123ABC******) (-123ABC*****) '{:*<12x} {:*<12X}'
(******123abc) (*****-123abc) (******123ABC) (*****-123ABC) '{:*>12x} {:*>12X}'
(******123abc) (-*****123abc) (******123ABC) (-*****123ABC) '{:*=12x} {:*=12X}'
(***123abc***) (**-123abc***) (***123ABC***) (**-123ABC***) '{:*^12x} {:*^12X}'
(+00000123abc) (-00000123abc) (+00000123ABC) (-00000123ABC) '{:+012x} {:+012X}'
(000000123abc) (-00000123abc) (000000123ABC) (-00000123ABC) '{:-012x} {:-012X}'
( 00000123abc) (-00000123abc) ( 00000123ABC) (-00000123ABC) '{: 012x} {: 012X}'
(0x123abc) (-0x123abc) (0X123ABC) (-0X123ABC) '{:#x} {:#X}'
(12_3abc) (-12_3abc) (12_3ABC) (-12_3ABC) '{:_x} {:_X}'
(0x12_3abc) (-0x12_3abc) (0X12_3ABC) (-0X12_3ABC) '{:#_x} {:#_X}'
(0x0_0012_3abc) (-0x0012_3abc) (0X0_0012_3ABC) (-0X0012_3ABC) '{:#012_x} {:#012_X}'
lst = [
    "{:e}",
    "{:E}",
    "{:0e}",
    "{:0E}",
    "{:+e}",
    "{:+E}",
    "{: e}",
    "{: E}",
    "{:15e}",
    "{:15E}",
    "{:015e}",
    "{:015E}",
    "{:+15e}",
    "{:+15E}",
    "{:-15e}",
    "{:-15E}",
    "{: 15e}",
    "{: 15E}",
    "{:15.1e}",
    "{:15.1E}",
    "{:15.0e}",
    "{:15.0E}",
    "{:#15.0e}",
    "{:#15.0E}",
]
for s in lst:
    fmt1 = s.format(123.456)
    fmt2 = s.format(-123.456)
    print("({}) ({})\t'{}'".format(fmt1, fmt2, s))

print("({0:5e}) ({0:5E})".format(float("NaN")))
print("({0:5e}) ({0:5E})".format(float("inf")))
【出力例】
(1.234560e+02) (-1.234560e+02)  '{:e}'
(1.234560E+02) (-1.234560E+02)  '{:E}'
(1.234560e+02) (-1.234560e+02)  '{:0e}'
(1.234560E+02) (-1.234560E+02)  '{:0E}'
(+1.234560e+02) (-1.234560e+02) '{:+e}'
(+1.234560E+02) (-1.234560E+02) '{:+E}'
( 1.234560e+02) (-1.234560e+02) '{: e}'
( 1.234560E+02) (-1.234560E+02) '{: E}'
(   1.234560e+02) (  -1.234560e+02) '{:15e}'
(   1.234560E+02) (  -1.234560E+02) '{:15E}'
(0001.234560e+02) (-001.234560e+02) '{:015e}'
(0001.234560E+02) (-001.234560E+02) '{:015E}'
(  +1.234560e+02) (  -1.234560e+02) '{:+15e}'
(  +1.234560E+02) (  -1.234560E+02) '{:+15E}'
(   1.234560e+02) (  -1.234560e+02) '{:-15e}'
(   1.234560E+02) (  -1.234560E+02) '{:-15E}'
(   1.234560e+02) (  -1.234560e+02) '{: 15e}'
(   1.234560E+02) (  -1.234560E+02) '{: 15E}'
(        1.2e+02) (       -1.2e+02) '{:15.1e}'
(        1.2E+02) (       -1.2E+02) '{:15.1E}'
(          1e+02) (         -1e+02) '{:15.0e}'
(          1E+02) (         -1E+02) '{:15.0E}'
(         1.e+02) (        -1.e+02) '{:#15.0e}'
(         1.E+02) (        -1.E+02) '{:#15.0E}'
(  nan) (  NAN)
(  inf) (  INF)
lst = [
    "{:f}",
    "{:F}",
    "{:0f}",
    "{:0F}",
    "{:+f}",
    "{:+F}",
    "{: f}",
    "{: F}",
    "{:,f}",
    "{:,F}",
    "{:15f}",
    "{:15F}",
    "{:015f}",
    "{:015F}",
    "{:+15f}",
    "{:+15F}",
    "{:-15f}",
    "{:-15F}",
    "{: 15f}",
    "{: 15F}",
    "{:15,f}",
    "{:15,F}",
    "{:15.1f}",
    "{:15.1F}",
    "{:15.0f}",
    "{:15.0F}",
    "{:#15.0f}",
    "{:#15.0F}",

    "{:#15.1f}",
    "{:#15.2f}",
    "{:#15.3f}",
    "{:#15.4f}",
    "{:#15.5f}",
]
for s in lst:
    fmt1 = s.format(1234.5678)
    fmt2 = s.format(-1234.5678)
    print("({}) ({})\t'{}'".format(fmt1, fmt2, s))

print("({0:5f}) ({0:5F})".format(float("NaN")))
print("({0:5f}) ({0:5F})".format(float("inf")))
【出力例】
(1234.567800) (-1234.567800)    '{:f}'
(1234.567800) (-1234.567800)    '{:F}'
(1234.567800) (-1234.567800)    '{:0f}'
(1234.567800) (-1234.567800)    '{:0F}'
(+1234.567800) (-1234.567800)   '{:+f}'
(+1234.567800) (-1234.567800)   '{:+F}'
( 1234.567800) (-1234.567800)   '{: f}'
( 1234.567800) (-1234.567800)   '{: F}'
(1,234.567800) (-1,234.567800)  '{:,f}'
(1,234.567800) (-1,234.567800)  '{:,F}'
(    1234.567800) (   -1234.567800) '{:15f}'
(    1234.567800) (   -1234.567800) '{:15F}'
(00001234.567800) (-0001234.567800) '{:015f}'
(00001234.567800) (-0001234.567800) '{:015F}'
(   +1234.567800) (   -1234.567800) '{:+15f}'
(   +1234.567800) (   -1234.567800) '{:+15F}'
(    1234.567800) (   -1234.567800) '{:-15f}'
(    1234.567800) (   -1234.567800) '{:-15F}'
(    1234.567800) (   -1234.567800) '{: 15f}'
(    1234.567800) (   -1234.567800) '{: 15F}'
(   1,234.567800) (  -1,234.567800) '{:15,f}'
(   1,234.567800) (  -1,234.567800) '{:15,F}'
(         1234.6) (        -1234.6) '{:15.1f}'
(         1234.6) (        -1234.6) '{:15.1F}'
(           1235) (          -1235) '{:15.0f}'
(           1235) (          -1235) '{:15.0F}'
(          1235.) (         -1235.) '{:#15.0f}'
(          1235.) (         -1235.) '{:#15.0F}'
(         1234.6) (        -1234.6) '{:#15.1f}'
(        1234.57) (       -1234.57) '{:#15.2f}'
(       1234.568) (      -1234.568) '{:#15.3f}'
(      1234.5678) (     -1234.5678) '{:#15.4f}'
(     1234.56780) (    -1234.56780) '{:#15.5f}'
(  nan) (  NAN)
(  inf) (  INF)
lst = [
    "{:g}",
    "{:G}",
    "{:0g}",
    "{:0G}",
    "{:+g}",
    "{:+G}",
    "{: g}",
    "{: G}",
    "{:8g}",
    "{:8G}",
    "{:08g}",
    "{:08G}",
    "{:+8g}",
    "{:+8G}",
    "{:-8g}",
    "{:-8G}",
    "{: 8g}",
    "{: 8G}",
    "{:8.1g}",
    "{:8.1G}",
    "{:8.0g}",
    "{:8.0G}",
    "{:#8.0g}",
    "{:#8.0G}",

    "{:#8.1g}",
    "{:#8.2g}",
    "{:#8.3g}",
    "{:#8.4g}",
    "{:#8.5g}",

]
for s in lst:
    fmt1 = s.format(123.456)
    fmt2 = s.format(-123.456)
    fmt3 = s.format(123456789)
    fmt4 = s.format(-0.0000123456789)
    print("({}) ({})\t({}) ({})\t'{}'".format(fmt1, fmt2, fmt3, fmt4, s))

print("({0:5g}) ({0:5G})".format(float("NaN")))
print("({0:5g}) ({0:5G})".format(float("inf")))
【出力例】
(123.456) (-123.456)    (1.23457e+08) (-1.23457e-05)    '{:g}'
(123.456) (-123.456)    (1.23457E+08) (-1.23457E-05)    '{:G}'
(123.456) (-123.456)    (1.23457e+08) (-1.23457e-05)    '{:0g}'
(123.456) (-123.456)    (1.23457E+08) (-1.23457E-05)    '{:0G}'
(+123.456) (-123.456)   (+1.23457e+08) (-1.23457e-05)   '{:+g}'
(+123.456) (-123.456)   (+1.23457E+08) (-1.23457E-05)   '{:+G}'
( 123.456) (-123.456)   ( 1.23457e+08) (-1.23457e-05)   '{: g}'
( 123.456) (-123.456)   ( 1.23457E+08) (-1.23457E-05)   '{: G}'
( 123.456) (-123.456)   (1.23457e+08) (-1.23457e-05)    '{:8g}'
( 123.456) (-123.456)   (1.23457E+08) (-1.23457E-05)    '{:8G}'
(0123.456) (-123.456)   (1.23457e+08) (-1.23457e-05)    '{:08g}'
(0123.456) (-123.456)   (1.23457E+08) (-1.23457E-05)    '{:08G}'
(+123.456) (-123.456)   (+1.23457e+08) (-1.23457e-05)   '{:+8g}'
(+123.456) (-123.456)   (+1.23457E+08) (-1.23457E-05)   '{:+8G}'
( 123.456) (-123.456)   (1.23457e+08) (-1.23457e-05)    '{:-8g}'
( 123.456) (-123.456)   (1.23457E+08) (-1.23457E-05)    '{:-8G}'
( 123.456) (-123.456)   ( 1.23457e+08) (-1.23457e-05)   '{: 8g}'
( 123.456) (-123.456)   ( 1.23457E+08) (-1.23457E-05)   '{: 8G}'
(   1e+02) (  -1e+02)   (   1e+08) (  -1e-05)   '{:8.1g}'
(   1E+02) (  -1E+02)   (   1E+08) (  -1E-05)   '{:8.1G}'
(   1e+02) (  -1e+02)   (   1e+08) (  -1e-05)   '{:8.0g}'
(   1E+02) (  -1E+02)   (   1E+08) (  -1E-05)   '{:8.0G}'
(  1.e+02) ( -1.e+02)   (  1.e+08) ( -1.e-05)   '{:#8.0g}'
(  1.E+02) ( -1.E+02)   (  1.E+08) ( -1.E-05)   '{:#8.0G}'
(  1.e+02) ( -1.e+02)   (  1.e+08) ( -1.e-05)   '{:#8.1g}'
( 1.2e+02) (-1.2e+02)   ( 1.2e+08) (-1.2e-05)   '{:#8.2g}'
(    123.) (   -123.)   (1.23e+08) (-1.23e-05)  '{:#8.3g}'
(   123.5) (  -123.5)   (1.235e+08) (-1.235e-05)    '{:#8.4g}'
(  123.46) ( -123.46)   (1.2346e+08) (-1.2346e-05)  '{:#8.5g}'
(  nan) (  NAN)
(  inf) (  INF)
lst = [
    "{:%}",
    "{:*<15%}",
    "{:*>15%}",
    "{:*=15%}",
    "{:*^15%}",
    "{:+15%}",
    "{:-15%}",
    "{: 15%}",

    "{:*<12.4%}",
    "{:*>12.4%}",
    "{:*=12.4%}",
    "{:*^12.4%}",
    "{:+12.4%}",
    "{:-12.4%}",
    "{: 12.4%}",
]
for s in lst:
    fmt1 = s.format(0.1234)
    fmt2 = s.format(-0.1234)
    print("({}) ({})\t'{}'".format(fmt1, fmt2, s))
【出力例】
(12.340000%) (-12.340000%)  '{:%}'
(12.340000%*****) (-12.340000%****) '{:*<15%}'
(*****12.340000%) (****-12.340000%) '{:*>15%}'
(*****12.340000%) (-****12.340000%) '{:*=15%}'
(**12.340000%***) (**-12.340000%**) '{:*^15%}'
(    +12.340000%) (    -12.340000%) '{:+15%}'
(     12.340000%) (    -12.340000%) '{:-15%}'
(     12.340000%) (    -12.340000%) '{: 15%}'
(12.3400%****) (-12.3400%***)   '{:*<12.4%}'
(****12.3400%) (***-12.3400%)   '{:*>12.4%}'
(****12.3400%) (-***12.3400%)   '{:*=12.4%}'
(**12.3400%**) (*-12.3400%**)   '{:*^12.4%}'
(   +12.3400%) (   -12.3400%)   '{:+12.4%}'
(    12.3400%) (   -12.3400%)   '{:-12.4%}'
(    12.3400%) (   -12.3400%)   '{: 12.4%}'
import datetime
d = datetime.date(2001, 2, 3)
print("{:%Y-%m-%d}".format(d))
t = datetime.time(1, 2, 3)
print("{:%H:%M:%S}".format(t))
dt = datetime.datetime(2001, 2, 3, 4, 5, 6)
print("{:%Y-%m-%d %H:%M:%S}".format(dt))
【出力例】
2001-02-03
01:02:03
2001-02-03 04:05:06

% 演算子【printf 形式書式化】

メモ

構文

format % values

戻り値指定子を置換した文字列
format指定子を含んだ文字列
values置換要素 (下記の指定が可)
タプル (指定要素数分)
辞書 ((key) に対応)
その他オブジェクト

指定子%[(key)][flag][width][.precision][length]type
(key)マップキー (辞書の対応キー名)
flag変換フラグ (下記の組合せ)
flag備考
#別形式表記
0o~:符号付き 8 進数
0x~:符号付き 16 進数 (小文字)
0X~:符号付き 16 進数 (大文字)
0ゼロパディング
+正数・負数ともに符号出力 (SP フラグは上書き)
-左揃え (0 フラグは上書き)
(SP)負数は符号出力、正数は空白
width最小のフィールド幅
width備考
数字最小のフィールド幅
*タプルの要素を使用
.precision精度
precision備考
数字精度 (デフォルト:6)
*タプルの要素を使用
length精度長
length説明備考
hshort
unsigned short
未使用の為、無視
llong
unsigned long
Llong double
type変換型
type備考
aascii()【印字可能文字列変換 (エスケープ)】で変換
c文字
d符号付き 10 進数
e指数表記の浮動小数点数 (e【指数】・nan【非数】・inf【無限大】は小文字)
E指数表記の浮動小数点数 (E【指数】・NAN【非数】・INF【無限大】は大文字)
f10 進浮動小数点数 (nan【非数】・inf【無限大】は小文字)
F10 進浮動小数点数 (NAN【非数】・INF【無限大】は大文字)
g指数表記の自動切換 (e【指数】・nan【非数】・inf【無限大】は小文字)
指数部が -4 以上または精度以下:指数表記
その他:10進表記
G指数表記の自動切換 (E【指数】・NAN【非数】・INF【無限大】は大文字)
指数部が -4 以上または精度以下:指数表記
その他:10進表記
i符号付き 10 進数
o符号付き 8 進数
rrepr()【印字可能文字列変換】で変換
sstr()【文字列型】で変換
ud【符号付き 10 進数】と同じ
x符号付き 16 進数 (小文字)
X符号付き 16 進数 (大文字)
%% 文字

# オブジェクト
print("%d" % 1234)
# タプル
print("%d %f" % (1234, 123.456))
print("%0*d" % (8, 1234))
print("%0*.*f" % (16, 8, 1234.5678))
# 辞書
dic = {"key1": 1234, "key2": 123.456, "key3": "STRING"}
print("%(key1)d %(key2)f %(key3)s" % dic)
【出力例】
1234
1234 123.456000
00001234
0001234.56780000
1234 123.456000 STRING
s = "STRING"
print("(A) '%s'" % s)
print("(B) '%10s'" % s)
print("(C) '%-10s'" % s)
print("(D) '%*s'" % (10, s))
print("(E) '%(key1)-10s'" % {"key1": s})
【出力例】
(A) 'STRING'
(B) '    STRING'
(C) 'STRING    '
(D) '    STRING'
(E) 'STRING    '
lst = [
    "%+d",
    "%-d",
    "% d",
    "%08d",
    "%+8d",
    "%-8d",
    "% 8d" ,
    "%+08d",
    "% 08d",
]
for s in lst:
    s1 = s % 123456
    s2 = s % -123456
    print("({}) ({})\t'{}'".format(s1, s2, s))

print("(%*d)" % (8, 1234))
print("(%(key1)8d)" % {"key1": 1234})
【出力例】
(+123456) (-123456) '%+d'
(123456) (-123456)  '%-d'
( 123456) (-123456) '% d'
(00123456) (-0123456)   '%08d'
( +123456) ( -123456)   '%+8d'
(123456  ) (-123456 )   '%-8d'
(  123456) ( -123456)   '% 8d'
(+0123456) (-0123456)   '%+08d'
( 0123456) (-0123456)   '% 08d'
(    1234)
(    1234)
lst = [
    "%e",
    "%E",
    "%+e",
    "%+E",
    "% e",
    "% E",
    "%15e",
    "%15E",
    "%015e",
    "%015E",
    "%+15e",
    "%+15E",
    "%-15e",
    "%-15E",
    "% 15e",
    "% 15E",
    "%.1e",
    "%.1E",
]
for s in lst:
    s1 = s % 12.34
    s2 = s % -12.34
    print("({}) ({})\t'{}'".format(s1, s2, s))

nan = float("NaN")
inf = float("inf")
print("(%5e) (%5E)" % (nan, nan))
print("(%5e) (%5E)" % (inf, inf))

print("(%*e)" % (15, 12.34))
print("(%*.*e)" % (15, 1, 12.34))
print("(%(key1)e)" % {"key1": 12.34})
【出力例】
(1.234000e+01) (-1.234000e+01)  '%e'
(1.234000E+01) (-1.234000E+01)  '%E'
(+1.234000e+01) (-1.234000e+01) '%+e'
(+1.234000E+01) (-1.234000E+01) '%+E'
( 1.234000e+01) (-1.234000e+01) '% e'
( 1.234000E+01) (-1.234000E+01) '% E'
(   1.234000e+01) (  -1.234000e+01) '%15e'
(   1.234000E+01) (  -1.234000E+01) '%15E'
(0001.234000e+01) (-001.234000e+01) '%015e'
(0001.234000E+01) (-001.234000E+01) '%015E'
(  +1.234000e+01) (  -1.234000e+01) '%+15e'
(  +1.234000E+01) (  -1.234000E+01) '%+15E'
(1.234000e+01   ) (-1.234000e+01  ) '%-15e'
(1.234000E+01   ) (-1.234000E+01  ) '%-15E'
(   1.234000e+01) (  -1.234000e+01) '% 15e'
(   1.234000E+01) (  -1.234000E+01) '% 15E'
(1.2e+01) (-1.2e+01)    '%.1e'
(1.2E+01) (-1.2E+01)    '%.1E'
(  nan) (  NAN)
(  inf) (  INF)
(   1.234000e+01)
(        1.2e+01)
(1.234000e+01)
lst = [
    "%f",
    "%F",
    "%+f",
    "% f",
    "%12f",
    "%012f",
    "%+12f",
    "%-12f",
    "% 12f",
    "%.1f",
]
for s in lst:
    s1 = s % 12.34
    s2 = s % -12.34
    print("({}) ({})\t'{}'".format(s1, s2, s))

nan = float("NaN")
inf = float("inf")
print("(%5f) (%5F)" % (nan, nan))
print("(%5f) (%5F)" % (inf, inf))

print("(%*f)" % (12, 12.34))
print("(%*.*f)" % (12, 1, 12.34))
print("(%(key1)f)" % {"key1": 12.34})
【出力例】
(12.340000) (-12.340000)    '%f'
(12.340000) (-12.340000)    '%F'
(+12.340000) (-12.340000)   '%+f'
( 12.340000) (-12.340000)   '% f'
(   12.340000) (  -12.340000)   '%12f'
(00012.340000) (-0012.340000)   '%012f'
(  +12.340000) (  -12.340000)   '%+12f'
(12.340000   ) (-12.340000  )   '%-12f'
(   12.340000) (  -12.340000)   '% 12f'
(12.3) (-12.3)  '%.1f'
(  nan) (  NAN)
(  inf) (  INF)
(   12.340000)
(        12.3)
(12.340000)
lst = [
    "%g",
    "%G",
    "%+g",
    "%+G",
    "% g",
    "% G",
    "%12g",
    "%12G",
    "%012g",
    "%012G",
    "%+12g",
    "%+12G",
    "%-12g",
    "%-12G",
    "% 12g",
    "% 12G",
    "%.2g",
    "%.2G",
]
for s in lst:
    s1 = s % 1.234e-05
    s2 = s % 12.34
    s3 = s % -12.34
    print("({}) ({}) ({})\t'{}'".format(s1, s2, s3, s))

nan = float("NaN")
inf = float("inf")
print("(%5g) (%5G)" % (nan, nan))
print("(%5g) (%5G)" % (inf, inf))

print("(%*g)" % (12, 12.34))
print("(%*.*g)" % (12, 1, 12.34))
print("(%(key1)g)" % {"key1": 12.34})
【出力例】
(1.234e-05) (12.34) (-12.34)    '%g'
(1.234E-05) (12.34) (-12.34)    '%G'
(+1.234e-05) (+12.34) (-12.34)  '%+g'
(+1.234E-05) (+12.34) (-12.34)  '%+G'
( 1.234e-05) ( 12.34) (-12.34)  '% g'
( 1.234E-05) ( 12.34) (-12.34)  '% G'
(   1.234e-05) (       12.34) (      -12.34)    '%12g'
(   1.234E-05) (       12.34) (      -12.34)    '%12G'
(0001.234e-05) (000000012.34) (-00000012.34)    '%012g'
(0001.234E-05) (000000012.34) (-00000012.34)    '%012G'
(  +1.234e-05) (      +12.34) (      -12.34)    '%+12g'
(  +1.234E-05) (      +12.34) (      -12.34)    '%+12G'
(1.234e-05   ) (12.34       ) (-12.34      )    '%-12g'
(1.234E-05   ) (12.34       ) (-12.34      )    '%-12G'
(   1.234e-05) (       12.34) (      -12.34)    '% 12g'
(   1.234E-05) (       12.34) (      -12.34)    '% 12G'
(1.2e-05) (12) (-12)    '%.2g'
(1.2E-05) (12) (-12)    '%.2G'
(  nan) (  NAN)
(  inf) (  INF)
(       12.34)
(       1e+01)
(12.34)
lst = [
    "%x",
    "%X",
    "%#x",
    "%#X",
    "%+x",
    "%+X",
    "%#+x",
    "%#+X",
    "% x",
    "% X",
    "%4x",
    "%4X",
    "%#4x",
    "%#4X",
    "%04x",
    "%04X",
    "%#04x",
    "%#04X",
    "%+4x",
    "%+4X",
    "%-4x",
    "%-4X",
    "% 4x",
    "% 4X",
]
for s in lst:
    s1 = s % 255
    s2 = s % -255
    print("({}) ({})\t'{}'".format(s1, s2, s))

print("(%*x)" % (4, 255))
print("(%(key1)x)" % {"key1": 255})
【出力例】
(ff) (-ff)  '%x'
(FF) (-FF)  '%X'
(0xff) (-0xff)  '%#x'
(0XFF) (-0XFF)  '%#X'
(+ff) (-ff) '%+x'
(+FF) (-FF) '%+X'
(+0xff) (-0xff) '%#+x'
(+0XFF) (-0XFF) '%#+X'
( ff) (-ff) '% x'
( FF) (-FF) '% X'
(  ff) ( -ff)   '%4x'
(  FF) ( -FF)   '%4X'
(0xff) (-0xff)  '%#4x'
(0XFF) (-0XFF)  '%#4X'
(00ff) (-0ff)   '%04x'
(00FF) (-0FF)   '%04X'
(0xff) (-0xff)  '%#04x'
(0XFF) (-0XFF)  '%#04X'
( +ff) ( -ff)   '%+4x'
( +FF) ( -FF)   '%+4X'
(ff  ) (-ff )   '%-4x'
(FF  ) (-FF )   '%-4X'
(  ff) ( -ff)   '% 4x'
(  FF) ( -FF)   '% 4X'
(  ff)
(ff)

f'~'【フォーマット済み文字列リテラル】3.6

メモ

構文

f'置換フィールドを含んだ文字列 》'
使用可能なプリフィックス・引用符は、文字列作成 参照

置換フィールド{f_expression[!conversion][:format_spec]}
{} を通常の文字とするには、二重表現 {{}}

f_expression置換対象の式 (前後の空白は無視)
(conditional_expression | * or_expr)
  (, conditional_expression | , * or_expr)* [,]
| yield_expression
※ カンマを使用するとタプル指定 (丸カッコは省略可)
conversion型変換 (format()【書式化】conversion 参照)
format_spec書式指定 (format()【書式化】format_spec 参照)
入れ子:format_specには置換フィールドの指定可能 (例:フィールド幅を置換フィールドで指定)
conditional_expression式
指定可能・指定不可の例は下記参照
指定可能 例備考
即値例:{123}
変数要素名を指定する場合、引用符が必要
(format()【書式化】では不要)
関数呼び出し戻り値が複数の場合、タプル
lambda【ラムダ式 (無名関数)】: を使用する為、丸カッコで囲む
if-else【三項演算子】
算術演算等例:{x + y}
比較演算結果が True・False
指定不可 例備考
(空)例:{}
エスケープ例:{'\n'}
変数を使用して回避
yield【ジェネレータ関数・一時停止】 を除く
例:代入文 {i = 123}
#【コメント】
* or_exprアンパック対象 (def【関数定義】のアンパック 参照)
タプル指定が必要:単一の場合、最後にカンマ
yield_expressionyield【ジェネレータ関数・一時停止】

# 指定方法
n = 123
s = "STRING"
print(f"{n} {s} 【変数 (f\"~\")】")
print(F'{n:*<+10,} {s:*^10} 【書式指定 (F\'~\')】')
print(fr'''( {n}\n{s}

【三重引用符+raw 文字列】)''')
print(f"({s}) ({  s  }) ({    s    }) 【前後の空白は無視】")
fmt = f"{n} {s} 【実行時に式を評価】"
print(fmt)
n = 100
s = "STRING" * 10
print(fmt)

# 単純式
x = 2
y = 3
print(f"{x} * {y} = {x * y} 【計算式】")

print(f"x={x} y={y} [{'x < y' if x < y else 'y < x'}] 【三項演算子】")
x = 5
print(f"x={x} y={y} [{'x < y' if x < y else 'y < x'}] 【三項演算子】")

print(f"{x < y} 【比較】")
【出力例】
123 STRING 【変数 (f"~")】
+123****** **STRING** 【書式指定 (F'~')】
( 123\nSTRING

【三重引用符+raw 文字列】)
(STRING) (STRING) (STRING) 【前後の空白は無視】
123 STRING 【実行時に式を評価】
123 STRING 【実行時に式を評価】
2 * 3 = 6 【計算式】
x=2 y=3 [x < y] 【三項演算子】
x=5 y=3 [y < x] 【三項演算子】
False 【比較】
# 関数呼び出し
def func(x, y):
    return x, y

x = 2
y = 3
print(f"{x} ^ {y} = {pow(x, y)} 【関数呼び出し】")
print(f"func({x}, {y}) {func(x, y)} 【関数呼び出し (複数戻り値:タプル)】")

# ラムダ式 (丸カッコで囲む)
y = 2
print(f"{(lambda x: x * x)(y)} 【ラムダ式】")

# タプル・アンパック
print(f"{1} 【即値】")
print(f"{1,} 【タプル (単一指定:最後にカンマ)】")
print(f"{1, 2} 【タプル (複数指定)】")
print(f"{(1, 2)} 【タプル (丸カッコあり)】")
x = 1
y = 2
print(f"{x, y, x+y} 【タプル (計算式)】")

lst = ['L0', 'L1', 'L2']
print(f"{lst} 【リスト型】")
print(f"{lst[0]} {lst[1]} {lst[2]} 【リスト型 (個別要素)】")
print(f"{lst,} 【単一タプル (リスト型)】")
print(f"{*lst,} 【単一タプル (リスト型アンパック)】")
print(f"{lst, *lst} 【タプル (リスト型+リスト型アンパック)】")

dic = {'d0': 'D0', 'd1': 'D1', 'd2': 'D2'}
print(f"{dic} 【辞書型】")
print(f"{dic['d0']} {dic['d1']} {dic['d2']} 【辞書型 (個別要素)】")
print(f"{dic,} 【単一タプル (辞書型)】")
print(f"{*dic,} 【単一タプル (辞書型アンパック)】")
print(f"{dic, *dic} 【タプル (辞書型+辞書型アンパック)】")
【出力例】
2 ^ 3 = 8 【関数呼び出し】
func(2, 3) (2, 3) 【関数呼び出し (複数戻り値:タプル)】
4 【ラムダ式】
1 【即値】
(1,) 【タプル (単一指定:最後にカンマ)】
(1, 2) 【タプル (複数指定)】
(1, 2) 【タプル (丸カッコあり)】
(1, 2, 3) 【タプル (計算式)】
['L0', 'L1', 'L2'] 【リスト型】
L0 L1 L2 【リスト型 (個別要素)】
(['L0', 'L1', 'L2'],) 【単一タプル (リスト型)】
('L0', 'L1', 'L2') 【単一タプル (リスト型アンパック)】
(['L0', 'L1', 'L2'], 'L0', 'L1', 'L2') 【タプル (リスト型+リスト型アンパック)】
{'d0': 'D0', 'd1': 'D1', 'd2': 'D2'} 【辞書型】
D0 D1 D2 【辞書型 (個別要素)】
({'d0': 'D0', 'd1': 'D1', 'd2': 'D2'},) 【単一タプル (辞書型)】
('d0', 'd1', 'd2') 【単一タプル (辞書型アンパック)】
({'d0': 'D0', 'd1': 'D1', 'd2': 'D2'}, 'd0', 'd1', 'd2') 【タプル (辞書型+辞書型アンパック)】