string — 일반적인 문자열 연산

string 모듈은 문자열 처리에 쓰이는 상수와, 문자열 포맷팅을 커스터마이즈할 수 있는 Formatter 클래스, 간단한 치환을 위한 Template 문자열 클래스, 그리고 몇 가지 헬퍼 함수를 제공해요.

더 알아보기

str — 텍스트 시퀀스 타입.
문자열 메서드(String Methods).

출처: Python 표준 라이브러리

본문

문자열 상수

이 모듈에 정의된 상수들이에요.

string.ascii_letters — 아래에서 설명할 ascii_lowercase와 ascii_uppercase 상수의 결합이에요. 이 값은 locale에 의존하지 않아요.
string.ascii_lowercase — 소문자 'abcdefghijklmnopqrstuvwxyz'. locale에 의존하지 않고 바뀌지 않아요.
string.ascii_uppercase — 대문자 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'. locale에 의존하지 않고 바뀌지 않아요.
string.digits — 문자열 '0123456789'.
string.hexdigits — 문자열 '0123456789abcdefABCDEF'.
string.octdigits — 문자열 '01234567'.
string.punctuation — C locale에서 구두점으로 간주되는 ASCII 문자들의 문자열: !"#$%&'()*+,-./:;<=>?@[\]^_{|}~`.
string.printable — Python이 인쇄 가능하다고 간주하는 ASCII 문자들의 문자열. digits, ascii_letters, punctuation, whitespace의 결합이에요.

참고 — 설계상 string.printable.isprintable()은 False를 반환해요. 특히 string.printable은 POSIX 의미에서 인쇄 가능하지 않아요(LC_CTYPE 참고).
string.whitespace — 공백으로 간주되는 모든 ASCII 문자를 담은 문자열. 공백, 탭, 줄바꿈(linefeed), 복귀(return), 폼피드(formfeed), 세로 탭을 포함해요.

사용자 정의 문자열 포맷팅

내장 문자열 클래스는 PEP 3101에 설명된 format() 메서드로 복잡한 변수 치환과 값 포맷팅을 할 수 있어요. string 모듈의 Formatter 클래스는 내장 format() 메서드와 같은 구현을 사용해 여러분만의 문자열 포맷팅 동작을 만들고 커스터마이즈하게 해줘요.

class string.Formatter — Formatter 클래스는 다음 공개 메서드들을 가져요.

format(format_string, /, *args, **kwargs) — 기본 API 메서드예요. 포맷 문자열과 임의의 위치·키워드 인자 집합을 받아요. vformat()을 호출하는 단순한 래퍼예요. 버전 3.7에서 변경: 포맷 문자열 인자가 이제 위치 전용(positional-only).
vformat(format_string, args, kwargs) — 실제 포맷팅 작업을 하는 함수예요. *args와 **kwargs 구문으로 사전을 개별 인자로 언패킹하고 다시 패킹하는 대신, 미리 정의된 인자 사전을 전달하고 싶은 경우를 위해 별도 함수로 노출되어 있어요. vformat()은 포맷 문자열을 문자 데이터와 치환 필드로 분해하는 일을 해요. 아래에 설명하는 여러 메서드들을 호출하죠.

Formatter는 서브클래스가 대체하도록 의도된 여러 메서드들도 정의해요.

parse(format_string) — format_string을 순회하며 튜플 (literal_text, field_name, format_spec, conversion)들의 이터러블을 반환해요. vformat()이 문자열을 리터럴 텍스트 또는 치환 필드로 분해하는 데 쓰여요. 튜플의 값은 개념적으로 리터럴 텍스트 구간과 그 뒤의 단일 치환 필드를 나타내요. 리터럴 텍스트가 없다면(두 치환 필드가 연속으로 붙으면) literal_text는 길이가 0인 문자열이 돼요. 치환 필드가 없다면 field_name, format_spec, conversion은 None이 돼요. field_name의 값은 수정되지 않고, 번호가 없는 위치 필드의 자동 번호 부여는 vformat()이 해요.
get_field(field_name, args, kwargs) — field_name이 주어지면 포맷팅할 객체로 변환해요. parse()에서 반환된 field_name의 자동 번호 부여는 이 메서드를 호출하기 전에 vformat()이 해요. 튜플 (obj, used_key)를 반환해요. 기본 버전은 PEP 3101에 정의된 형태의 문자열, 예를 들어 "0[name]"이나 "label.title"을 받아요. args와 kwargs는 vformat()에 전달된 그대로예요. 반환값 used_key는 get_value()의 key 파라미터와 같은 의미예요.
get_value(key, args, kwargs) — 주어진 필드 값을 가져와요. key 인자는 정수 또는 문자열이에요. 정수면 args에서의 위치 인자 인덱스를, 문자열이면 kwargs에서의 명명된 인자를 나타내요. args 파라미터는 vformat()의 위치 인자 목록으로, kwargs 파라미터는 키워드 인자 사전으로 설정돼요. 복합 필드 이름의 경우 이 함수들은 필드 이름의 첫 구성 요소에만 호출되고, 이후 구성 요소는 일반 속성·인덱싱 연산으로 처리돼요. 예를 들어 필드 표현식 '0.name'은 키 인자 0으로 get_value()를 호출하게 해요. name 속성은 get_value()가 반환한 뒤 내장 getattr() 함수를 호출해 조회돼요. 인덱스나 키워드가 존재하지 않는 항목을 가리키면 IndexError 또는 KeyError를 발생시켜야 해요.
check_unused_args(used_args, args, kwargs) — 원하면 사용되지 않은 인자 검사를 구현해요. 이 함수의 인자는 포맷 문자열에서 실제로 참조된 모든 인자 키들의 집합(위치 인자는 정수, 명명된 인자는 문자열)과 vformat에 전달된 args·kwargs에 대한 참조예요. 사용되지 않은 인자 집합은 이 파라미터들로 계산할 수 있어요. 검사가 실패하면 check_unused_args()가 예외를 발생시키는 것으로 간주돼요.
format_field(value, format_spec) — format_field()는 단순히 전역 format() 내장 함수를 호출해요. 이 메서드는 서브클래스가 오버라이드할 수 있도록 제공돼요.
convert_field(value, conversion) — parse() 메서드가 반환한 튜플의 변환 타입에 따라 get_field()가 반환한 값을 변환해요. 기본 버전은 's'(str), 'r'(repr), 'a'(ascii) 변환 타입을 이해해요.

포맷 문자열 문법

str.format() 메서드와 Formatter 클래스는 포맷 문자열에 대해 같은 문법을 공유해요(다만 Formatter의 경우 서브클래스가 자신만의 포맷 문자열 문법을 정의할 수 있어요). 이 문법은 포맷된 문자열 리터럴(f-strings)과 템플릿 문자열 리터럴(t-strings)의 문법과 관련이 있지만 덜 정교하고, 특히 보간(inpolation)에서 임의의 표현식을 지원하지 않아요.

포맷 문자열은 중괄호 {}로 둘러싸인 "치환 필드(replacement fields)"를 포함해요. 중괄호 안에 없는 것은 리터럴 텍스트로 간주되고, 변경 없이 출력에 복사돼요. 리터럴 텍스트에 중괄호 문자를 포함해야 한다면 두 배로 해서 이스케이프할 수 있어요: {{와 }}.

치환 필드의 문법은 다음과 같아요:

replacement_field: "{" [field_name] ["!" conversion] [":" format_spec] "}"
field_name:        arg_name ("." attribute_name | "[" element_index "]")*
arg_name:          [identifier | digit+]
attribute_name:    identifier
element_index:     digit+ | index_string
index_string:      <any source character except "]"> +
conversion:        "r" | "s" | "a"
format_spec:       format-spec:format_spec

좀 더 비공식적으로 말하면, 치환 필드는 값을 포맷팅해서 치환 필드 대신 출력에 넣을 객체를 지정하는 field_name으로 시작할 수 있어요. field_name 뒤에는 선택적으로 느낌표 '!'가 앞에 붙는 conversion 필드와, 콜론 ':'이 앞에 붙는 format_spec이 따라올 수 있어요. 이것들은 치환 값에 대한 비기본 포맷을 지정해요. (Format specification mini-language 섹션도 참고.)

field_name 자체는 숫자나 키워드인 arg_name으로 시작해요. 숫자면 위치 인자를, 키워드면 명명된 키워드 인자를 가리켜요. arg_name은 문자열에 str.isdecimal()을 호출했을 때 참을 반환하면 숫자로 취급돼요. 포맷 문자열의 숫자 arg_name들이 0, 1, 2, … 순서로 있으면 전부(일부만이 아니라) 생략할 수 있고, 숫자 0, 1, 2, …이 자동으로 그 순서대로 삽입돼요.

arg_name은 인용 부호로 묶이지 않으므로, 포맷 문자열 안에서 임의의 사전 키(예: 문자열 '10'이나 ':-]')를 지정할 수 없어요. arg_name 뒤에는 여러 인덱스 또는 속성 표현식이 따라올 수 있어요. '.name' 형태의 표현식은 getattr()으로 명명된 속성을 선택하고, '[index]' 형태의 표현식은 __getitem__()으로 인덱스 조회를 해요.

버전 3.1에서 변경: str.format()에서 위치 인자 지정자를 생략할 수 있어서 '{} {}'.format(a, b)가 '{0} {1}'.format(a, b)와 같아짐. 버전 3.4에서 변경: Formatter에서도 생략 가능.

간단한 포맷 문자열 예제:

"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

conversion 필드는 포맷팅 전에 타입 강제 변환을 일으켜요. 보통 값의 포맷팅 작업은 값 자신의 __format__() 메서드가 해요. 하지만 어떤 경우에는 타입이 자기 자신의 포맷팅 정의를 무시하고 문자열로 포맷팅되도록 강제하는 게 바람직해요. __format__()을 호출하기 전에 값을 문자열로 변환하면 일반 포맷팅 로직을 우회해요.

현재 세 가지 conversion 플래그가 지원돼요: 값에 str()을 호출하는 '!s', repr()을 호출하는 '!r', ascii()를 호출하는 '!a'.

예시:

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first
"More {!a}"                      # Calls ascii() on the argument first

format_spec 필드는 값이 어떻게 표시될지에 대한 명세를 담아요. 필드 폭, 정렬, 패딩, 소수 정밀도 같은 세부사항을 포함하죠. 각 값 타입은 자신만의 "포맷팅 미니언어" 또는 format_spec의 해석을 정의할 수 있어요. 대부분의 내장 타입은 다음 섹션에서 설명하는 공통 포맷팅 미니언어를 지원해요.

format_spec 필드는 자신 안에 중첩된 치환 필드도 포함할 수 있어요. 이 중첩된 치환 필드는 필드 이름, conversion 플래그, 포맷 명세를 포함할 수 있지만, 더 깊은 중첩은 허용되지 않아요. format_spec 안의 치환 필드는 format_spec 문자열이 해석되기 전에 치환돼요. 이것은 값의 포맷팅을 동적으로 지정할 수 있게 해줘요.

Format specification mini-language

"Format specifications"는 포맷 문자열 안의 치환 필드 안에서 개별 값이 어떻게 표시될지 정의하는 데 쓰여요(Format string syntax, f-strings, t-strings 참고). 내장 format() 함수에 직접 전달할 수도 있어요. 각 포맷 가능 타입은 format specification이 어떻게 해석될지 정의할 수 있어요.

대부분의 내장 타입은 format specification에 대해 다음 옵션들을 구현해요. 다만 일부 포맷팅 옵션은 숫자 타입에서만 지원돼요.

일반적인 관례는 빈 format specification이 값에 str()을 호출한 것과 같은 결과를 내는 거예요. 비어 있지 않은 format specification은 보통 결과를 수정해요.

표준 format specifier의 일반 형태는 다음과 같아요:

format_spec:             [options][width_and_precision][type]
options:                 [[fill]align][sign]["z"]["#"]["0"]
fill:                    <any character>
align:                   "<" | ">" | "=" | "^"
sign:                    "+" | "-" | " "
width_and_precision:     [width_with_grouping][precision_with_grouping]
width_with_grouping:     [width][grouping]
precision_with_grouping: "." [precision][grouping] | "." grouping
width:                   digit+
precision:               digit+
grouping:                "," | "_"
type:                    "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g"
                         | "G" | "n" | "o" | "s" | "x" | "X" | "%"

유효한 align 값이 지정되면, 그 앞에 어떤 문자든 될 수 있고 생략하면 기본값이 공백인 fill 문자를 붙일 수 있어요. 포맷된 문자열 리터럴에서 또는 str.format() 메서드를 쓸 때 리터럴 중괄호("{"나 "}")를 fill 문자로 쓸 수 없어요. 다만 중첩된 치환 필드로 중괄호를 넣을 수는 있어요. 이 제한은 format() 함수에는 영향이 없어요.

다양한 정렬 옵션의 의미는 다음과 같아요.

옵션	의미
`'<'`	필드를 사용 가능한 공간 안에서 왼쪽 정렬로 강제(대부분 객체의 기본값).
`'>'`	필드를 사용 가능한 공간 안에서 오른쪽 정렬로 강제(숫자의 기본값).
`'='`	패딩을 부호(있으면) 뒤, 숫자 앞에 배치하도록 강제. `+000000120` 형태의 필드 출력에 쓰여요. 이 정렬 옵션은 `complex`를 제외한 숫자 타입에서만 유효해요. `'0'`이 필드 폭 바로 앞에 오면 숫자에서 기본값이 돼요.
`'^'`	필드를 사용 가능한 공간 안에서 가운데 정렬로 강제.

최소 필드 폭이 정의되지 않으면 필드 폭은 항상 채울 데이터와 같은 크기가 되어, 이 경우 정렬 옵션은 의미가 없어요.

sign 옵션은 숫자 타입에서만 유효하고 다음 중 하나일 수 있어요.

옵션	의미
`'+'`	양수와 음수 모두에 부호를 사용해야 함을 나타냄.
`'-'`	음수에만 부호를 사용해야 함을 나타냄(기본 동작).
space	양수에는 앞 공백, 음수에는 마이너스 부호를 사용해야 함을 나타냄.

'z' 옵션은 format precision으로 반올림한 뒤 음수 영(negative zero) 부동소수점 값을 양수 영으로 강제해요. 이 옵션은 부동소수점 표시 타입에서만 유효해요. 버전 3.11에서 변경: 'z' 옵션 추가(PEP 682 참고).

'#' 옵션은 변환에 "대체 형태(alternate form)"를 사용하게 해요. 대체 형태는 타입에 따라 다르게 정의돼요. 이 옵션은 정수, float, complex 타입에서만 유효해요. 정수의 경우 이진·팔진·십육진 출력을 사용할 때 이 옵션이 각각 '0b', '0o', '0x', '0X' 접두사를 출력 값에 추가해요. float와 complex의 경우 대체 형태는 변환 결과에 숫자가 뒤따르지 않아도 항상 소수점 문자를 포함하게 해요. 보통은 소수점 문자가 숫자가 뒤따를 때만 이 변환들의 결과에 나타나요. 또한 'g', 'G' 변환에서는 끝의 0이 결과에서 제거되지 않아요.

width는 접두사, 구분자, 기타 포맷팅 문자를 포함한 최소 전체 필드 폭을 정의하는 십진 정수예요. 지정하지 않으면 필드 폭은 내용에 의해 결정돼요.

명시적 정렬이 주어지지 않으면, width 필드 앞의 0('0') 문자는 complex를 제외한 숫자 타입에 대해 부호 인지(sign-aware) 0 패딩을 활성화해요. 이것은 '0' fill 문자에 '=' 정렬 타입을 쓰는 것과 같아요. 버전 3.10에서 변경: width 필드 앞의 '0'이 문자열의 기본 정렬에 더 이상 영향 주지 않음.

precision은 표시 타입 'f', 'F'에서는 소수점 뒤에, 'g', 'G'에서는 소수점 앞뒤에 표시할 자릿수를 나타내는 십진 정수예요. 문자열 표시 타입에서는 필드의 최대 크기, 즉 필드 내용에서 사용될 문자 수를 나타내요. precision은 정수 표시 타입에는 허용되지 않아요.

width와 precision 필드 뒤의 grouping 옵션은 각각 숫자의 정수부와 소수부에 대한 자릿수 그룹 구분자를 지정해요. 다음 중 하나일 수 있어요.

옵션	의미
`','`	정수 표시 타입 `'d'`와 `'n'`을 제외한 부동소수점 표시 타입에서 매 3자리마다 콤마를 삽입. 다른 표시 타입에서는 지원되지 않음.
`'_'`	정수 표시 타입 `'d'`와 `'n'`을 제외한 부동소수점 표시 타입에서 매 3자리마다 밑줄을 삽입. 정수 표시 타입 `'b'`, `'o'`, `'x'`, `'X'`에서는 매 4자리마다 밑줄을 삽입. 다른 표시 타입에서는 지원되지 않음.

locale 인지 구분자를 원하면 'n' float 표시 타입이나 정수 표시 타입을 대신 쓰세요.

버전 3.1에서 변경: ',' 옵션 추가(PEP 378 참고). 버전 3.6에서 변경: '_' 옵션 추가(PEP 515 참고). 버전 3.14에서 변경: 소수부에 대한 grouping 옵션 지원.

마지막으로 type이 데이터를 어떻게 표시할지 결정해요.

사용 가능한 문자열 표시 타입:

타입	의미
`'s'`	문자열 포맷. 문자열의 기본 타입이며 생략할 수 있어요.
None	`'s'`와 같음.

사용 가능한 정수 표시 타입:

타입	의미
`'b'`	이진 포맷. 밑 2로 숫자를 출력.
`'c'`	문자. 인쇄 전에 정수를 해당 유니코드 문자로 변환.
`'d'`	십진 정수. 밑 10으로 숫자를 출력.
`'o'`	팔진 포맷. 밑 8로 숫자를 출력.
`'x'`	십육진 포맷. 9보다 큰 자리에 소문자로 밑 16으로 숫자를 출력.
`'X'`	십육진 포맷. 9보다 큰 자리에 대문자로 밑 16으로 숫자를 출력. `'#'`이 지정되면 접두사 `'0x'`도 `'0X'`로 대문자화됨.
`'n'`	숫자. 현재 locale 설정으로 적절한 자릿수 그룹 구분자를 삽입한다는 점만 빼고 `'d'`와 같음. 기본 locale은 시스템 locale이 아님을 주의. `'n'`을 쓰기 전에 `locale.setlocale()`으로 `LC_NUMERIC`을 설정하고 싶을 수 있어요.
None	`'d'`와 같음.

위의 표시 타입에 더해, 정수는 아래에 나열된 부동소수점 표시 타입('n'과 None 제외)으로도 포맷팅할 수 있어요. 그럴 때는 포맷팅 전에 float()로 정수를 부동소수점 수로 변환해요.

float와 Decimal 값에 대한 사용 가능한 표시 타입:

타입	의미
`'e'`	과학 표기법. 주어진 정밀도 `p`에 대해 계수와 지수를 구분하는 'e' 문자로 과학 표기법으로 숫자를 포맷. 계수는 소수점 앞에 한 자리, 뒤에 `p` 자리로 총 `p + 1`개의 유효 자릿수. 정밀도가 없으면 `float`의 경우 소수점 뒤 6자리 정밀도를 쓰고 `Decimal`의 경우 모든 계수 자릿수를 표시. `p=0`이면 `#` 옵션을 쓰지 않는 한 소수점이 생략됨. `float`의 경우 지수는 항상 적어도 두 자리이고, 값이 0이면 0.
`'E'`	과학 표기법. 구분 문자로 대문자 'E'를 쓰는 것만 빼고 `'e'`와 같음.
`'f'`	고정 소수점 표기법. 주어진 정밀도 `p`에 대해 소수점 뒤에 정확히 `p`자리가 있는 십진수로 숫자를 포맷. 정밀도가 없으면 `float`의 경우 소수점 뒤 6자리, `Decimal`의 경우 모든 계수 자릿수를 보여줄 만큼 큰 정밀도를 사용. `p=0`이면 `#` 옵션을 쓰지 않는 한 소수점이 생략됨.
`'F'`	고정 소수점 표기법. `'f'`와 같지만 `nan`을 `NAN`으로, `inf`를 `INF`로 변환.
`'g'`	일반 포맷. 주어진 정밀도 `p >= 1`에 대해 숫자를 `p`개의 유효 자릿수로 반올림한 뒤, 크기에 따라 고정 소수점 포맷 또는 과학 표기법으로 결과를 포맷. 정밀도 0은 정밀도 1과 동등하게 취급됨. 정확한 규칙은: 표시 타입 `'e'`와 정밀도 `p-1`로 포맷된 결과의 지수가 `exp`라 하자. 그러면 `m <= exp < p`일 때(여기서 `m`은 float의 경우 -4, Decimal의 경우 -6), 숫자는 표시 타입 `'f'`와 정밀도 `p-1-exp`로 포맷됨. 그렇지 않으면 표시 타입 `'e'`와 정밀도 `p-1`로 포맷됨. 두 경우 모두 가수에서 중요하지 않은 끝자리 0이 제거되고, `'#'` 옵션을 쓰지 않는 한 뒤따르는 자리가 없으면 소수점도 제거됨. 정밀도가 없으면 `float`의 경우 6개 유효 자릿수 정밀도를 사용. `Decimal`의 경우 결과의 계수는 값의 계수 자릿수로 형성되고, 절대값이 `1e-6`보다 작은 값과 최하위 자리의 자릿값이 1보다 큰 값에는 과학 표기법이, 그 외에는 고정 소수점 표기법이 사용됨. 양수·음수 무한대, 양수·음수 0, nan은 정밀도와 무관하게 각각 `inf`, `-inf`, `0`, `-0`, `nan`으로 포맷됨.
`'G'`	일반 포맷. 숫자가 너무 커지면 `'E'`로 전환하는 것만 빼고 `'g'`와 같음. 무한대와 NaN의 표현도 대문자화됨.
`'n'`	숫자. 숫자의 정수부에 대한 자릿수 그룹 구분자를 현재 locale 설정으로 삽입한다는 점만 빼고 `'g'`와 같음. 기본 locale은 시스템 locale이 아님을 주의. `'n'`을 쓰기 전에 `locale.setlocale()`으로 `LC_NUMERIC`을 설정하고 싶을 수 있어요.
`'%'`	백분율. 숫자에 100을 곱하고 고정(`'f'`) 포맷으로 표시한 뒤 퍼센트 부호를 붙임.
None	`float`의 경우 이는 `'g'` 타입과 비슷하지만, 고정 소수점 표기법으로 결과를 포맷할 때 항상 소수점 뒤에 적어도 한 자리를 포함하고 `exp >= p - 1`일 때 과학 표기법으로 전환. 정밀도가 지정되지 않으면 후자는 주어진 값을 충실히 표현하는 데 필요한 만큼 커짐. `Decimal`의 경우 현재 decimal 컨텍스트의 `context.capitals` 값에 따라 `'g'` 또는 `'G'`와 같음. 전체 효과는 다른 포맷 수정자에 의해 수정된 `str()`의 출력과 일치시키는 것.

결과는 소수점 뒤 p자리의 정밀도로 올바르게 반올림되어야 해요. float의 반올림 모드는 내장 round()와 일치해요. Decimal의 경우 현재 컨텍스트의 반올림 모드가 사용돼요.

complex에 대한 사용 가능한 표시 타입은 float와 같아요('%'는 허용되지 않음). 복소수의 실수부와 허수부는 둘 다 지정된 표시 타입에 따라 부동소수점 수로 포맷돼요. 그것들은 허수부의 필수 부호로 구분되고, 허수부는 j 접미사로 끝나요. 표시 타입이 없으면 결과는 str()의 출력과 일치해요(0이 아닌 실수부를 가진 복소수는 괄호로 둘러싸임), 다른 포맷 수정자들에 의해 수정될 수 있어요.

Format examples

이 섹션은 str.format() 문법의 예제와 옛 %-포맷팅과의 비교를 담아요.

대부분의 경우 문법은 옛 %-포맷팅과 비슷하고, {}가 추가되고 % 대신 :가 쓰여요. 예를 들어 '%03.2f'는 '{:03.2f}'로 바꿀 수 있어요.

새 포맷 문법은 아래 예제들에 나타난 새롭고 다른 옵션들도 지원해요.

위치로 인자 접근:

>>> '{0}, {1}, {2}'.format('a', 'b', 'c')
'a, b, c'
>>> '{}, {}, {}'.format('a', 'b', 'c')  # 3.1+ only
'a, b, c'
>>> '{2}, {1}, {0}'.format('a', 'b', 'c')
'c, b, a'
>>> '{2}, {1}, {0}'.format(*'abc')      # unpacking argument sequence
'c, b, a'
>>> '{0}{1}{0}'.format('abra', 'cad')   # arguments' indices can be repeated
'abracadabra'

이름으로 인자 접근:

>>> 'Coordinates: {latitude}, {longitude}'.format(latitude='37.24N', longitude='-115.81W')
'Coordinates: 37.24N, -115.81W'
>>> coord = {'latitude': '37.24N', 'longitude': '-115.81W'}
>>> 'Coordinates: {latitude}, {longitude}'.format(**coord)
'Coordinates: 37.24N, -115.81W'

인자의 속성 접근:

>>> c = 3-5j
>>> ('The complex number {0} is formed from the real part {0.real} '
...  'and the imaginary part {0.imag}.').format(c)
'The complex number (3-5j) is formed from the real part 3.0 and the imaginary part -5.0.'
>>> class Point:
...     def __init__(self, x, y):
...         self.x, self.y = x, y
...     def __str__(self):
...         return 'Point({self.x}, {self.y})'.format(self=self)
...
>>> str(Point(4, 2))
'Point(4, 2)'

인자의 항목 접근:

>>> coord = (3, 5)
>>> 'X: {0[0]};  Y: {0[1]}'.format(coord)
'X: 3;  Y: 5'

%s와 %r 대체:

>>> "repr() shows quotes: {!r}; str() doesn't: {!s}".format('test1', 'test2')
"repr() shows quotes: 'test1'; str() doesn't: test2"

텍스트 정렬과 폭 지정:

>>> '{:<30}'.format('left aligned')
'left aligned                  '
>>> '{:>30}'.format('right aligned')
'                 right aligned'
>>> '{:^30}'.format('centered')
'           centered           '
>>> '{:*^30}'.format('centered')  # use '*' as a fill char
'***********centered***********'

%+f, %-f, % f 대체와 부호 지정:

>>> '{:+f}; {:+f}'.format(3.14, -3.14)  # show it always
'+3.140000; -3.140000'
>>> '{: f}; {: f}'.format(3.14, -3.14)  # show a space for positive numbers
' 3.140000; -3.140000'
>>> '{:-f}; {:-f}'.format(3.14, -3.14)  # show only the minus -- same as '{:f}; {:f}'
'3.140000; -3.140000'

%x와 %o 대체, 그리고 다른 밑으로의 값 변환:

>>> # format also supports binary numbers
>>> "int: {0:d};  hex: {0:x};  oct: {0:o};  bin: {0:b}".format(42)
'int: 42;  hex: 2a;  oct: 52;  bin: 101010'
>>> # with 0x, 0o, or 0b as prefix:
>>> "int: {0:d};  hex: {0:#x};  oct: {0:#o};  bin: {0:#b}".format(42)
'int: 42;  hex: 0x2a;  oct: 0o52;  bin: 0b101010'

콤마나 밑줄을 자릿수 그룹 구분자로 사용:

>>> '{:,}'.format(1234567890)
'1,234,567,890'
>>> '{:_}'.format(1234567890)
'1_234_567_890'
>>> '{:_b}'.format(1234567890)
'100_1001_1001_0110_0000_0010_1101_0010'
>>> '{:_x}'.format(1234567890)
'4996_02d2'
>>> '{:_}'.format(123456789.123456789)
'123_456_789.12345679'
>>> '{:.,}'.format(123456789.123456789)
'123456789.123,456,79'
>>> '{:,._}'.format(123456789.123456789)
'123,456,789.123_456_79'

백분율 표현:

>>> points = 19
>>> total = 22
>>> 'Correct answers: {:.2%}'.format(points/total)
'Correct answers: 86.36%'

타입별 포맷팅 사용:

>>> import datetime as dt
>>> d = dt.datetime(2010, 7, 4, 12, 15, 58)
>>> '{:%Y-%m-%d %H:%M:%S}'.format(d)
'2010-07-04 12:15:58'

인자 중첩과 더 복잡한 예제:

>>> for align, text in zip('<^>', ['left', 'center', 'right']):
...     '{0:{fill}{align}16}'.format(text, fill=align, align=align)
...
'left<<<<<<<<<<<<'
'^^^^^center^^^^^'
'>>>>>>>>>>>right'
>>>
>>> octets = [192, 168, 0, 1]
>>> '{:02X}{:02X}{:02X}{:02X}'.format(*octets)
'C0A80001'
>>> int(_, 16)
3232235521
>>>
>>> width = 5
>>> for num in range(5,12):
...     for base in 'dXob':
...         print('{0:{width}{base}}'.format(num, base=base, width=width), end=' ')
...     print()
...
    5     5     5   101
    6     6     6   110
    7     7     7   111
    8     8    10  1000
    9     9    11  1001
   10     A    12  1010
   11     B    13  1011

템플릿 문자열 ($-strings)

참고 — 여기 설명된 기능은 Python 2.4에서 도입됐어요. 정규식을 기반으로 하는 간단한 템플릿 방법이죠. str.format(), 포맷된 문자열 리터럴, 템플릿 문자열 리터럴보다 앞섰어요. Python 3.14에서 도입된 템플릿 문자열 리터럴(t-strings)과는 무관해요. t-strings는 string.templatelib 모듈에 있는 string.templatelib.Template 객체로 평가돼요.

템플릿 문자열은 PEP 292에 설명된 것처럼 더 간단한 문자열 치환을 제공해요. 템플릿 문자열의 주요 사용 사례는 국제화(i18n)예요. 그 맥락에서는 더 단순한 문법과 기능 덕분에 다른 내장 문자열 포맷팅 기능보다 번역하기 쉽거든요. i18n을 위해 템플릿 문자열 위에 만들어진 라이브러리 예로는 flufl.i18n 패키지를 봐요.

템플릿 문자열은 $-기반 치환을 지원하며 다음 규칙을 사용해요:

$$는 이스케이프로, 단일 $로 치환돼요.
$identifier는 매핑 키 "identifier"와 일치하는 치환 플레이스홀더를 지정해요. 기본적으로 "identifier"는 밑줄 또는 ASCII 문자로 시작하는 대소문자 구분 없는 ASCII 영숫자 문자열(밑줄 포함)로 제한돼요. $ 문자 뒤의 첫 번째 비식별자 문자가 이 플레이스홀더 명세를 종료해요.
${identifier}는 $identifier와 동등해요. 플레이스홀더 뒤에 유효한 식별자 문자가 오지만 플레이스홀더의 일부가 아닐 때, 예를 들어 "${noun}ification"에서 필요해요.

문자열에서 $의 다른 어떤 등장도 ValueError를 발생시켜요.

string 모듈은 이 규칙들을 구현하는 Template 클래스를 제공해요. Template의 메서드들은:

class string.Template(template) — 생성자는 템플릿 문자열인 단일 인자를 받아요.

substitute(mapping={}, /, **kwds) — 템플릿 치환을 수행하고 새 문자열을 반환해요. mapping은 템플릿의 플레이스홀더와 일치하는 키를 가진 사전류 객체예요. 또는 키워드 인자를 제공할 수 있는데, 키워드가 플레이스홀더예요. mapping과 kwds가 모두 주어지고 중복이 있으면 kwds의 플레이스홀더가 우선해요.
safe_substitute(mapping={}, /, **kwds) — substitute()와 같지만, mapping과 kwds에 플레이스홀더가 없어도 KeyError 예외를 발생시키는 대신 원래 플레이스홀더가 결과 문자열에 그대로 나타나요. 또한 substitute()와 달리 $의 다른 어떤 등장도 ValueError를 발생시키지 않고 단순히 $를 반환해요. 다른 예외는 여전히 발생할 수 있지만, 이 메서드는 예외를 발생시키는 대신 항상 사용 가능한 문자열을 반환하려 하기 때문에 "safe"라고 불러요. 다른 의미로는, safe_substitute()는 매달린 구분자, 짝이 맞지 않는 중괄호, 유효한 Python 식별자가 아닌 플레이스홀더를 담은 잘못된 템플릿을 조용히 무시하므로 안전하다고 말하기 어려워요.
is_valid() — 템플릿에 substitute()가 ValueError를 발생시키게 할 유효하지 않은 플레이스홀더가 있으면 False를 반환해요. (버전 3.11에 추가됨.)
get_identifiers() — 템플릿의 유효한 식별자 목록을 처음 나타난 순서대로 반환하고, 유효하지 않은 식별자는 무시해요. (버전 3.11에 추가됨.)

Template 인스턴스는 하나의 공개 데이터 속성도 제공해요:

template — 생성자의 template 인자에 전달된 객체예요. 일반적으로 바꾸면 안 되지만, 읽기 전용 접근은 강제되지 않아요.

Template 사용 예시:

>>> from string import Template
>>> s = Template('$who likes $what')
>>> s.substitute(who='tim', what='kung pao')
'tim likes kung pao'
>>> d = dict(who='tim')
>>> Template('Give $who $100').substitute(d)
Traceback (most recent call last):
...
ValueError: Invalid placeholder in string: line 1, col 11
>>> Template('$who likes $what').substitute(d)
Traceback (most recent call last):
...
KeyError: 'what'
>>> Template('$who likes $what').safe_substitute(d)
'tim likes $what'

고급 사용법: Template의 서브클래스를 파생해서 플레이스홀더 문법, 구분자 문자, 또는 템플릿 문자열을 파싱하는 데 쓰는 전체 정규식을 커스터마이즈할 수 있어요. 이를 위해 다음 클래스 속성들을 오버라이드할 수 있어요:

delimiter — 플레이스홀더를 도입하는 구분자를 설명하는 리터럴 문자열. 기본값은 $. 구현이 필요에 따라 이 문자열에 re.escape()을 호출하므로 정규식이 아니어야 함을 주의. 클래스 생성 후 구분자를 바꿀 수 없다는 점도 주의(즉 다른 구분자는 서브클래스의 클래스 네임스페이스에 설정해야 해요).
idpattern — 중괄호가 없는 플레이스홀더의 패턴을 설명하는 정규식. 기본값은 정규식 (?a:[_a-z][_a-z0-9]*). 이것이 주어지고 braceidpattern이 None이면 이 패턴이 중괄호가 있는 플레이스홀더에도 적용돼요.

참고 — 기본 flags가 re.IGNORECASE라 패턴 [a-z]는 일부 비-ASCII 문자와 일치할 수 있어요. 그래서 여기 로컬 a 플래그를 써요. 버전 3.7에서 변경: braceidpattern을 써서 중괄호 안과 밖에서 쓰이는 별도 패턴을 정의할 수 있음.
braceidpattern — idpattern과 비슷하지만 중괄호가 있는 플레이스홀더의 패턴을 설명해요. 기본값은 None으로, idpattern으로 폴백(즉 중괄호 안과 밖에서 같은 패턴이 사용됨)을 의미해요. 주어지면 중괄호가 있는 것과 없는 플레이스홀더에 대해 다른 패턴을 정의할 수 있어요. (버전 3.7에 추가됨.)
flags — 치환을 인식하는 데 쓰이는 정규식을 컴파일할 때 적용될 정규식 플래그. 기본값은 re.IGNORECASE. re.VERBOSE가 항상 플래그에 추가되므로 커스텀 idpattern은 verbose 정규식 관례를 따라야 함을 주의. (버전 3.2에 추가됨.)

또는 클래스 속성 pattern을 오버라이드해 전체 정규식 패턴을 제공할 수 있어요. 이렇게 하면 값은 정규식 패턴 문자열 또는 네 개의 명명된 캡처 그룹이 있는 컴파일된 정규식 객체여야 해요. 캡처 그룹들은 위에 주어진 규칙과 잘못된 플레이스홀더 규칙에 대응해요:

escaped — 이 그룹은 기본 패턴의 $$ 같은 이스케이프 시퀀스와 일치해요.
named — 이 그룹은 중괄호가 없는 플레이스홀더 이름과 일치해요. 캡처 그룹에 구분자를 포함하면 안 돼요.
braced — 이 그룹은 중괄호로 둘러싸인 플레이스홀더 이름과 일치해요. 캡처 그룹에 구분자나 중괄호를 포함하면 안 돼요.
invalid — 이 그룹은 다른 어떤 구분자 패턴(보통 단일 구분자)과 일치하고, 정규식에서 마지막에 나타나야 해요.

이 클래스의 메서드들은 패턴이 이 명명된 그룹 중 하나가 일치하지 않고 템플릿과 일치하면 ValueError를 발생시킬 거예요.

헬퍼 함수

string.capwords(s, sep=None) — str.split()으로 인자를 단어들로 나누고, str.capitalize()로 각 단어를 대문자화하고, str.join()으로 대문자화된 단어들을 이어붙여요. 선택적 두 번째 인자 sep이 없거나 None이면 공백 문자의 연속이 단일 공백으로 바뀌고 앞뒤 공백이 제거돼요. 그렇지 않으면 sep이 단어를 나누고 이어붙이는 데 쓰여요.