Python의 형식 변환, 형식(0 채우기, 지수 표기법, 16진법 등)

사업

파이썬에서 숫자나 문자열을 다양한 형식으로 변환(형식화)하려면 내장 함수 format() 또는 문자열 메서드 str.format()을 사용합니다.

이 섹션에서는 다음 기능을 사용하는 방법에 대해 설명합니다.

  • 내장 함수(예: 프로그래밍 언어)format()
  • 문자열 메서드str.format()

또한 다음 형식으로 변환하기 위한 형식 지정 문자열을 샘플 코드로 설명합니다.

  • 왼쪽 맞춤, 가운데 맞춤, 오른쪽 맞춤
  • 제로 채우기
  • 기호(더하기 또는 빼기)
  • 숫자 구분 기호(쉼표, 밑줄)
  • 2진수, 8진수, 16진수
  • 소수점 이하 자릿수 지정
  • 유효 숫자(유효 자릿수)
  • 지수 표기법
  • 백분율 표시

Python 3.6부터 f-문자열(f-문자열)이 문자열 메서드 str.format()에 추가되어 더 간결해졌습니다.

내장 함수: format()

format()은 표준 Python 내장 함수로 제공됩니다.

개요는 다음과 같습니다.

  • format(value, format_spec)
    • 첫 번째 인수:value
      원래 값입니다. 문자열 str, 숫자 int, float 등
    • 두 번째 인수format_spec
      형식 사양 문자열입니다. 문자열 str
    • 반환 값: 형식화된 문자열 str

아래에 예를 보여줍니다. 형식 문자열의 유형과 작성 방법은 나중에 설명합니다.

이 예에서는 숫자 리터럴과 문자열 리터럴을 첫 번째 인수로 사용했지만 물론 이러한 값을 포함하는 변수를 사용할 수 있습니다.

s = format(255, '04x')
print(s)
print(type(s))
# 00ff
# <class 'str'>

print(format('center', '*^16'))
# *****center*****

문자열 메서드 str.format()

문자열 str 유형에 대한 format() 메서드도 있습니다.

format() 메서드를 호출하는 문자열 str의 {}를 대체 필드라고 하며 format() 메서드의 인수로 대체됩니다.

형식 사양 문자열은 대체 필드 {} 다음에 “:”로 작성되어야 합니다.

반환 값은 형식화된 문자열 str입니다.

위에서 설명한 내장 함수 format()과 동등한 과정은 다음과 같다.

s = '{:04x}'.format(255)
print(s)
print(type(s))
# 00ff
# <class 'str'>

print('{:*^16}'.format('center'))
# *****center*****

다시 말하지만, 숫자 리터럴과 문자열 리터럴을 인수로 사용하고 있지만 물론 변수도 사용할 수 있습니다.

대체 필드에 대한 인수 지정

순서대로 인수 지정(기본값)

여러 대체 필드 {}가 있을 수 있으며 기본적으로 메서드 인수는 순서대로 처리됩니다. {}의 형식 지정 문자열이 생략되면 str()에 의해 문자열로 변환됩니다.

문자열에 변수 값을 삽입하고 인쇄하는 데 유용합니다.

print('{}-{}-{}'.format('100', '二百', 300))
# 100-二百-300

정수 값에 대한 위치 인수 지정

{0} 또는 {1}과 같이 정수 값이 {}에 지정되면 출력은 인수의 순서에 따라 달라집니다. 같은 번호를 반복해서 사용할 수 있습니다. 문자열에 동일한 값을 삽입하려는 경우에 유용합니다.

print('{0}-{1}-{0}'.format('foo', 'bar'))
# foo-bar-foo

임의의 이름(문자열)에 대한 키워드 인수 지정

{}에 아무 이름이나 지정하고 키워드 인수로 입력할 수도 있습니다.

print('{day}/{month}/{year}/'.format(day=11, month=1, year=2018))
# 11/1/2018

목록 또는 사전을 인수로 지정

목록과 사전을 인수로 지정할 수 있습니다.

[]를 사용하여 목록의 인덱스 또는 대체 필드에서 사전의 키를 지정합니다. 따옴표 “‘” 및 “”는 사전 키를 지정하는 데 사용되지 않습니다.

동일한 인수를 반복적으로 사용하려면 위에서 설명한 대로 정수 값이나 문자열(이름)을 지정해야 합니다.

l = ['one', 'two', 'three']
print('{0[0]}-{0[1]}-{0[2]}'.format(l))
# one-two-three

d1 = {'name': 'Alice', 'age': 20}
d2 = {'name': 'Bob', 'age': 30}
print('{0[name]} is {0[age]} years old.\n{1[name]} is {1[age]} years old.'.format(d1, d2))
# Alice is 20 years old.
# Bob is 30 years old.

목록에 *를 추가하고 인수로 지정하여 위치 인수로 확장하거나 사전에 **를 추가하고 인수로 지정하여 키워드 인수로 확장할 수 있습니다.

l = ['one', 'two', 'three']
print('{}-{}-{}'.format(*l))
# one-two-three

d = {'name': 'Alice', 'age': 20}
print('{name} is {age} years old.'.format(**d))
# Alice is 20 years old.

중괄호 {}에 대한 설명

format() 메서드에 중괄호 {,}를 쓰고 싶다면 {{,}}와 같이 두 번 반복합니다. 백슬래시는 이스케이프할 수 없습니다.

print('{{}}-{num}-{{{num}}}'.format(num=100))
# {}-100-{100}

형식이 지정된 문자열

두 경우 모두 형식을 지정하려면 {}에서 정수 값 또는 이름 문자열 뒤에 “:format string”을 작성합니다.

print('{num:x}'.format(num=255))
# ff

print('{day}/{month:02}/{year:02}/'.format(day=11, month=1, year=2018))
# 11/01/2018

다음에서는 형식 문자열을 사용하여 형식을 지정하는 방법에 대해 설명합니다. 샘플 코드는 문자열 메서드 str.format()을 사용하지만 동일한 형식 문자열을 내장 함수 format()과 함께 사용할 수 있습니다. 내장 함수 format()에서 형식 지정 문자열은 두 번째 인수로 지정됩니다.

왼쪽 맞춤, 가운데 맞춤, 오른쪽 맞춤

아래에서 왼쪽 맞춤, 가운데 맞춤, 오른쪽 맞춤 등을 정렬할 수 있습니다. 총 문자 수를 숫자로 지정합니다.

  • <
  • ^
  • >
print('left  : {:<10}'.format(100))
print('center: {:^10}'.format(100))
print('right : {:>10}'.format(100))
# left  : 100       
# center:    100    
# right :        100

채울 문자를 지정할 수도 있습니다. 위의 예와 같이 생략하면 공백입니다.

단일 문자이면 2바이트 문자를 사용할 수 있습니다.

print('left  : {:*<10}'.format(100))
print('center: {:a^10}'.format(100))
print('right : {:鬼>10}'.format(100))
# left  : 100*******
# center: aaa100aaaa
# right : 鬼鬼鬼鬼鬼鬼鬼100

> 기호(-,+)는 고려하지 않습니다. =를 사용하는 경우 기호 다음에 지정된 문자가 옵니다. +를 지정하려면 = 뒤에 +를 쓰십시오. 부호 처리의 세부 사항은 후술한다.

print('sign: {:0>10}'.format(-100))
print('sign: {:0=10}'.format(-100))
print('sign: {:0=+10}'.format(100))
# sign: 000000-100
# sign: -000000100
# sign: +000000100

<, ^, > 문자열에 대해 지정할 수 있지만 =는 오류 ValueError가 발생합니다. 문자열에 =를 사용하려면 int()를 사용하여 숫자로 변환해야 합니다.

# print('sign: {:0=10}'.format('-100'))
# ValueError: '=' alignment not allowed in string format specifier

print('sign: {:0=10}'.format(int('-100')))
# sign: -000000100

부동 소수점 숫자에도 동일하게 적용됩니다. 소수점도 문자로 계산됩니다.

print('left  : {:*<10}'.format(1.23))
print('center: {:a^10}'.format(1.23))
print('right : {:鬼>10}'.format(1.23))
# left  : 1.23******
# center: aaa1.23aaa
# right : 鬼鬼鬼鬼鬼鬼1.23

print('sign: {:0>10}'.format(-1.23))
print('sign: {:0=10}'.format(-1.23))
print('sign: {:0=+10}'.format(1.23))
# sign: 00000-1.23
# sign: -000001.23
# sign: +000001.23

목록, 튜플 등은 있는 그대로 지정하면 오류가 발생하며 str()을 사용하여 문자열로 변환할 수 있습니다.

l = [0, 1]
print(type(l))
# <class 'list'>

# print('{:*^16}'.format(l))
# TypeError: unsupported format string passed to list.__format__

print(type(str(l)))
# <class 'str'>

print('{:*^16}'.format(str(l)))
# *****[0, 1]*****

왼쪽 맞춤, 가운데 맞춤 및 오른쪽 맞춤의 경우 ljust(), center() 및 rjust()라는 전용 문자열 메서드도 있습니다.

0 채우기

0 채우기로 자릿수를 조정하려면 채울 문자를 0으로 설정하고 오른쪽 정렬합니다.

0 채우기의 경우 정렬 기호가 생략되면 =가 지정된 것처럼 처리됩니다.

print('zero padding: {:0=10}'.format(100))
print('zero padding: {:010}'.format(100))
# zero padding: 0000000100
# zero padding: 0000000100

print('zero padding: {:0=10}'.format(-100))
print('zero padding: {:010}'.format(-100))
# zero padding: -000000100
# zero padding: -000000100

#오류!

# print('zero padding: {:010}'.format('-100'))
# ValueError: '=' alignment not allowed in string format specifier

0 채우기의 경우 zfill()이라는 전용 문자열 메서드도 있습니다.

기호(더하기 또는 빼기)

기본적으로 음수만 기호(빼기-)로 표시됩니다.

서식 지정 문자열에 +가 추가되면 양수에 대한 기호(더하기 +)도 표시됩니다. 공백이 추가되면 양수 시작 부분에 공백이 표시되고 자릿수는 음수에 맞춰 정렬됩니다.

print('sign: {}'.format(100))
print('sign: {}'.format(-100))
# sign: 100
# sign: -100

print('sign: {:+}'.format(100))
print('sign: {:+}'.format(-100))
# sign: +100
# sign: -100

print('sign: {: }'.format(100))
print('sign: {: }'.format(-100))
# sign:  100
# sign: -100

위에서 언급한 0 채우기와 같이 임의의 문자로 채울 때 주의하십시오. + 및 공백이 없는 기본값은 양수를 하나 이상의 문자로 채웁니다.

print('sign: {:06}'.format(100))
print('sign: {:06}'.format(-100))
# sign: 000100
# sign: -00100

print('sign: {:+06}'.format(100))
print('sign: {:+06}'.format(-100))
# sign: +00100
# sign: -00100

print('sign: {: 06}'.format(100))
print('sign: {: 06}'.format(-100))
# sign:  00100
# sign: -00100

정렬 기호를 사용하는 경우 기호 지정 기호는 정렬 기호 뒤에 작성해야 합니다.

print('sign: {:_>6}'.format(100))
print('sign: {:_>6}'.format(-100))
# sign: ___100
# sign: __-100

print('sign: {:_>+6}'.format(100))
print('sign: {:_>+6}'.format(-100))
# sign: __+100
# sign: __-100

print('sign: {:_> 6}'.format(100))
print('sign: {:_> 6}'.format(-100))
# sign: __ 100
# sign: __-100

숫자 구분 기호(쉼표, 밑줄)

세 자리마다 쉼표 또는 밑줄 _ 구분 기호를 추가합니다. 이렇게 하면 큰 숫자를 더 쉽게 읽을 수 있습니다. underscore_는 Python 3.6에 추가된 옵션이므로 이전 버전에서는 사용할 수 없습니다.

print('{:,}'.format(100000000))
# 100,000,000

print('{:_}'.format(100000000))
# 100_000_000

부동 소수점 숫자 float 유형의 경우 정수 부분만 구분됩니다.

print('{:,}'.format(1234.56789))
# 1,234.56789

2진수, 8진수, 16진수

출력을 위해 숫자 값을 2진수, 8진수 및 16진수로 변환합니다.

  • b: 바이너리
  • o: 8진수
  • d: 10진수
  • x,X: 16진수(대문자는 대문자)
print('bin: {:b}'.format(255))
print('oct: {:o}'.format(255))
print('dec: {:d}'.format(255))
print('hex: {:x}'.format(255))
print('HEX: {:X}'.format(255))
# bin: 11111111
# oct: 377
# dec: 255
# hex: ff
# HEX: FF

또한 0 채우기와 결합할 수 있으며 2진수 및 16진수 표기법에서 숫자를 정렬하는 데 자주 사용됩니다.

print('bin: {:08b}'.format(255))
print('oct: {:08o}'.format(255))
print('dec: {:08d}'.format(255))
print('hex: {:08x}'.format(255))
print('HEX: {:08X}'.format(255))
# bin: 11111111
# oct: 00000377
# dec: 00000255
# hex: 000000ff
# HEX: 000000FF

접두사를 고려하여 0으로 채우는 문자 수를 지정해야 합니다.

print('bin: {:#010b}'.format(255))
print('oct: {:#010o}'.format(255))
print('dec: {:#010d}'.format(255))
print('hex: {:#010x}'.format(255))
print('HEX: {:#010X}'.format(255))
# bin: 0b11111111
# oct: 0o00000377
# dec: 0000000255
# hex: 0x000000ff
# HEX: 0X000000FF

2진수 및 16진수의 경우 밑줄 _ 자릿수 구분 기호만 삽입할 수 있습니다(Python 3.6 이상). 4자리 구분자가 사용됩니다. 0으로 채워진 문자의 수는 밑줄의 수도 고려해야 합니다.

print('hex: {:08x}'.format(255))
print('hex: {:09_x}'.format(255))
print('hex: {:#011_x}'.format(255))
# hex: 000000ff
# hex: 0000_00ff
# hex: 0x0000_00ff

정수 유형 int만이 형식을 2진수 또는 16진수로 변환할 수 있습니다. int()를 사용하여 숫자로 변환할 수 있습니다.

# print('hex: {:08x}'.format('255'))
# ValueError: Unknown format code 'X' for object of type 'str'

print('hex: {:08x}'.format(int('255')))
# hex: 000000ff

소수점 이하 자릿수 지정

소수점 이하 자릿수를 지정하려면 다음을 수행하십시오. n은 자릿수입니다. 소수점 이하 자릿수는 정수부의 자릿수에 관계없이 지정된 자릿수가 됩니다.
.[n]f

print('{:.2f}'.format(123.456))
print('{:.5f}'.format(123.456))
print('{:.3f}'.format(0.0001234))
# 123.46
# 123.45600
# 0.000

소수점 왼쪽은 위에서 설명한 대로 왼쪽 맞춤, 가운데 맞춤, 오른쪽 맞춤 또는 0 채우기로 지정할 수 있습니다. 목표 값의 자릿수가 지정된 숫자보다 크면 아무 작업도 수행하지 않습니다. 대상 값의 자릿수가 지정된 자릿수보다 크면 아무 작업도 수행되지 않습니다.

print('{:>12.5f}'.format(123.456))
print('{:012.5f}'.format(123.456))
print('{:06.5f}'.format(123.456))
#    123.45600
# 000123.45600
# 123.45600

소수점 뒤의 원래 자릿수보다 작은 자릿수를 지정하면 값이 반올림됩니다. 이것은 가장 가까운 정수로 반올림하는 것이 아니라 짝수로 반올림한다는 점에 유의하십시오. 0.5는 0으로 반올림됩니다.

print('{:.0f}'.format(0.4))
print('{:.0f}'.format(0.5))
print('{:.0f}'.format(0.6))
# 0
# 0
# 1

일반 반올림을 사용하려면 표준 라이브러리 십진수의 quantize() 메서드를 사용할 수 있습니다.

지수 표기법

부동 소수점 부동 소수점 숫자가 문자열 str로 변환되면 자릿수에 따라 자동으로 지수 표기법으로 작성됩니다. 정수 유형 int는 그렇지 않습니다.

print('{}'.format(0.0001234))
print('{}'.format(0.00001234))
# 0.0001234
# 1.234e-05

print('{}'.format(1234000000000000.0))
print('{}'.format(12340000000000000.0))
print('{}'.format(12340000000000000000000000))
# 1234000000000000.0
# 1.234e+16
# 12340000000000000000000000

서식 지정 문자열에 e 또는 E를 지정하면 항상 지수 표기법으로 변환할 수 있습니다. 출력에 사용되는 문자는 각각 e 및 E입니다.

print('{:e}'.format(0.0001234))
print('{:E}'.format(0.0001234))
# 1.234000e-04
# 1.234000E-04

소수점 이하 자릿수를 지정할 수도 있습니다. 정수 부분은 항상 한 자릿수이고 소수점은 지정된 자릿수입니다.

print('{:.5e}'.format(0.0001234))
print('{:.2E}'.format(0.0001234))
# 1.23400e-04
# 1.23E-04

print('{:.5e}'.format(987.65))
print('{:.2E}'.format(987.65))
# 9.87650e+02
# 9.88E+02

왼쪽 맞춤, 가운데 맞춤, 오른쪽 맞춤 또는 0 채우기를 지정하면 e-, E+ 등도 숫자(문자)로 계산됩니다.

print('{:>12.5e}'.format(987.65))
print('{:012.2E}'.format(987.65))
#  9.87650e+02
# 00009.88E+02

유효 숫자(유효 자릿수)

다음을 수행하여 전체 자릿수를 지정할 수 있습니다. 결과에 따라 지수 표기법이 자동으로 사용됩니다. 소수점 뒤에 오는 0은 생략됩니다.
.[n]g

print('{:.2g}'.format(123.456))
print('{:.3g}'.format(123.456))
print('{:.8g}'.format(123.456))
print('{:.3g}'.format(0.0001234))
# 1.2e+02
# 123
# 123.456
# 0.000123

g를 생략하면 출력이 정수가 아닙니다. g는 대부분의 경우 동일하지만 출력이 정수인 경우에만 해당합니다.

print('{:.2}'.format(123.456))
print('{:.3}'.format(123.456))
print('{:.8}'.format(123.456))
print('{:.3}'.format(0.0001234))
# 1.2e+02
# 1.23e+02
# 123.456
# 0.000123

동일한 값을 처리하면 각각 다음을 얻습니다.

print('{:.3f}'.format(123.456))
print('{:.3e}'.format(123.456))
print('{:.3g}'.format(123.456))
print('{:.3}'.format(123.456))
# 123.456
# 1.235e+02
# 123
# 1.23e+02

print('{:.8f}'.format(123.456))
print('{:.8e}'.format(123.456))
print('{:.8g}'.format(123.456))
print('{:.8}'.format(123.456))
# 123.45600000
# 1.23456000e+02
# 123.456
# 123.456

g의 경우 또는 생략하면 소수점 뒤의 0은 생략되므로 동일한 유효숫자수(유효자릿수)를 출력하고자 하는 경우에는 e나 E의 지수 표기법을 사용한다. 정수 부분은 항상 한 자릿수이고 소수점은 지정된 자릿수이므로 n개의 유효 자릿수를 출력하려면 n-1을 지정하면 됩니다.

print('{:.4e}'.format(123.456))
print('{:.4e}'.format(0.000012345))
print('{:.4e}'.format(12))
# 1.2346e+02
# 1.2345e-05
# 1.2000e+01

백분율 표시

형식 지정 문자열에 %가 지정되면 숫자 float 또는 int 값에 100을 곱하고 %가 있는 문자열로 변환합니다.

소수점 이하 자릿수를 지정할 수도 있습니다. 기본값은 소수점 이하 6자리입니다. 왼쪽 맞춤, 가운데 맞춤, 오른쪽 맞춤 및 0 채우기도 사용할 수 있습니다. %도 문자로 계산됩니다.

print('{:%}'.format(0.12345))
print('{:.2%}'.format(0.12345))
# 12.345000%
# 12.35%

print('{:%}'.format(10))
print('{:.2%}'.format(10))
# 1000.000000%
# 1000.00%

print('{:>7.2%}'.format(0.12345))
print('{:07.2%}'.format(0.12345))
#  12.35%
# 012.35%
Copied title and URL