Python Language
문자열 서식 지정

소개

통사론

• "{}". format (42) ==> "42"
• "{0}". format (42) ==> "42"
• "{0 : .2f}". format (42) ==> "42.00"
• "{0 : .0f}". format (42.1234) ==> "42"
• "{답}". 형식 (no_answer = 41, 답 = 42) ==> "42"
• "{대답 : .2f}". 형식 (no_answer = 41, 대답 = 42) ==> "42.00"
• "{[key]}". format ({ 'key': 'value'}) ==> "value"
• format ([ 'zero', 'one', 'two']) ==> "one"
• "{answer} = {answer}". format (answer = 42) ==> "42 = 42"
• ''.join ([ 'stack', 'overflow']) ==> "스택 오버플로"

비고

문자열 서식의 기본 사항

foo = 1
bar = 'bar'
baz = 3.14

str.format 을 사용하여 출력 형식을 str.format 수 있습니다. 대괄호 쌍은 인수가 전달 된 순서대로 인수로 대체됩니다.

print('{}, {} and {}'.format(foo, bar, baz))
# Out: "1, bar and 3.14"

괄호 안에 색인을 지정할 수도 있습니다. 숫자는 str.format 함수에 전달 된 인수의 인덱스 (0부터 시작 함)에 해당합니다.

print('{0}, {1}, {2}, and {1}'.format(foo, bar, baz))
# Out: "1, bar, 3.14, and bar"
print('{0}, {1}, {2}, and {3}'.format(foo, bar, baz))
# Out: index out of range error

명명 된 인수도 사용할 수 있습니다.

print("X value is: {x_val}. Y value is: {y_val}.".format(x_val=2, y_val=3))
# Out: "X value is: 2. Y value is: 3."

str.format 전달되면 객체 속성을 참조 할 수 있습니다.

class AssignValue(object):
    def __init__(self, value):
        self.value = value
my_value = AssignValue(6)
print('My value is: {0.value}'.format(my_value))  # "0" is optional
# Out: "My value is: 6"

사전 키도 사용할 수 있습니다.

my_dict = {'key': 6, 'other_key': 7}
print("My other key is: {0[other_key]}".format(my_dict))  # "0" is optional
# Out: "My other key is: 7"

리스트 및 튜플 인덱스에도 동일하게 적용됩니다.

my_list = ['zero', 'one', 'two']
print("2nd element is: {0[2]}".format(my_list))  # "0" is optional
# Out: "2nd element is: two"

참고 : str.format 외에도 Python은 문자열 형식 지정 또는 보간 연산자 ( PEP 3101 참조)라고도하는 모듈러스 연산자 % 제공합니다. str.format 은 % 의 후속 버전이며 여러 대체를 더 쉽게 수행 할 수있게함으로써 유연성을 제공합니다.

인수 인덱스 외에도 중괄호 안에 형식 지정을 포함 할 수도 있습니다. (이 특별한 규칙을 다음과 콜론이 와야합니다 표현이다 : ). 형식 지정에 대한 자세한 설명은 문서 를 참조하십시오. 형식 지정의 예는 정렬 지시문입니다 :~^20 ( ^ 는 가운데 맞춤, 총 너비 20, ~ 문자로 채우기) :

'{:~^20}'.format('centered')
# Out: '~~~~~~centered~~~~~~'

format 은 % 를 사용하여 가능하지 않은 동작을 허용합니다 (예 : 반복 인수).

t = (12, 45, 22222, 103, 6)
print '{0} {2} {1} {2} {3} {2} {4} {2}'.format(*t)    
# Out: 12 22222 45 22222 103 22222 6 22222

format 은 함수이므로 다른 함수에서 인수로 사용할 수 있습니다.

number_list = [12,45,78]
print map('the number is {}'.format, number_list)
# Out: ['the number is 12', 'the number is 45', 'the number is 78']   
    

from datetime import datetime,timedelta
    
once_upon_a_time = datetime(2010, 7, 1, 12, 0, 0)
delta = timedelta(days=13, hours=8,  minutes=20)
    
gen = (once_upon_a_time + x * delta for x in xrange(5))
    
print '\n'.join(map('{:%Y-%m-%d %H:%M:%S}'.format, gen))
#Out: 2010-07-01 12:00:00
#     2010-07-14 20:20:00
#     2010-07-28 04:40:00
#     2010-08-10 13:00:00
#     2010-08-23 21:20:00

정렬 및 패딩

'{:~<9s}, World'.format('Hello')
# 'Hello~~~~, World'

'{:~>9s}, World'.format('Hello')
# '~~~~Hello, World'

'{:~^9s}'.format('Hello')
# '~~Hello~~'

'{:0=6d}'.format(-123)
# '-00123'

참고 : 문자열 함수 인 ljust() , rjust() , center() , zfill() 사용하여 동일한 결과를 얻을 수 있지만이 함수는 버전 2.5부터 사용되지 않습니다.

서식 리터럴 (f-string)

리터럴 형식 문자열은 PEP 498 (Python 3.6 이상)에 도입되어 문자열 리터럴의 시작 부분에 f 를 추가 할 수 있으므로 현재 범위의 모든 변수와 함께 .format 을 효과적으로 적용 할 수 있습니다.

>>> foo = 'bar'
>>> f'Foo is {foo}'
'Foo is bar'

이는 정렬 및 점 표기법을 포함하여 고급 형식 문자열에서도 작동합니다.

>>> f'{foo:^7s}'
'  bar  '

참고 : f'' 는 bytes 대해 b'' 또는 unicode 에서 unicode 에 대해 u'' 와 같은 특정 유형을 나타내지 않습니다. 포매팅이 즉시 적용되어 정상적인 교반이 이루어집니다.

형식 문자열은 또한 중첩 될 수 있습니다.

>>> price = 478.23
>>> f"{f'${price:0.2f}':*>20s}"
'*************$478.23'

f- 문자열의 표현식은 왼쪽에서 오른쪽 순서로 평가됩니다. 이 표현식에 부작용이있는 경우에만 감지 할 수 있습니다.

>>> def fn(l, incr):
...    result = l[0]
...    l[0] += incr
...    return result
...
>>> lst = [0]
>>> f'{fn(lst,2)} {fn(lst,3)}'
'0 2'
>>> f'{fn(lst,2)} {fn(lst,3)}'
'5 7'
>>> lst
[10]

datetime을 사용한 문자열 포맷

모든 클래스는 __format__ 메소드를 통해 자체 문자열 형식화 구문을 구성 할 수 있습니다. 표준 파이썬 라이브러리에서이 타입을 쉽게 사용할 수있는 타입은 datetime 타입이다. str.format 내에서 직접 strftime 과 같은 포맷 코드를 사용할 수있다.

>>> from datetime import datetime
>>> 'North America: {dt:%m/%d/%Y}.  ISO: {dt:%Y-%m-%d}.'.format(dt=datetime.now())
'North America: 07/21/2016.  ISO: 2016-07-21.'

공식적인 문서 에서 datetime 포맷터의 전체 목록을 찾을 수 있습니다.

Getitem 및 Getattr을 사용하여 포맷

__getitem__ 을 지원하는 모든 데이터 구조는 중첩 된 구조로 포맷 될 수 있습니다.

person = {'first': 'Arthur', 'last': 'Dent'} 
'{p[first]} {p[last]}'.format(p=person) 
# 'Arthur Dent'

객체 속성은 getattr() 사용하여 액세스 할 수 있습니다.

class Person(object):
    first = 'Zaphod'
    last = 'Beeblebrox'

'{p.first} {p.last}'.format(p=Person())
# 'Zaphod Beeblebrox'

플로팅 형식

>>> '{0:.0f}'.format(42.12345)
'42'

>>> '{0:.1f}'.format(42.12345)
'42.1'

>>> '{0:.3f}'.format(42.12345)
'42.123'

>>> '{0:.5f}'.format(42.12345)
'42.12345'

>>> '{0:.7f}'.format(42.12345)
'42.1234500'

다른 참조 방법에 대한 동일한 보류 :

>>> '{:.3f}'.format(42.12345)
'42.123'

>>> '{answer:.3f}'.format(answer=42.12345)
'42.123'

부동 소수점 숫자는 과학 표기법 또는 백분율로 포맷 할 수 있습니다.

>>> '{0:.3e}'.format(42.12345)
'4.212e+01'

>>> '{0:.0%}'.format(42.12345)
'4212%'

{0} 및 {name} 표기법을 결합 할 수도 있습니다. 이는 모든 변수를 1 개의 선언 으로 미리 지정된 소수 자릿수로 반올림하려는 경우에 특히 유용합니다.

>>> s = 'Hello'
>>> a, b, c = 1.12345, 2.34567, 34.5678
>>> digits = 2

>>> '{0}! {1:.{n}f}, {2:.{n}f}, {3:.{n}f}'.format(s, a, b, c, n=digits)
'Hello! 1.12, 2.35, 34.57'

수치 서식 지정

.format() 메소드는 다음과 같은 다른 형식의 숫자를 해석 할 수 있습니다.

>>> '{:c}'.format(65)    # Unicode character
'A'

>>> '{:d}'.format(0x0a)  # base 10
'10'

>>> '{:n}'.format(0x0a)  # base 10 using current locale for separators
'10'

다른 기본 (16 진수, 8 진수, 2 진수)으로 정수 서식 지정

>>> '{0:x}'.format(10) # base 16, lowercase - Hexadecimal
'a'

>>> '{0:X}'.format(10) # base 16, uppercase - Hexadecimal
'A'

>>> '{:o}'.format(10) # base 8 - Octal
'12'

>>> '{:b}'.format(10) # base 2 - Binary
'1010'

>>> '{0:#b}, {0:#o}, {0:#x}'.format(42) # With prefix
'0b101010, 0o52, 0x2a'

>>> '8 bit: {0:08b}; Three bytes: {0:06x}'.format(42) # Add zero padding
'8 bit: 00101010; Three bytes: 00002a'

포맷을 사용하여 RGB float 튜플을 색상 16 진수 문자열로 변환합니다.

>>> r, g, b = (1.0, 0.4, 0.0)
>>> '#{:02X}{:02X}{:02X}'.format(int(255 * r), int(255 * g), int(255 * b))
'#FF6600'

정수 만 변환 할 수 있습니다.

>>> '{:x}'.format(42.0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: Unknown format code 'x' for object of type 'float'

클래스의 사용자 지정 서식 지정

노트 :

아래의 모든 것은 str.format 메소드와 format 함수에 적용됩니다. 아래의 텍스트에서 두 개는 서로 바꿔서 사용할 수 있습니다.

format 함수에 전달되는 모든 값에 대해 파이썬은 그 인수에 대해 __format__ 메소드를 찾습니다. 따라서 사용자 정의 클래스는 자체 __format__ 메소드를 사용하여 format 함수가 클래스를 표시하고 형식을 지정하는 방법 및 특성을 결정할 수 있습니다.

이것은 __format__ __str__ 와 같이 __str__ 는 다르다. 여러분은 정렬, 필드 폭 등을 포함하여 형식 언어를 고려할 수 있고, 심지어 원한다면 자신의 형식 지정자와 자신 만의 형식 언어 확장을 구현할 수도있다. 1

object.__format__(self, format_spec)

예 :

# Example in Python 2 - but can be easily applied to Python 3

class Example(object):
    def __init__(self,a,b,c):
        self.a, self.b, self.c = a,b,c

    def __format__(self, format_spec):
        """ Implement special semantics for the 's' format specifier """
        # Reject anything that isn't an s
        if format_spec[-1] != 's':
            raise ValueError('{} format specifier not understood for this object', format_spec[:-1])

        # Output in this example will be (<a>,<b>,<c>)
        raw = "(" + ",".join([str(self.a), str(self.b), str(self.c)]) + ")"
        # Honor the format language by using the inbuilt string format
        # Since we know the original format_spec ends in an 's' 
        # we can take advantage of the str.format method with a 
        # string argument we constructed above
        return "{r:{f}}".format( r=raw, f=format_spec )

inst = Example(1,2,3)
print "{0:>20s}".format( inst )
# out :              (1,2,3)
# Note how the right align and field width of 20 has been honored.

노트 :

사용자 정의 클래스에 사용자 정의 __format__ 메소드가없고 클래스의 인스턴스가 format 함수에 전달되면 Python2 는 __str__ 메소드 또는 __repr__ 메소드의 반환 값을 사용하여 인쇄 할 대상을 결정합니다 (둘 다 존재하지 않으면 기본 repr 이 사용됩니다), 형식 지정자는 s 형식 지정자를 사용해야합니다. Python3 에서 사용자 정의 클래스를 format 함수에 전달하려면 사용자 정의 클래스에서 __format__ 메소드를 정의해야합니다.

중첩 된 서식

일부 형식은 형식이 지정된 문자열의 너비 또는 맞춤과 같은 추가 매개 변수를 사용할 수 있습니다.

>>> '{:.>10}'.format('foo')
'.......foo'

이들도에 파라미터로서 제공 될 수있는 format 더 스팅 의해 {} 내부 {} :

>>> '{:.>{}}'.format('foo', 10)
'.......foo'
'{:{}{}{}}'.format('foo', '*', '^', 15)
'******foo******'

후자의 예에서는 '{:*^15}' 형식 문자열 ( '{:{}{}{}}' )을 '{:*^15}' 실제 문자열 'foo' 는 그런 식으로 형식화됩니다.

이는 표의 데이터를 정렬 할 때 매개 변수가 미리 알려지지 않은 경우에 유용합니다.

>>> data = ["a", "bbbbbbb", "ccc"]
>>> m = max(map(len, data))
>>> for d in data:
...     print('{:>{}}'.format(d, m))
      a
bbbbbbb
    ccc

패딩 및 자르기 문자열 결합

3 문자 열에 변수를 인쇄하고 싶다고합시다.

참고 : 배수가 { 와 } 가 이스케이프 처리됩니다.

s = """

pad
{{:3}}             :{a:3}:

truncate
{{:.3}}            :{e:.3}:

combined
{{:>3.3}}          :{a:>3.3}:
{{:3.3}}           :{a:3.3}:
{{:3.3}}           :{c:3.3}:
{{:3.3}}           :{e:3.3}:
"""

print (s.format(a="1"*1, c="3"*3, e="5"*5))

산출:

pad
{:3}             :1  :

truncate
{:.3}            :555:

combined
{:>3.3}          :  1:
{:3.3}           :1  :
{:3.3}           :333:
{:3.3}           :555:

명명 된 자리 표시 자

형식 문자열에 키워드 인수를 사용하여 보간라는 이름의 자리 표시자를 포함 할 수 있습니다 format .

사전 사용 (Python 2.x)

>>> data = {'first': 'Hodor', 'last': 'Hodor!'}
>>> '{first} {last}'.format(**data)
'Hodor Hodor!'

사전 사용 (Python 3.2 이상)

>>> '{first} {last}'.format_map(data)
'Hodor Hodor!'

str.format_map 을 사용하면 먼저 압축을 풀지 않아도 사전을 사용할 수 있습니다. 또한 새로 채워진 dict 대신 data 클래스 (사용자 정의 유형 일 수도 있음)가 사용됩니다.

사전이없는 경우 :

>>> '{first} {last}'.format(first='Hodor', last='Hodor!')
'Hodor Hodor!'