str【文字列型】^{3.0～3.3 / 3.6～3.93.12}

s = str()
print(s, len(s), type(s))
# 出力： 0 <class 'str'>
s = str('STRING')
print(s, len(s), type(s))
# 出力：STRING 6 <class 'str'>
s = str(-123456)
print(s, len(s), type(s))
# 出力：-123456 7 <class 'str'>
s = str(-123.456)
print(s, len(s), type(s))
# 出力：-123.456 8 <class 'str'>

b1 = b'bin'
s = str(b1)
print(s, len(s), type(s))
# 出力：b'bin' 6 <class 'str'>
s = str(b1, 'utf-8')
print(s, len(s), type(s))
# 出力：bin 3 <class 'str'>

b2 = b'abc\x80xyz'
s = str(b2, errors='backslashreplace')
print(s, len(s), type(s))
# 出力：abc\x80xyz 10 <class 'str'>
s = str(b2, errors='ignore')
print(s, len(s), type(s))
# 出力：abcxyz 6 <class 'str'>

# 半角・全角・エスツェット (ドイツ語)
s = 'xYzXyZｘＹｚＸｙＺßẞ'
print(s)
# 出力：xYzXyZｘＹｚＸｙＺßẞ
print(s.upper())
# 出力：XYZXYZＸＹＺＸＹＺSSẞ
print(s.lower())
# 出力：xyzxyzｘｙｚｘｙｚßß
print(s.swapcase())
# 出力：XyZxYzＸｙＺｘＹｚSSß
print(s.casefold())
# 出力：xyzxyzｘｙｚｘｙｚssss

s1 = 'the quick brown fox jumps over the lazy dog.'
s2 = 'THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG.'
s3 = 'ｃａｔｓ ａｎｄ ｄｏｇｓ'
s4 = 'ＣＡＴＳ ＡＮＤ ＤＯＧＳ'
s5 = "'we're the world'"
s6 = 'ß ß'

print(s1.capitalize())
# 出力：The quick brown fox jumps over the lazy dog.
print(s2.capitalize())
# 出力：The quick brown fox jumps over the lazy dog.
print(s3.capitalize())
# 出力：Ｃａｔｓ ａｎｄ ｄｏｇｓ
print(s4.capitalize())
# 出力：Ｃａｔｓ ａｎｄ ｄｏｇｓ
print(s5.capitalize())
# 出力：We're the world
print(s6.capitalize())
# 出力：SS ß [Python 3.8 未満]
# 出力：Ss ß [Python 3.8 以上]

print(s1.title())
# 出力：The Quick Brown Fox Jumps Over The Lazy Dog.
print(s2.title())
# 出力：The Quick Brown Fox Jumps Over The Lazy Dog.
print(s3.title())
# 出力：Ｃａｔｓ Ａｎｄ Ｄｏｇｓ
print(s4.title())
# 出力：Ｃａｔｓ Ａｎｄ Ｄｏｇｓ
print(s5.title())
# 出力：We'Re The World
print(s6.title())
# 出力：Ss Ss

dic = {
    '空文字列': '',
    '大小文字混在': 'abcXYZ',
    '区別なし文字のみ': '123',
    '全て大文字': 'ABCＸＹＺΑΒΓ',
    '大文字 ＋ 区別なし文字': 'ABC123XYZ',
    '全て小文字': 'abcａｂｃαβγ',
    '小文字 ＋ 区別なし文字': 'abc123',
}

for key, value in dic.items():
    print(f'{value.isupper()} {value.islower()} [{key}] [{value}]')
# 出力：False False [空文字列] []
# 出力：False False [大小文字混在] [abcXYZ]
# 出力：False False [区別なし文字のみ] [123]
# 出力：True False [全て大文字] [ABCＸＹＺΑΒΓ]
# 出力：True False [大文字 ＋ 区別なし文字] [ABC123XYZ]
# 出力：False True [全て小文字] [abcａｂｃαβγ]
# 出力：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.',
    'ｃａｔｓ ａｎｄ ｄｏｇｓ',
    'ＣＡＴＳ ＡＮＤ ＤＯＧＳ',
    'Ｃａｔｓ Ａｎｄ Ｄｏｇｓ',
]

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 ｃａｔｓ ａｎｄ ｄｏｇｓ
# 出力：False ＣＡＴＳ ＡＮＤ ＤＯＧＳ
# 出力：True Ｃａｔｓ Ａｎｄ Ｄｏｇｓ

import copy

dic = {
    '空文字列': '',
    'ASCII (U+0000 ～ U+007F)': "!#1Az'",
    '英字 (半角)': 'abcXYZ',
    '英字 (全角)': 'ａｂｃＸＹＺ',
    '英数字 (半角)': '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(f'{str(r[0]):5} {str(r[1]):5} {str(r[2]):5} [{value}] [{key}]')

# 出力：isascii() isalpha() isalnum()
# 出力：True  False False [] [空文字列]
# 出力：True  False False [!#1Az'] [ASCII (U+0000 ～ U+007F)]
# 出力：
# 出力：True  True  True  [abcXYZ] [英字 (半角)]
# 出力：
# 出力：False True  True  [ａｂｃＸＹＺ] [英字 (全角)]
# 出力：
# 出力：True  False True  [abc123XYZ] [英数字 (半角)]
# 出力：
# 出力：False False True  [ａｂｃ１２３ＸＹＺ] [英数字 (全角)]
# 出力：
# 出力：False True  True  [ひらがな] [ひらがな]
# 出力：False True  True  [カタカナ] [カタカナ]
# 出力：False True  True  [漢字] [漢字]
# 出力：False True  True  [αβγπΣ] [ラテン文字]
# 出力：
# 出力：False False 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(f'{value.isdecimal()} '
              f'{value.isdigit()} '
              f'{value.isnumeric()} '
              f'[{value}] '
              f'[{key}]'
              )


# 数字以外
dic0 = {
    '空文字列': '',
    '英数混在': '123ABC',
    '符号付き': '-123',
    '小数点付き': '123.456',
}
display(dic0)
# 出力：
# False False False [] [空文字列]
# False False False [123ABC] [英数混在]
# False False False [-123] [符号付き]
# False False False [123.456] [小数点付き]

# 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)
# 出力：
# True True True [0123456789] [半角アラビア数字 (U+0030～U+0039)]
# True True True [０１２３４５６７８９] [全角アラビア数字 (U+FF10～U+FF19)]
# True True True [٠١٢٣٤٥٦٧٨٩] [アラビア・インド数字 (U+0660～U+0669)]
# True True True [०१२३४५६७८९] [デーヴァナーガリー数字 (U+0966～U+096F)]

# 修飾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)
# 出力：
# 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)]

# その他数字
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 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)]

dic = {
    '空文字列': '',
    '文字': 'abc',
    '半角スペース': ' ',
    '全角スペース': '　',
    'タブ': '\t',
}
for key, value in dic.items():
    print(f'{value.isspace()} [{value}] [{key}]')
# 出力：
# False [] [空文字列]
# False [abc] [文字]
# True [ ] [半角スペース]
# True [　] [全角スペース]
# True [	] [タブ]

lst = ['', 'abc', '(SP) ', '(tab)\t']
for s in lst:
    print(f'{s.isprintable()} [{s}]')
# 出力：
# True []
# True [abc]
# True [(SP) ]
# False [(tab)	]

import keyword

lst = ['', '123abc', 'abc', 'i', 'CLASS', '変数', 'if', 'class']
for s in lst:
    print(f'{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]

s = 'STRING'
print(f'[{s.center(9)}]')
print(f'[{s.center(9, "#")}]')
print(f'[{s.center(3)}]')
# 出力：[  STRING ]
# 出力：[##STRING#]
# 出力：[STRING]

print(f'[{s.rjust(9)}]')
print(f'[{s.rjust(9, "#")}]')
print(f'[{s.rjust(3)}]')
# 出力：[   STRING]
# 出力：[###STRING]
# 出力：[STRING]

s1 = '123'
s2 = '-123'
s3 = '+123'
print(f'[{s1.zfill(6)}]')
print(f'[{s2.zfill(6)}]')
print(f'[{s3.zfill(6)}]')
print(f'[{s1.zfill(2)}]')
# 出力：[000123]
# 出力：[-00123]
# 出力：[+00123]
# 出力：[123]

s1 = '  STRING  '
print(f'[{s1}]')
print(f'[{s1.strip()}]')
print(f'[{s1.lstrip()}]')
print(f'[{s1.rstrip()}]')
# 出力：[  STRING  ]
# 出力：[STRING]
# 出力：[STRING  ]
# 出力：[  STRING]

s2 = 'abcSTRINGxyz'
chars = 'zyxcba'
print(s2)
print(s2.strip(chars))
print(s2.lstrip(chars))
print(s2.rstrip(chars))
# 出力：abcSTRINGxyz
# 出力：STRING
# 出力：STRINGxyz
# 出力：abcSTRING

s3 = 'startstop'
start = 'start'
stop = 'stop'
print(s3)
print(s3.strip(start))
print(s3.lstrip(start))
print(s3.rstrip(start))
print(s3.removeprefix(start))
print(s3.removesuffix(start))
# 出力：startstop
# 出力：op
# 出力：op
# 出力：startstop
# 出力：stop
# 出力：startstop

print(s3.strip(stop))
print(s3.lstrip(stop))
print(s3.rstrip(stop))
print(s3.removeprefix(stop))
print(s3.removesuffix(stop))
# 出力：ar
# 出力：artstop
# 出力：star
# 出力：startstop
# 出力：start

s = 'start__end'

print(s.startswith('start'))
# 出力：True
print(s.startswith('end'))
# 出力：False
print(s.startswith('start', 1))
# 出力：False
print(s.startswith('end', 7))
# 出力：True
print(s.startswith('start', 0, 2))
# 出力：False
print(s.startswith(('start', '_')))
# 出力：True
print(s.startswith(('start', 'end')))
# 出力：True

print(s.endswith('start'))
# 出力：False
print(s.endswith('end'))
# 出力：True
print(s.endswith('end', -2))
# 出力：False
print(s.endswith('end', 5))
# 出力：True
print(s.endswith('end', 2, 7))
# 出力：False
print(s.endswith(('start', '_')))
# 出力：False
print(s.endswith(('start', 'end')))
# 出力：True

s = 'cats and dogs, cats and dogs'

print(s.find('cat'))
# 出力：0
print(s.find('dog'))
# 出力：9
print(s.find('mouse'))
# 出力：-1
print(s.find('cat', 1))
# 出力：15
print(s.find('cat', 1, 17))
# 出力：-1

print(s.index('cat'))
# 出力：0
print(s.index('dog'))
# 出力：9
try:
    print(s.index('mouse'))
except ValueError as e:
    print(type(e), e.args)
# 出力：<class 'ValueError'> ('substring not found',)
print(s.index('cat', 1))
# 出力：15
try:
    print(s.index('cat', 1, 17))
except ValueError as e:
    print(type(e), e.args)
# 出力：<class 'ValueError'> ('substring not found',)

print(s.rfind('cat'))
# 出力：15
print(s.rfind('dog'))
# 出力：24
print(s.rfind('mouse'))
# 出力：-1
print(s.rfind('cat', 1))
# 出力：15
print(s.rfind('cat', 1, 17))
# 出力：-1

print(s.rindex('cat'))
# 出力：15
print(s.rindex('dog'))
# 出力：24
try:
    print(s.rindex('mouse'))
except ValueError as e:
    print(type(e), e.args)
# 出力：<class 'ValueError'> ('substring not found',)
print(s.rindex('cat', 1))
# 出力：15
try:
    print(s.rindex('cat', 1, 17))
except ValueError as e:
    print(type(e), e.args)
# 出力：<class 'ValueError'> ('substring not found',)

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(s1.split())
# 出力：['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog.']
print(s1.split(maxsplit=3))
# 出力：['The', 'quick', 'brown', 'fox jumps over the lazy dog.']
print(s2.split())
# 出力：['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog.']
print(s2.split(maxsplit=3))
# 出力：['The', 'quick', 'brown', 'fox  jumps  over  the  lazy  dog.  ']
print(s3.split(','))
# 出力：['111', '', '333', '444', '555', '', '', '888', '999', '']
print(s3.split(',', maxsplit=3))
# 出力：['111', '', '333', '444,555,,,888,999,']
print(s3.split(',,'))
# 出力：['111', '333,444,555', ',888,999,']

print(s1.rsplit())
# 出力：['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog.']
print(s1.rsplit(maxsplit=3))
# 出力：['The quick brown fox jumps over', 'the', 'lazy', 'dog.']
print(s2.rsplit())
# 出力：['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog.']
print(s2.rsplit(maxsplit=3))
# 出力：['  The  quick  brown  fox  jumps  over', 'the', 'lazy', 'dog.']
print(s3.rsplit(','))
# 出力：['111', '', '333', '444', '555', '', '', '888', '999', '']
print(s3.rsplit(',', maxsplit=3))
# 出力：['111,,333,444,555,,', '888', '999', '']
print(s3.rsplit(',,'))
# 出力：['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))
# 出力：The quick brown\rfox\njumps over\nthe lazy\r\ndog.\n
print(s.splitlines())
# 出力：['The quick brown', 'fox', 'jumps over', 'the lazy', 'dog.']
print(s.splitlines(True))
# 出力：['The quick brown\r', 'fox\n', 'jumps over\n', 'the lazy\r\n', 'dog.\n']

s = 'The quick brown fox jumps over the lazy dog.'
print(s.partition(' '))
# 出力：('The', ' ', 'quick brown fox jumps over the lazy dog.')
print(s.partition('-'))
# 出力：('The quick brown fox jumps over the lazy dog.', '', '')
print(s.rpartition(' '))
# 出力：('The quick brown fox jumps over the lazy', ' ', 'dog.')
print(s.rpartition('-'))
# 出力：('', '', 'The quick brown fox jumps over the lazy dog.')

s = 'The quick brown fox jumps over the lazy dog.'
print(s.replace('fox', 'cat'))
# 出力：The quick brown cat jumps over the lazy dog.
print(s.replace('o', '[ O ]'))
# 出力：The quick br[ O ]wn f[ O ]x jumps [ O ]ver the lazy d[ O ]g.
print(s.replace('o', '[ O ]', 2))
# 出力：The quick br[ O ]wn f[ O ]x jumps over the lazy dog.
print(s)
# 出力：The quick brown fox jumps over the lazy dog.

print('(', ''.replace('', 'REPLACE'), ')', sep='')
# 出力：(REPLACE) [Python 3.8]
# 出力：(REPLACE) [Python 3.9]
print('(', ''.replace('', 'REPLACE', 1), ')', sep='')
# 出力：()        [Python 3.8]
# 出力：(REPLACE) [Python 3.9]
print('(', ''.replace('', 'REPLACE', 9), ')', sep='')
# 出力：()        [Python 3.8]
# 出力：(REPLACE) [Python 3.9]

lst = ['cat', 'dog', 'fox']
print(''.join(lst))
# 出力：catdogfox
print(','.join(lst))
# 出力：cat,dog,fox
print(', '.join(lst))
# 出力：cat, dog, fox

dic = {'animal1': 'cat', 'animal2': 'dog', 'animal3': 'fox'}
print(', '.join(dic))
# 出力：animal1, animal2, animal3

s = '*\t***\t*****\t*******'
print(s.translate({0x09: '\\t'}))
# 出力：*\t***\t*****\t*******
print(s.expandtabs())
# 出力：*       ***     *****   *******
# 参考：+123456789+123456789+123456789
print(s.expandtabs(4))
# 出力：*   *** *****   *******
# 参考：+123456789+123456789+123456789

s = 'あいう'
for c in s:
    unicode = ord(c)
    utf8 = c.encode()
    sjis = c.encode('shift-jis')
    print(f'{c} 0x{unicode:04X} {utf8} {sjis}')
# 出力：あ 0x3042 b'\xe3\x81\x82' b'\x82\xa0'
# 出力：い 0x3044 b'\xe3\x81\x84' b'\x82\xa2'
# 出力：う 0x3046 b'\xe3\x81\x86' b'\x82\xa4'
print(s.encode())
# 出力：b'\xe3\x81\x82\xe3\x81\x84\xe3\x81\x86'

try:
    print(s.encode('ascii', 'strict'))
except UnicodeError as e:
    print(type(e), e.args)
# 出力：<class 'UnicodeEncodeError'> ('ascii', 'あいう', 0, 3, 'ordinal not in range(128)')
print(s.encode('ascii', 'ignore'))
# 出力：b''
print(s.encode('ascii', 'replace'))
# 出力：b'???'
print(s.encode('ascii', 'xmlcharrefreplace'))
# 出力：b'&#12354;&#12356;&#12358;'
print(s.encode('ascii', 'backslashreplace'))
# 出力：b'\\u3042\\u3044\\u3046'

s1 = 'The quick brown fox jumps over the lazy dog.'.lower()
#     0123456789+123456789+123456789+123456789+123
#     4321+987654321+987654321+987654321+987654321

print(s1.count(' '))
# 出力：8
print(s1.count('the'))
# 出力：2
print(s1.count('the', 1))
# 出力：1
print(s1.count('o'))
# 出力：4
print(s1.count('o', 12, -2))
# 出力：4
print(s1.count('o', 13, -3))
# 出力：2
print(s1.count('mouse'))
# 出力：0

for i in range(ord('a'), (ord('z') + 1)):
    c = chr(i)
    count = s1.count(c)
    if 1 < count:
        print(c, count)
# 出力：e 3
# 出力：h 2
# 出力：o 4
# 出力：r 2
# 出力：t 2
# 出力：u 2

s2 = 'AAAAAA'
print(s2.count('AA'))
# 出力：3
print(s2.count('AA', 1))
# 出力：2

s = 'The quick brown fox jumps over the lazy dog.'

tbl1 = str.maketrans({'x': '(X)', 'y': '(Y)', 'z': '(Z)', 'e': None})
print(tbl1)
# 出力：{120: '(X)', 121: '(Y)', 122: '(Z)', 101: None}
print(s.translate(tbl1))
# 出力：Th quick brown fo(X) jumps ovr th la(Z)(Y) dog.

tbl2 = str.maketrans('abcxyz', 'ABCXYZ')
print(tbl2)
# 出力：{97: 65, 98: 66, 99: 67, 120: 88, 121: 89, 122: 90}
print(s.translate(tbl2))
# 出力：The quiCk Brown foX jumps over the lAZY dog.

tbl3 = str.maketrans('o', '_', 'abc')
print(tbl3)
# 出力：{111: 95, 97: None, 98: None, 99: None}
print(s.translate(tbl3))
# 出力：The quik r_wn f_x jumps _ver the lzy d_g.

#      SP        x             y   Y     z     Z
dic = {' ': '=', 0x78: '(X)', 'y': 0x59, 0x7A: 0x5A}
tbl4 = str.maketrans(dic)
print(tbl4)
# 出力：{32: '=', 120: '(X)', 121: 89, 122: 90}
print(s.translate(tbl4))
# 出力：The=quick=brown=fo(X)=jumps=over=the=laZY=dog.

# 参考
s = 'The quick brown fox jumps over the lazy dog.'
array = ' ' * 0x61 + 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
lst = list(array)
lst[0x20] = '-'  # SP
lst[0x54] = 't'  # 'T'
lst[0x2E] = '@'  # '.'
tbl1 = ''.join(lst)
print(s.translate(tbl1))
# 出力：tHE-QUICK-BROWN-FOX-JUMPS-OVER-THE-LAZY-DOG@

#                  'x'          'y'          'z'          'o'
print(s.translate({0x78: '(X)', 0x79: '(Y)', 0x7A: '(Z)', 0x6F: None}))
# 出力：The quick brwn f(X) jumps ver the la(Z)(Y) dg.

# フィールド省略
print('{} {} {}'.format('P0', 'P1', 'P2'))
# 出力：P0 P1 P2

# フィールド名指定
print('{p2} {p1} {p0} {p2}'.format(p0='P0', p1='P1', p2='P2'))
# 出力：P2 P1 P0 P2

# 引数の位置番号指定
print('{2} {1} {0} {2}'.format('P0', 'P1', 'P2'))
# 出力：P2 P1 P0 P2

# 引数の位置番号指定・フィールド名指定
x = 2
y = 3
z = x * y
s = '{0} * {1} = {result}'
print(s.format(x, y, result=z))
# 出力：2 * 3 = 6

# {{と}}の出力
print('{{{}}} {{{}}} {{{}}}'.format('P0', 'P1', 'P2'))
# 出力：{P0} {P1} {P2}

# 辞書指定
dic = {'p0': 'P0', 'p1': 'P1', 'p2': 'P2'}
print('{p2} {p1} {p0} {p2}'.format_map(dic))
# 出力：P2 P1 P0 P2

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

# 辞書指定 置換フィールドの入れ子
dic = {'b0': 'B0', 'b1': 'B1', 'b2': 'B2', 'width': 6}
s = '({b0:*<{width}s}) ({b1:*>{width}s}) ({b2:*^{width}s})'
print(s.format_map(dic))
# 出力：(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))
# 出力：ATTR0 ATTR1

# 要素番号
fld2 = [123, 456]
print('{0[0]} {0[1]}'.format(fld2))
# 出力：123 456

# 要素名
fld3 = {'item1': 'ITEM1', 'item2': 'ITEM2', 'item3': 'ITEM3'}
print('{0[item1]} {0[item2]} {0[item3]}'.format(fld3))
# 出力：ITEM1 ITEM2 ITEM3

# 要素番号＋属性名
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))
# 出力：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('({}) ({}) {}'.format(fmt1, fmt2, s))
# 出力：
# (STRING) (str) {}
# (STRING    ) (str       ) {:10}
# (STRING    ) (str       ) {:<10s}
# (    STRING) (       str) {:>10s}
# (  STRING  ) (   str    ) {:^10s}
# (STRING****) (str*******) {:*<10s}
# (****STRING) (*******str) {:*>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('({}) ({}) {}'.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     ) {:<15d}
# (      123456789) (     -123456789) {:>15d}
# (      123456789) (-     123456789) {:=15d}
# (   123456789   ) (  -123456789   ) {:^15d}
# (123456789******) (-123456789*****) {:*<15d}
# (******123456789) (*****-123456789) {:*>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('({}) ({}) {}'.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('({}) ({}) {}'.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('({}) ({}) {}'.format(fmt1, fmt2, s))
# 出力：
# (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}

print('({0:5e}) ({0:5E})'.format(float('NaN')))
# 出力：(  nan) (  NAN)
print('({0:5e}) ({0:5E})'.format(float('inf')))
# 出力：(  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('({}) ({}) {}'.format(fmt1, fmt2, s))
# 出力：
# (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}

print('({0:5f}) ({0:5F})'.format(float('NaN')))
# 出力：(  nan) (  NAN)
print('({0:5f}) ({0:5F})'.format(float('inf')))
# 出力：(  inf) (  INF)

# z【ゼロ強制】オプション [Python 3.11]
x = -.001
print('{:+.2f}'.format(x))
# 出力：-0.00
print('{:+z.2f}'.format(x))
# 出力：+0.00
print('{:-.2f}'.format(x))
# 出力：-0.00
print('{:-z.2f}'.format(x))
# 出力：0.00
print('{: .2f}'.format(x))
# 出力：-0.00
print('{: z.2f}'.format(x))
# 出力： 0.00

print(f'{x:+z.2f}')
# 出力：+0.00
print(f'{x:-z.2f}')
# 出力：0.00
print(f'{x: z.2f}')
# 出力： 0.00

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('({}) ({}) ({}) ({}) {}'.format(fmt1, fmt2, fmt3, fmt4, s))
# (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}

print('({0:5g}) ({0:5G})'.format(float('NaN')))
# 出力：(  nan) (  NAN)
print('({0:5g}) ({0:5G})'.format(float('inf')))
# 出力：(  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('({}) ({}) {}'.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))
# 出力：2001-02-03
t = datetime.time(1, 2, 3)
print('{:%H:%M:%S}'.format(t))
# 出力：01:02:03
dt = datetime.datetime(2001, 2, 3, 4, 5, 6)
print('{:%Y-%m-%d %H:%M:%S}'.format(dt))
# 出力：2001-02-03 04:05:06

# オブジェクト
print('%d' % 1234)
# 出力：1234

# タプル
print('%d %f' % (1234, 123.456))
# 出力：1234 123.456000
print('%0*d' % (8, 1234))
# 出力：00001234
print('%0*.*f' % (16, 8, 1234.5678))
# 出力：0001234.56780000

# 辞書
dic = {'key1': 1234, 'key2': 123.456, 'key3': 'STRING'}
print('%(key1)d %(key2)f %(key3)s' % dic)
# 出力：1234 123.456000 STRING

s = 'STRING'
print('[%s]' % s)
# 出力：[STRING]
print('[%10s]' % s)
# 出力：[    STRING]
print('[%-10s]' % s)
# 出力：[STRING    ]
print('[%*s]' % (10, s))
# 出力：[    STRING]
print('[%(key1)-10s]' % {'key1': s})
# 出力：[STRING    ]

lst = [
    '%+d',
    '%-d',
    '% d',
    '%08d',
    '%+8d',
    '%-8d',
    '% 8d',
    '%+08d',
    '% 08d',
]
for s in lst:
    s1 = s % 123456
    s2 = s % -123456
    print(f'({s1}) ({s2}) [{s}]')
# 出力：
# (+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]

print('(%*d)' % (8, 1234))
# 出力：(    1234)
print('(%(key1)8d)' % {'key1': 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(f'({s1}) ({s2}) [{s}]')
# 出力：
# (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 = float('NaN')
inf = float('inf')
print('(%5e) (%5E)' % (nan, nan))
# 出力：(  nan) (  NAN)
print('(%5e) (%5E)' % (inf, inf))
# 出力：(  inf) (  INF)

print('(%*e)' % (15, 12.34))
# 出力：(   1.234000e+01)
print('(%*.*e)' % (15, 1, 12.34))
# 出力：(        1.2e+01)
print('(%(key1)e)' % {'key1': 12.34})
# 出力：(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(f'({s1}) ({s2}) [{s}]')
# 出力：
# (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 = float('NaN')
inf = float('inf')
print('(%5f) (%5F)' % (nan, nan))
# 出力：(  nan) (  NAN)
print('(%5f) (%5F)' % (inf, inf))
# 出力：(  inf) (  INF)

print('(%*f)' % (12, 12.34))
# 出力：(   12.340000)
print('(%*.*f)' % (12, 1, 12.34))
# 出力：(        12.3)
print('(%(key1)f)' % {'key1': 12.34})
# 出力：(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(f'({s1}) ({s2}) ({s3}) [{s}]')
# 出力：
# (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 = float('NaN')
inf = float('inf')
print('(%5g) (%5G)' % (nan, nan))
# 出力：(  nan) (  NAN)
print('(%5g) (%5G)' % (inf, inf))
# 出力：(  inf) (  INF)

print('(%*g)' % (12, 12.34))
# 出力：(       12.34)
print('(%*.*g)' % (12, 1, 12.34))
# 出力：(       1e+01)
print('(%(key1)g)' % {'key1': 12.34})
# 出力：(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(f'({s1}) ({s2}) [{s}]')
# 出力：
# (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]

print('(%*x)' % (4, 255))
# 出力：(  ff)
print('(%(key1)x)' % {'key1': 255})
# 出力：(ff)

n = 123
s = 'STRING'
# 変数
print(f'{n} {s}')
# 出力：123 STRING
# 書式指定
print(F'{n:*<+10,} {s:*^10}')
# 出力：+123****** **STRING**
# 三重引用符＋raw 文字列
print(fr'''( {n}\n{s}

)''')
# 出力：
# ( 123\nSTRING
#
# )
# 前後の空白は無視
print(f'({s}) ({  s  }) ({    s    })')
# 出力：(STRING) (STRING) (STRING)
# 実行時に式を評価
fmt = f'{n} {s}'
print(fmt)
# 出力：123 STRING
n = 100
s = 'STRING' * 10
print(fmt)
# 出力：123 STRING

#### 単純式
x = 2
y = 3
# 計算式
print(f'{x} * {y} = {x * y}')
# 出力：2 * 3 = 6
# 三項演算子
print(f"x={x} y={y} [{'x < y' if x < y else 'y < x'}]")
# 出力：x=2 y=3 [x < y]
x = 5
print(f"x={x} y={y} [{'x < y' if x < y else 'y < x'}]")
# 出力：x=5 y=3 [y < x]
# 比較
print(f'{x < y}')
# 出力：False

def func(x, y):
    return x, y


# 関数呼び出し
x = 2
y = 3
print(f'{x} ** {y} = {pow(x, y)}')
# 出力：2 ** 3 = 8

# 関数呼び出し (複数戻り値：タプル)
print(f'func({x}, {y}) {func(x, y)}')
# 出力：func(2, 3) (2, 3)

# ラムダ式 (丸カッコで囲む)
y = 2
print(f'{(lambda x: x * x)(y)}')
# 出力：4

# タプル・アンパック
# 即値
print(f'{1}')
# 出力：1

# タプル (単一指定：最後にカンマ)
print(f'{1,}')
# 出力：(1,)

# タプル (複数指定)
print(f'{1, 2}')
# 出力：(1, 2)

# タプル (丸カッコあり)
print(f'{(1, 2)}')
# 出力：(1, 2)

# タプル (計算式)
x = 1
y = 2
print(f'{x, y, x + y}')
# 出力：(1, 2, 3)

# リスト型
lst = ['L0', 'L1', 'L2']
print(f'{lst}')
# 出力：['L0', 'L1', 'L2']

# リスト型 (個別要素)
print(f'{lst[0]} {lst[1]} {lst[2]}')
# 出力：L0 L1 L2

# 単一タプル (リスト型)
print(f'{lst,}')
# 出力：(['L0', 'L1', 'L2'],)

# 単一タプル (リスト型アンパック)
print(f'{*lst,}')
# 出力：('L0', 'L1', 'L2')

# タプル (リスト型＋リスト型アンパック)
print(f'{lst, *lst}')
# 出力：(['L0', 'L1', 'L2'], 'L0', 'L1', 'L2')

# 辞書型
dic = {'d0': 'D0', 'd1': 'D1', 'd2': 'D2'}
print(f'{dic}')
# 出力：{'d0': 'D0', 'd1': 'D1', 'd2': 'D2'}

# 辞書型 (個別要素)
print(f"{dic['d0']} {dic['d1']} {dic['d2']}")
# 出力：D0 D1 D2

# 単一タプル (辞書型)
print(f'{dic,}')
# 出力：({'d0': 'D0', 'd1': 'D1', 'd2': 'D2'},)

# 単一タプル (辞書型アンパック)
print(f'{*dic,}')
# 出力：('d0', 'd1', 'd2')

# タプル (辞書型＋辞書型アンパック)
print(f'{dic, *dic}')
# 出力：({'d0': 'D0', 'd1': 'D1', 'd2': 'D2'}, 'd0', 'd1', 'd2')

# = 指定子 Python 3.8
x = 1
y = 2
z = 3
print(f'x = {x}\ny = {y}\nz = {z}')
# 出力：x = 1
# 出力：y = 2
# 出力：z = 3

print(f'{x = }\n{y = }\n{z = }')
# 出力：x = 1
# 出力：y = 2
# 出力：z = 3

print(f'{(x+y)*z=}')
# 出力：(x+y)*z=9

print(f'{(x + y) * z = }')
# 出力：(x + y) * z = 9

print(f'{(x + y) * z = :+.2f}')
# 出力：(x + y) * z = +9.00

# 置換フィールド内のコメント [Python 3.12]
comment_new = f"{', '.join([
    'abc',  # コメント
    'xyz',  # コメント
    'ABC',  # コメント
    'XYZ',  # コメント
])}"
print(comment_new)
# 出力：abc, xyz, ABC, XYZ

# 置換フィールド内で外側の引用符タイプの再利用 [Python 3.12]
i = 123
nest_old = f"""{f'''{f"{f'{ i }'}"}'''}"""  # Python 3.12 未満の最大入れ子
print(nest_old)
# 出力：123
nest_new = f'{f'{f'{f'{f'{f'{ i }'}'}'}'}'}'  # 上記を超える入れ子 [Python 3.12]
print(nest_new)
# 出力：123

# 置換フィールド内のバックスラッシュ [Python 3.12]
lst = ['abc', 'xyz', 'ABC', 'XYZ']
backslash_new_1 = f'{'\n'.join(lst)}'  # 改行
print(backslash_new_1)
# 出力：
# abc
# xyz
# ABC
# XYZ
# 置換フィールド内のバックスラッシュ (Unicode エスケープシーケンス) [Python 3.12]
backslash_new_2 = f'{'\N{Black Chess King}'.join(lst)}'
print(backslash_new_2)
# 出力：abc♚xyz♚ABC♚XYZ