상위 목록: 하위 목록: 작성 날짜: 읽는 데 12 분 소요

데이터 출력(print)

출력(print) 함수를 이용해 확인하고자 하는 데이터를 출력할 수 있습니다.

print()는 프로그램의 결과를 사용자에게 보여주는 가장 기본적인 방법이며, 코드가 의도대로 동작하는지 변수의 값을 확인하는 디버깅 용도로도 가장 많이 사용됩니다. 제 16강의 input()이 표준 입력(stdin)에서 한 줄을 읽는다면, print()는 값을 문자열로 바꾸어 표준 출력(stdout)에 씁니다.

출력 함수를 사용할 때, 데이터를 정렬하거나 간격 등을 설정한다면 효율적으로 값을 확인할 수 있습니다. 예를 들어 소수점 자릿수를 맞추거나, 표처럼 열을 정렬하거나, 큰 숫자에 천 단위 구분 기호를 넣으면 결과를 훨씬 읽기 쉬워집니다.

Python에서 문자열 안에 값을 넣어 형식을 지정하는 방법은 크게 세 가지가 있습니다.

  1. 퍼센트(%) 연산자 : C 언어의 printf 형식을 따르는 오래된 방식
  2. str.format() 메서드 : 중괄호({})를 사용하는 방식
  3. f-string : 문자열 앞에 f를 붙여 중괄호 안에 표현식을 직접 작성하는 방식 (Python 3.6 이상)

현재는 가독성과 속도가 가장 좋은 f-string을 주로 사용합니다.

세 방법 모두 print()의 기능이 아니라 문자열을 만드는 기능이라는 점이 중요합니다. 형식이 지정된 문자열을 먼저 만들고, 그 문자열을 print()에 전달하는 것이므로 변수에 저장하거나 파일에 기록하는 등 출력 외의 용도로도 똑같이 사용할 수 있습니다.

이번 강좌에서는 print()의 인수와 동작 원리를 먼저 살펴본 뒤, 세 가지 문자열 형식 지정 방법과 폭·정밀도·정렬 같은 형식 지정자를 차례대로 다룹니다.



print("Python")
print(repr("Python"))
print(["Python", 3])
print(3.0, 1/3, True, None)

result = print()
print(result)
결과
Python
‘Python’
[‘Python’, 3]
3.0 0.3333333333333333 True None

None

print()는 전달받은 값을 str() 함수로 문자열로 변환한 뒤 출력합니다. 문자열은 따옴표 없이 내용만 출력되고, 숫자·True·None 등도 각자의 문자열 표현으로 바뀌어 출력됩니다.

repr()은 값을 코드로 작성할 때의 형태로 표현하므로, 문자열에 따옴표가 붙습니다. 공백이나 빈 문자열처럼 눈에 잘 보이지 않는 값을 확인할 때 유용합니다.

목록을 출력하면 목록 안의 요소는 repr() 형태로 표시되므로 ['Python', 3]처럼 문자열에 따옴표가 붙습니다.

print()를 인수 없이 호출하면 빈 줄을 출력합니다. 또한 print()는 화면에 출력만 할 뿐 값을 돌려주지 않으므로, 반환값은 None입니다.

  • Tip : x = print(값)처럼 출력 결과를 변수에 저장할 수 없습니다. 형식이 지정된 문자열이 필요하다면 아래에서 다룰 f-string 등으로 문자열을 만들어 저장합니다.



import sys

print("A", "B", "C")
print("A", "B", "C", sep=", ")
print("A", "B", "C", sep="")
print("첫 번째 줄", end=" → ")
print("같은 줄에 이어서 출력")
print("오류 메시지", file=sys.stderr)
print("즉시 출력", flush=True)
결과
A B C
A, B, C
ABC
첫 번째 줄 → 같은 줄에 이어서 출력
오류 메시지
즉시 출력

print(*값, sep=" ", end="\n", file=sys.stdout, flush=False)의 형태로 사용합니다.

*값은 출력할 값을 개수 제한 없이 쉼표로 나열할 수 있다는 의미입니다. 나머지 인수는 반드시 sep=처럼 이름을 지정하여 전달해야 합니다.

sep은 여러 값 사이에 들어갈 구분자이며, 기본값은 공백(" ")입니다.

end는 출력이 끝난 뒤 마지막에 붙는 문자열이며, 기본값은 줄바꿈("\n")입니다. end를 변경하면 다음 print가 같은 줄에 이어서 출력됩니다.

즉, print("A", "B", "C")는 내부적으로 "A" + " " + "B" + " " + "C" + "\n"을 출력하는 것과 같습니다. print()를 호출할 때마다 줄이 바뀌는 이유는 end의 기본값이 줄바꿈이기 때문입니다.

file은 출력할 대상이며, 기본값은 표준 출력(sys.stdout)입니다. sys.stderr로 지정하면 표준 오류로 출력되고, 파일 객체를 지정하면 파일에 기록됩니다.

flush를 True로 지정하면 버퍼에 쌓아두지 않고 즉시 출력합니다. 진행 상황을 실시간으로 표시할 때 사용합니다.

  • Tip : sys.stderr로 출력한 값은 표준 출력과 다른 흐름이므로, 콘솔에서는 함께 보이지만 출력 순서가 다르게 보이거나 리다이렉션(>) 시 파일에 저장되지 않을 수 있습니다.


for i in range(1, 6):
    print(i, end=" ")
print()

print("진행", end="")
print(".", end="")
print(".", end="")
print(" 완료")
결과
1 2 3 4 5
진행.. 완료

end를 활용하여 반복문의 결과를 한 줄에 나열하는 예제입니다.

매 회차마다 줄바꿈 대신 공백을 붙여 1 2 3 4 5 가 한 줄에 출력되며, 반복이 끝난 뒤 인수 없는 print()로 줄바꿈을 한 번 추가하여 다음 출력이 새 줄에서 시작되게 합니다.

두 번째 부분은 end=""로 아무것도 붙이지 않아 여러 번의 print()가 하나의 줄 진행.. 완료로 이어집니다. 오래 걸리는 작업의 진행 상황을 점으로 표시할 때 이 방식에 flush=True를 함께 사용합니다.

  • Tip : 줄 끝에 남은 공백이 문제가 된다면 print(*range(1, 6))처럼 값을 한 번에 전달하여 sep으로 구분합니다. *는 범위의 요소를 각각의 인수로 풀어서 전달합니다.



퍼센트 연산자

% 연산자는 C 언어의 printf에서 유래한 가장 오래된 형식 지정 방법입니다. 새로 작성하는 코드에서는 잘 사용하지 않지만, 오래된 코드나 logging 모듈 등에서 여전히 볼 수 있으므로 읽을 수 있어야 합니다.

a = 3.0

print("정수형 출력 : %d" % a)
print("실수형 출력 : %f" % a)
결과
정수형 출력 : 3
실수형 출력 : 3.000000

"형식 문자열" % 값의 형태로 % 연산자를 활용하여 값을 원하는 형식의 문자열로 변환할 수 있습니다.

%d는 정수, %f는 실수, %s는 문자열 형식을 의미하며, %d에 실수를 넣으면 소수점 이하를 버린 정수로 출력됩니다.

%f는 정밀도를 지정하지 않으면 기본으로 소수점 이하 6자리까지 출력하므로 3.000000이 됩니다.

값이 여러 개라면 "%d, %s" % (1, "A")처럼 튜플로 전달합니다.


print("%s / %r" % ("Python", "Python"))
print("%d%% 완료" % 50)
print("%s" % (1, 2))
결과
Python / ‘Python’
50% 완료
TypeError: not all arguments converted during string formatting

%s는 str(), %r은 repr()로 변환한 결과를 넣습니다. 따라서 %r에는 따옴표가 붙습니다.

형식 문자열 안에서 % 기호 자체를 출력하려면 %%처럼 두 번 작성합니다.

세 번째 줄은 % 연산자의 대표적인 함정입니다. 오른쪽에 튜플을 주면 튜플의 각 요소를 각 형식 기호에 하나씩 대응시키므로, %s 하나에 값 두 개가 전달되어 TypeError가 발생합니다. 튜플 자체를 출력하려면 "%s" % ((1, 2),)처럼 한 번 더 튜플로 감싸야 하며, 이런 불편함 때문에 이후의 format()과 f-string이 등장했습니다.



폭 설정

a = 3.0

print("폭 설정 : %3d" % a)
print("폭 설정 : %5d" % a)
결과
폭 설정 :   3
폭 설정 :     3

%상수를 입력하여 상수 크기 만큼의 폭이 설정됩니다.

값이 폭보다 짧으면 앞쪽을 공백으로 채워 오른쪽 정렬합니다. %-5d처럼 -를 붙이면 왼쪽 정렬합니다.

%3d는 최소 3칸을 확보하므로 한 자리 숫자 3 앞에 공백 2칸이, %5d는 공백 4칸이 채워집니다. 여러 줄의 숫자를 출력할 때 폭을 같게 지정하면 자릿수가 달라도 오른쪽 끝이 가지런히 정렬됩니다.

  • Tip : %05d처럼 폭 앞에 0을 붙이면 공백 대신 0으로 채워 00003이 되고, %+d처럼 +를 붙이면 양수에도 부호를 표시하여 +3이 됩니다.



정밀도 설정

a = 0.123456789

print("정밀도 설정 : %.3f" % a)
print("정밀도 설정 : %.5f" % a)
결과
정밀도 설정 : 0.123
정밀도 설정 : 0.12346

%.상수를 입력하여 소수점(.) 기호 뒤의 상수 크기 만큼의 정밀도가 설정됩니다.

%.3f는 소수점 이하 넷째 자리 4에서 반올림하여 0.123이 되고, %.5f는 여섯째 자리 6에서 반올림하여 0.12346이 됩니다.

정밀도는 출력되는 문자열에만 적용되며, 변수 a에 저장된 값은 그대로입니다. 계산은 원래 값으로 하고 보여줄 때만 자릿수를 줄이는 것이 일반적인 사용 방법입니다.

  • Tip : 정밀도는 반올림하여 처리합니다. 단, 실수는 이진수로 저장되므로 "%.2f" % 2.675가 2.67이 되는 것처럼 예상과 다르게 반올림될 수 있습니다.


print("%.0f %.0f %.0f" % (0.5, 1.5, 2.5))
결과
0 2 2

0.5, 1.5, 2.5는 이진수로 정확히 표현되는 값이므로 오차의 영향이 없는데도, 결과는 1 2 3이 아닌 0 2 2입니다.

Python의 형식 지정은 정확히 중간인 값을 가장 가까운 짝수 쪽으로 반올림하는 은행원 반올림(Round Half to Even) 방식을 사용하기 때문입니다. 반올림 방향이 한쪽으로 치우치지 않아 많은 값을 합산할 때 오차가 누적되지 않는 장점이 있습니다.

  • Tip : 금액처럼 사사오입이 반드시 필요하다면 decimal 모듈의 ROUND_HALF_UP을 사용합니다.



폭과 정밀도 설정

a = 1234.56789

print("폭&정밀도 설정 : %6.3f" % a)
print("폭&정밀도 설정 : %13.5f" % a)
결과
폭&정밀도 설정 : 1234.568
폭&정밀도 설정 :    1234.56789

%n.m를 입력하여 n 크기 만큼의 폭과 m 크기 만큼의 정밀도로 설정합니다.

폭 n은 소수점과 소수 자릿수를 모두 포함한 전체 길이입니다. 첫 번째 예제처럼 값이 폭보다 길면 폭은 무시되고 값 전체가 출력됩니다.

첫 번째 줄은 정밀도 3을 적용한 1234.568이 8글자로 폭 6보다 길어 그대로 출력됩니다. 두 번째 줄은 1234.56789가 10글자이므로, 폭 13을 맞추기 위해 앞에 공백 3칸이 채워집니다.

폭은 최소 길이일 뿐이며 값을 자르지 않습니다. 따라서 폭을 너무 작게 잡아도 숫자가 잘려 잘못 표시되는 일은 없지만, 정렬은 어긋나게 됩니다.



format 설정 (1)

str.format() 메서드는 % 연산자의 단점을 보완하기 위해 도입된 방식입니다. 형식 기호 대신 중괄호({})를 자리 표시자로 사용하며, 값의 자료형에 맞는 기호를 고를 필요가 없습니다.

a = 1
b = 2.0
c = "Python"

print("정수:{0}\n실수:{1}\n문자열:{2}".format(a, b, c))
결과
정수:1
실수:2.0
문자열:Python

"{0}{1}{2}...{n}".format(index0, index1, index2, ..., indexn)을 사용하여 포맷 형식을 설정할 수 있습니다.

format의 인덱스의 순서대로 삽입됩니다.

{0}에는 format()의 첫 번째 인수 a가, {1}에는 두 번째 인수 b가 들어갑니다. 정수·실수·문자열을 구분하는 기호 없이 각 값의 str() 결과가 그대로 삽입되며, \n은 줄바꿈 문자이므로 세 줄로 출력됩니다.

{}처럼 번호를 생략하면 순서대로 삽입되며, "{name}".format(name="Python")처럼 이름으로 지정할 수도 있습니다.


print("{0}{1}{0}".format("아", "야"))
print("{} + {} = {}".format(1, 2, 1 + 2))
print("{name}은 {age}살".format(name="윤대희", age=30))
print("{0} {}".format(1, 2))
결과
아야아
1 + 2 = 3
윤대희은 30살
ValueError: cannot switch from manual field specification to automatic field numbering

번호를 지정하면 {0}처럼 같은 값을 여러 번 사용할 수 있습니다. 이는 % 연산자로는 같은 값을 두 번 전달해야 하는 작업입니다.

이름으로 지정하면 인수의 순서와 상관없이 의미가 드러나므로, 자리 표시자가 많을 때 실수를 줄일 수 있습니다.

마지막 줄처럼 번호를 지정한 {0}과 번호를 생략한 {}를 섞어 쓰면 ValueError가 발생합니다. 한 문자열 안에서는 한 가지 방식만 사용합니다.



format 설정 (2)

L = ["1번", "2번", "3번"]

print("L0 = {0[0]}\nL1 = {0[1]}".format(L))
결과
L0 = 1번
L1 = 2번

"{0[0]}{0[1]}....{n[m]}".format(A, B, ...)을 사용하여 포맷 형식을 설정할 수 있습니다.

n은 format에 포함된 순서를 의미하며 m은 인덱스 안의 요소를 의미합니다.

{0[1]}은 “format()의 0번째 인수의 1번 요소”이므로 L[1]인 2번이 삽입됩니다.


D = {"name": "Python", "version": 3.14}

print("{0[name]} {0[version]}".format(D))
결과
Python 3.14

사전도 같은 방식으로 key를 지정해 값을 꺼낼 수 있습니다.

주의할 점은 중괄호 안의 key에 따옴표를 쓰지 않는다는 것입니다. {0[name]}의 name은 문자열 "name"으로 해석됩니다. 이처럼 중괄호 안에는 인덱싱 같은 제한된 문법만 사용할 수 있으며, 연산이나 함수 호출은 사용할 수 없습니다. 이 제한을 없앤 것이 다음의 f-string입니다.



f-string

name = "Python"
version = 3.14
L = ["1번", "2번", "3번"]

print(f"언어 : {name}, 버전 : {version}")
print(f"L0 = {L[0]}, 길이 = {len(L)}")
print(f"계산 : {2 ** 10}")
print(f"대문자 : {name.upper()}")
결과
언어 : Python, 버전 : 3.14
L0 = 1번, 길이 = 3
계산 : 1024
대문자 : PYTHON

f-string(formatted string literal)은 문자열 앞에 f 또는 F를 붙이고, 중괄호({}) 안에 변수나 표현식을 직접 작성하는 방식입니다. (Python 3.6 이상)

format()처럼 값을 뒤에 따로 나열하지 않아도 되므로, 어떤 값이 어디에 들어가는지 한눈에 확인할 수 있습니다.

중괄호 안에는 변수뿐만 아니라 인덱싱, 연산, 함수 호출 등 모든 표현식을 사용할 수 있습니다.

f-string은 실행될 때 중괄호 안의 표현식을 그 자리에서 계산하고, 결과를 str()로 변환해 문자열에 끼워 넣습니다. 예제의 {2 ** 10}은 1024를 계산한 뒤 삽입하고, {name.upper()}는 메서드를 호출한 결과 PYTHON을 삽입합니다.

  • Tip : 중괄호 자체를 출력하려면 f"{{ }}"처럼 두 번 입력합니다.


x = 10
print(f"{{x}} = {x}")

s = "Python"
print(f"{s!r} {s!s}")

n = 3
pi = 3.14159
print(f"{pi:.{n}f}")
결과
{x} = 10
‘Python’ Python
3.142

첫 번째 줄에서 두 겹의 중괄호는 글자 그대로의 중괄호로 출력되고, 한 겹의 {x}만 표현식으로 계산됩니다. 그래서 {x} = 10이 출력됩니다.

!r과 !s는 변환 지정자로, 삽입하기 전에 값을 각각 repr(), str()로 변환합니다. 문자열 값이 공백을 포함하는지 등을 확인할 때 !r을 사용하면 따옴표 덕분에 경계가 명확히 보입니다.

{pi:.{n}f}처럼 형식 지정자 안에 다시 중괄호를 넣으면, 정밀도를 변수로 지정할 수 있습니다. n이 3이므로 .3f가 적용되어 3.142가 됩니다.


x = 1
msg = f"x = {x}"

x = 2
print(msg)
print(f"x = {x}")
결과
x = 1
x = 2

f-string은 작성된 줄이 실행되는 순간 값을 계산하여 완성된 문자열을 만듭니다.

msg는 x가 1일 때 만들어졌으므로 이후 x를 2로 바꾸어도 x = 1이 유지됩니다. 변수와 연결된 템플릿이 아니라 평범한 문자열이 저장된 것이기 때문입니다. 최신 값이 필요하다면 출력할 때 f-string을 다시 실행해야 합니다.



형식 지정자

pi = 3.14159

print(f"[{pi:.2f}]")
print(f"[{42:5d}]")
print(f"[{42:<5}]")
print(f"[{42:^5}]")
print(f"[{42:*>5}]")
print(f"[{1234567:,}]")
print(f"[{0.25:.1%}]")
print(f"[{255:x}] [{255:08b}]")
결과
[3.14]
[   42]
[42   ]
[ 42  ]
[***42]
[1,234,567]
[25.0%]
[ff] [11111111]

{값:형식}처럼 콜론(:) 뒤에 형식 지정자를 작성하여 폭, 정밀도, 정렬 등을 설정할 수 있습니다.

.2f는 소수점 두 자리, 5d는 폭 5의 정수입니다. <, ^, >는 각각 왼쪽, 가운데, 오른쪽 정렬이며, 정렬 기호 앞에 문자를 쓰면 빈칸을 그 문자로 채웁니다.

,는 천 단위 구분 기호, %는 백분율, x는 16진수, b는 2진수입니다. 08b처럼 폭 앞에 0을 쓰면 빈칸을 0으로 채웁니다.

형식 지정자는 [[채움 문자]정렬][부호][0][폭][,][.정밀도][형식]의 순서로 작성합니다. 예제 결과를 읽어 보면 다음과 같습니다.

  • {42:^5} : 폭 5에 두 글자를 가운데 정렬하므로 남는 3칸을 왼쪽 1칸, 오른쪽 2칸으로 나눕니다.
  • {42:*>5} : *가 채움 문자, >가 오른쪽 정렬이므로 ***42가 됩니다.
  • {0.25:.1%} : 값에 100을 곱하고 소수점 한 자리와 % 기호를 붙여 25.0%가 됩니다.

숫자는 기본적으로 오른쪽 정렬, 문자열은 왼쪽 정렬되므로 {42:5d}는 별도의 정렬 기호 없이도 오른쪽 정렬됩니다.

  • Tip : 형식 지정자는 "{0:.2f}".format(pi)처럼 format() 메서드에서도 똑같이 사용할 수 있습니다.


print(f"{1234.5:>10,.1f}|")
print(f"{'가나':>6}|")
결과
   1,234.5|
    가나|

첫 번째 줄은 여러 지정자를 조합한 예제입니다. 오른쪽 정렬(>), 폭 10, 천 단위 구분(,), 소수점 한 자리(.1f)가 모두 적용되어 1,234.5(7글자) 앞에 공백 3칸이 채워집니다.

두 번째 줄은 한글을 정렬할 때의 주의점입니다. 폭은 글자 수 기준으로 계산되므로 '가나'는 2글자로 취급되어 공백 4칸이 채워집니다. 하지만 대부분의 콘솔에서 한글은 영문보다 두 배 넓게 표시되므로, 한글과 영문이 섞인 표는 열이 어긋나 보일 수 있습니다.



디버그 지정자(=)

x = 10
name = "Python"

print(f"{x=}")
print(f"{x * 2 = }")
print(f"{name = }")
print(f"{name = :>10}")
결과
x=10
x * 2 = 20
name = ‘Python’
name =     Python

중괄호 안의 표현식 뒤에 =를 붙이면 표현식과 그 결괏값을 함께 출력합니다. (Python 3.8 이상)

= 앞뒤에 작성한 공백도 그대로 출력되므로, {x * 2 = }처럼 원하는 형태로 표시할 수 있습니다.

=를 사용하면 기본적으로 repr() 형태로 출력되므로 문자열에는 따옴표가 붙습니다. 단, {name = :>10}처럼 형식 지정자를 함께 사용하면 str() 형태로 출력됩니다.

print("x =", x)처럼 변수 이름을 직접 적으면 변수 이름을 바꿀 때 문자열도 함께 고쳐야 하지만, 디버그 지정자는 작성한 표현식 자체를 출력하므로 이름과 값이 항상 일치합니다.

  • Tip : 변수 값을 빠르게 확인하는 디버깅 용도로 유용합니다.



f-string 문법 개선

songs = ["Python", "Java", "C"]

print(f"목록 : {", ".join(songs)}")
print(f"줄바꿈 : {"\n".join(songs)}")
print(f"합계 : {
    sum([1, 2, 3])  # 여러 줄 표현식과 주석
}")
결과
목록 : Python, Java, C
줄바꿈 : Python
Java
C
합계 : 6

Python 3.12 이상에서는 PEP 701에 따라 f-string의 문법 제한이 크게 줄었습니다.

이전 버전에서는 바깥 문자열과 같은 종류의 따옴표를 중괄호 안에서 사용할 수 없었지만, 이제는 f"{", ".join(songs)}"처럼 재사용할 수 있습니다.

또한, 중괄호 안에서 "\n"과 같은 역슬래시(\)를 사용할 수 있으며, 표현식을 여러 줄에 걸쳐 작성하고 # 주석을 추가할 수도 있습니다.

두 번째 줄은 "\n".join(songs)가 요소 사이에 줄바꿈을 넣은 문자열을 만들기 때문에, 결과가 세 줄에 걸쳐 출력됩니다.

  • Tip : Python 3.11 이하에서도 실행해야 하는 코드라면 f"{', '.join(songs)}"처럼 서로 다른 따옴표를 사용합니다.



템플릿 문자열(t-string)

name = "Python"
t = t"Hello {name}"

print(type(t))
print(t.strings)
print(t.values)
결과
<class ‘string.templatelib.Template’>
(‘Hello ‘, ‘’)
(‘Python’,)

Python 3.14 이상에서는 문자열 앞에 t를 붙인 템플릿 문자열(Template String)을 사용할 수 있습니다. (PEP 750)

f-string과 문법은 같지만, 결과가 완성된 str이 아니라 문자열 조각과 값을 따로 보관한 Template 객체입니다. strings에는 고정된 문자열 조각이, values에는 중괄호 안에서 계산된 값이 담겨 있습니다.

f-string은 값을 바로 합쳐 버리므로 값이 어떤 내용인지 검사할 기회가 없지만, t-string은 값을 합치기 전에 이스케이프하거나 검증하는 처리를 끼워 넣을 수 있습니다. 사용자 입력을 HTML이나 SQL 문장에 넣을 때처럼 안전성이 중요한 경우를 위해 도입되었습니다.

  • Tip : 단순히 화면에 출력할 문자열이 필요하다면 f-string을 사용합니다. t-string은 Template 객체를 받아서 처리하는 함수와 함께 사용하는 기능입니다.



정리

이름 설명 반환값/특징
print(*값, sep, end, file, flush) 값을 str()로 변환해 출력 반환값 None, 기본 구분자 공백, 끝에 줄바꿈
"%d" % 값 퍼센트 연산자 오래된 방식, 튜플 전달 시 함정 주의
"{0}".format(값) format() 메서드 번호·이름 지정, 같은 값 재사용 가능
f"{표현식}" f-string Python 3.6 이상, 실행 시점에 계산, 가장 권장
{값:형식} 형식 지정자 폭, 정밀도, 정렬, 채움 문자, ,, %, x, b
{표현식=} 디버그 지정자 Python 3.8 이상, 표현식과 값을 함께 출력
{값!r}, {값!s} 변환 지정자 repr(), str()로 변환 후 삽입
t"{표현식}" 템플릿 문자열 Python 3.14 이상, Template 객체 반환

세 가지 형식 지정 방법 중 어느 것을 선택할지 고민된다면 f-string을 사용합니다. 값이 문자열 안의 위치에 바로 보이고, 표현식을 직접 쓸 수 있으며, 형식 지정자도 format()과 동일합니다. % 연산자와 format()은 기존 코드를 읽거나, 형식 문자열을 미리 정의해 두고 나중에 값을 채워야 하는 경우에 사용합니다.

댓글 남기기

함께 보면 좋은 글