2. 어휘 분석¶
파이썬 프로그램은 파서(parser) 에 의해 읽힙니다. 파서의 입력은 어휘 분석기(lexical analyzer) (또는 토크나이저(tokenizer) 라고도 함)가 생성하는 토큰 스트림입니다. 이 장에서는 어휘 분석기가 이러한 토큰을 생성하는 방식을 설명합니다.
어휘 분석기는 프로그램 텍스트의 인코딩 (기본값은 UTF-8)을 결정하고, 텍스트를 소스 문자 로 디코딩합니다. 텍스트를 디코딩할 수 없는 경우 SyntaxError 가 발생합니다.
다음으로, 어휘 분석기는 소스 문자를 사용하여 토큰 스트림을 생성합니다. 생성된 토큰의 유형은 일반적으로 다음에 처리될 소스 문자에 따라 달라집니다. 마찬가지로, 분석기의 다른 특수한 동작은 아직 처리되지 않은 첫 번째 소스 문자에 따라 결정됩니다. 다음 표는 이러한 소스 문자의 요약과 더 자세한 정보가 포함된 섹션으로의 링크를 제공합니다.
문자 |
다음 토큰 (또는 기타 관련 문서) |
|---|---|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2.1. 줄 구조(Line structure)¶
파이썬 프로그램은 여러 개의 논리적인 줄(logical lines) 들로 나뉩니다.
2.1.1. 논리적인 줄¶
The end of a logical line is represented by the token NEWLINE.
Statements cannot cross logical line boundaries except where NEWLINE
is allowed by the syntax (e.g., between statements in compound statements).
A logical line is constructed from one or more physical lines by following
the explicit or implicit
line joining rules.
2.1.2. 물리적인 줄¶
물리적인 줄은 다음 중 하나의 줄 끝 시퀀스로 종료되는 문자들의 시퀀스입니다:
ASCII LF(라인피드)를 사용하는 유닉스 형식,
ASCII 시퀀스 CR LF(리턴 뒤에 라인피드가 오는 형태)를 사용하는 윈도우 형식,
ASCII CR(캐리지 리턴) 문자를 사용하는 ‘Classic Mac OS’ 형식입니다.
플랫폼과 관계없이 이러한 시퀀스들은 각각 단일한 ASCII LF(라인피드) 문자로 대체됩니다. (이는 문자열 리터럴 내부에서도 동일하게 적용됩니다.) 각 줄은 어떤 시퀀스든 사용할 수 있으며, 파일 내에서 일관적일 필요는 없습니다.
입력의 끝 또한 마지막 물리적인 줄에 대한 암시적 종결자 역할을 합니다.
형식적으로는 다음과 같습니다:
newline: <ASCII LF> | <ASCII CR> <ASCII LF> | <ASCII CR>
2.1.4. 인코딩 선언¶
파이썬 스크립트의 첫 번 째나 두 번째 줄에 있는 주석이 정규식 coding[=:]\s*([-\w.]+) 과 매치되면, 이 주석은 인코딩 선언으로 처리됩니다. 이 정규식의 첫 번째 그룹은 소스 코드 파일의 인코딩 이름을 지정합니다. 인코딩 선언은 줄 전체에 홀로 나와야 합니다. 만약 두 번째 줄이라면, 첫 번째 줄 역시 주석만 있어야 합니다. 인코딩 선언의 권장 형태는 두 개입니다. 하나는
# -*- coding: <encoding-name> -*-
인데 GNU Emacs에서도 인식됩니다. 다른 하나는
# vim:fileencoding=<encoding-name>
인데 Bram Moolenaar 의 VIM에서 인식됩니다.
인코딩 선언이 없는 경우 기본 인코딩은 UTF-8입니다. 파일의 암시적 또는 명시적 인코딩이 UTF-8인 경우, 초기 UTF-8 바이트 순서 표시(b'\xef\xbb\xbf')는 문법 오류 대신 무시됩니다.
인코딩이 선언되면, 인코딩 이름은 파이썬이 인식할 수 있어야 합니다 (표준 인코딩를 참조하세요). 인코딩은 문자열 리터럴, 주석, 식별자를 포함한 모든 어휘 분석에서 모두 사용됩니다.
문자열 리터럴, 주석, 식별자를 포함한 모든 어휘 분석은 소스 인코딩을 사용하여 디코딩된 유니코드 텍스트에서 수행됩니다. NUL 제어 문자를 제외한 모든 유니코드 코드 포인트가 파이썬 소스에 나타날 수 있습니다.
source_character: <any Unicode code point, except NUL>
2.1.5. 명시적인 줄 결합¶
둘 이상의 물리적인 줄은 역 슬래시 문자(\)를 사용해서 논리적인 줄로 결합할 수 있습니다: 물리적인 줄이 문자열 리터럴이나 주석의 일부가 아닌 역 슬래시 문자로 끝나면, 역 슬래시와 뒤따르는 개행 문자가 제거된 채로, 현재 만들어지고 있는 논리적인 줄에 합쳐집니다. 예를 들어:
if 1900 < year < 2100 and 1 <= month <= 12 \
and 1 <= day <= 31 and 0 <= hour < 24 \
and 0 <= minute < 60 and 0 <= second < 60: # 유효한 날짜처럼 보입니다
return 1
역 슬래시로 끝나는 줄은 주석이 포함될 수 없습니다. 역 슬래시는 주석을 결합하지 못합니다. 역 슬래시는 문자열 리터럴을 제외한 어떤 토큰도 결합하지 못합니다 (즉, 문자열 리터럴 이외의 어떤 토큰도 역 슬래시를 사용해서 두 줄에 나누어 기록할 수 없습니다.). 문자열 리터럴 밖에 있는 역 슬래시가 앞에서 언급한 장소 이외의 곳에 등장하는 것은 문법에 어긋납니다.
2.1.6. 묵시적인 줄 결합¶
괄호(()), 대괄호([]), 중괄호({})가 사용되는 표현은 역 슬래시 없이도 여러 개의 물리적인 줄로 나눌 수 있습니다. 예를 들어:
month_names = ['Januari', 'Februari', 'Maart', # 이것들은
'April', 'Mei', 'Juni', # 일년을 이루는
'Juli', 'Augustus', 'September', # 달들의
'Oktober', 'November', 'December'] # 네덜란드 이름입니다
묵시적으로 이어지는 줄들은 주석을 포함할 수 있습니다. 이어지는 줄들의 들여쓰기는 중요하지 않습니다. 중간에 빈 줄이 들어가도 됩니다. 묵시적으로 줄 결합하는 줄 들 간에는 NEWLINE 토큰이 만들어지지 않습니다. 묵시적으로 이어지는 줄들은 삼중 따옴표 된 문자열들에서도 등장할 수 있는데 (아래를 보라), 이 경우는 주석이 포함될 수 없습니다.
2.1.7. 빈 줄¶
공백, 탭, 폼피드 및 선택적으로 주석만 포함된 논리적 줄은 무시됩니다(즉, NEWLINE 토큰이 생성되지 않습니다). 구문의 대화형 입력 중에 빈 줄 처리는 read-eval-print 루프의 구현에 따라 다를 수 있습니다. 표준 대화형 인터프리터에서 완전히 비어 있는 논리적 줄(즉, 공백이나 주석조차 포함하지 않는 줄)은 여러 줄로 구성된 구문을 종료합니다.
2.1.8. 들여쓰기¶
논리적인 줄의 제일 앞에 오는 공백(스페이스와 탭)은 줄의 들여쓰기 수준을 계산하는 데 사용되고, 이는 다시 문장들의 묶음을 결정하는 데 사용되게 됩니다.
탭은 (왼쪽에서 오른쪽으로) 1~8개의 스페이스로 변환되는데, 치환된 후의 총 스페이스 문자 수가 8의 배수가 되도록 맞춥니다. (유닉스에서 사용되는 규칙에 맞추려는 것입니다.) 첫 번째 비 공백 문자 앞에 나오는 공백의 총수가 줄의 들여쓰기를 결정합니다. 들여쓰기는 역 슬래시를 사용해서 여러 개의 물리적인 줄로 나눠질 수 없습니다; 첫 번째 역 슬래시 이전의 공백이 들여쓰기를 결정합니다.
소스 파일이 탭과 스페이스를 섞어 쓰는 경우, 탭이 몇 개의 스페이스에 해당하는지에 따라 다르게 해석될 수 있으면 TabError 를 일으킵니다.
크로스-플랫폼 호환성 유의 사항: UNIX 이외의 플랫폼에서 편집기들이 동작하는 방식 때문에, 하나의 파일 내에서 들여쓰기를 위해 탭과 스페이스를 섞어 쓰는 것은 현명한 선택이 아닙니다. 다른 플랫폼들에서는 최대 들여쓰기 수준에 제한이 있을 수도 있다는 점도 주의해야 합니다.
폼 피드 문자는 줄의 처음에 나올 수 있습니다; 앞서 설명한 들여쓰기 수준 계산에서는 무시됩니다. 선행 공백의 다른 곳에 등장하는 폼 피드 문자는 정의되지 않은 효과를 줍니다 (가령, 스페이스 수가 0으로 초기화될 수 있습니다).
연속된 줄의 들여쓰기 수준은 스택을 사용하여 다음과 같이 INDENT 및 DEDENT 토큰을 생성하는 데 사용됩니다.
파일의 첫 번째 줄을 읽기 전에 스택에 단일 0을 푸시하며, 이는 다시는 꺼내지지 않습니다. 스택에 푸시되는 숫자들은 아래에서 위로 갈수록 항상 엄격하게 증가합니다. 각 논리적 줄의 시작 부분에서 해당 줄의 들여쓰기 수준을 스택의 최상단과 비교합니다. 값이 같으면 아무 일도 일어나지 않습니다. 값이 더 크면 스택에 푸시되고 하나의 INDENT 토큰이 생성됩니다. 값이 더 작으면 그 값은 반드시 스택에 존재하는 숫자 중 하나여야 하며, 스택에서 자신보다 큰 모든 숫자를 꺼내고(pop) 꺼내진 각 숫자마다 하나의 DEDENT 토큰을 생성합니다. 파일의 끝에서 0보다 큰 상태로 스택에 남아 있는 각 숫자마다 DEDENT 토큰이 생성됩니다.
여기에 (혼란스럽다 할지라도) 올바르게 들여쓰기 된 파이썬 코드 조각이 있습니다:
def perm(l):
# l 의 모든 순열의 리스트를 계산합니다
if len(l) <= 1:
return [l]
r = []
for i in range(len(l)):
s = l[:i] + l[i+1:]
p = perm(s)
for x in p:
r.append(l[i:i+1] + x)
return r
다음 예는 여러 가지 들여쓰기 에러를 보여줍니다:
def perm(l): # 에러: 첫 줄을 들여쓰기 했습니다
for i in range(len(l)): # 에러: 들여쓰지 않았습니다
s = l[:i] + l[i+1:]
p = perm(l[:i] + l[i+1:]) # 에러: 예기치 않은 들여쓰기
for x in p:
r.append(l[i:i+1] + x)
return r # 에러: 일관성 없는 내어쓰기
(사실, 처음 세 개의 에러는 파서가 감지합니다. 단지 마지막 에러만 어휘 분석기가 감지합니다. — return r 의 들여쓰기가 스택에 있는 값과 일치하지 않습니다.)
2.1.9. 토큰 사이의 공백¶
논리적 줄의 시작이나 문자열 리터럴 내를 제외하고, 공백(space), 탭(tab), 폼피드(formfeed) 같은 공백 문자는 토큰을 구분하는 데 서로 대체하여 사용될 수 있습니다.
whitespace: ' ' | tab | formfeed
두 토큰 사이에 공백이 필요한 경우는 오직 그 두 토큰을 결합했을 때 다른 토큰으로 해석될 가능성이 있는 경우뿐입니다. 예를 들어, ab 는 하나의 토큰이지만 a b 는 두 개의 토큰입니다. 그러나 +a 와 + a 는 모두 『+』와 『a』라는 두 개의 토큰을 생성하는데, 이는 +a 가 유효한 토큰이 아니기 때문입니다.
2.1.10. 종료 마커¶
비대화형 입력의 끝에서 어휘 분석기는 ENDMARKER 토큰을 생성합니다.
2.2. 다른 토큰들¶
음성적인 의미를 지닌 NEWLINE, INDENT, 및 DEDENT 외에도 다음과 같은 범주의 토큰들이 존재합니다: 식별자 와 키워드 (NAME), 리터럴 (예를 들어 NUMBER 및 STRING), 그리고 다른 기호들(연산자 및 구분자, OP). 공백 문자(앞서 언급한 논리적 줄 구분자 제외)는 토큰이 아니며 토큰을 구분하는 역할을 합니다. 모호성이 있는 경우, 해당 위치에서 왼쪽에서 오른쪽으로 읽었을 때 유효한 토큰을 형성하는 가장 긴 문자열이 하나의 토큰이 됩니다.
2.3. 이름(식별자 및 키워드)¶
NAME 토큰은 식별자, 키워드, 그리고 소프트 키워드 를 나타냅니다.
이름은 다음과 같은 문자로 구성됩니다.
대문자 및 소문자(
A-Z및a-z),밑줄(
_),첫 번째 문자로 올 수 없는 숫자(
0부터9까지), 그리고비 ASCII 문자. 유효한 이름은 오직 “문자 형태(letter-like)” 및 “숫자 형태(digit-like)”의 문자만 포함할 수 있습니다. 자세한 내용은 이름에 포함된 비 ASCII 문자 를 참조하십시오.
이름은 최소 하나의 문자를 포함해야 하며, 최대 길이는 제한이 없습니다. 대소문자를 구분합니다.
엄격하게 말하면, 이름은 다음과 같은 어휘 정의로 설명됩니다.
NAME:name_startname_continue* name_start: "a"..."z" | "A"..."Z" | "_" | <non-ASCII character> name_continue: name_start | "0"..."9" identifier: <NAME, except keywords>
이 문법과 일치하는 모든 이름이 유효한 것은 아니라는 점에 주의하십시오. 자세한 내용은 이름에 포함된 비 ASCII 문자 를 참조하십시오.
2.3.1. 키워드¶
다음의 이름들은 예약어 또는 언어의 키워드 로 사용되며, 일반적인 식별자로 사용할 수 없습니다. 이 단어들은 아래에 적힌 것과 정확하게 철자가 일치해야 합니다.
False await else import pass
None break except in raise
True class finally is return
and continue for lambda try
as def from nonlocal while
assert del global not with
async elif if or yield
2.3.2. 소프트 키워드¶
Added in version 3.10.
일부 이름은 특정 문맥에서만 예약어로 취급됩니다. 이를 소프트 키워드 라고 합니다.
이것들은 해당 문맥에서 구문론적으로 키워드 역할을 하지만, 이 구분은 토큰화 단계가 아닌 파서 수준에서 이루어집니다.
소프트 키워드로서, 이들은 문법 내에서 사용 가능하면서도 기존에 이러한 이름을 식별자로 사용하는 코드와의 호환성을 유지합니다.
버전 3.12에서 변경: type 은 이제 소프트 키워드입니다.
버전 3.15에서 변경: lazy 는 이제 소프트 키워드입니다.
2.3.3. 식별자의 예약 영역¶
(키워드와는 별개로) 어떤 부류의 식별자들은 특별한 의미가 있습니다. 이 부류의 식별자들은 시작과 끝의 밑줄 문자 패턴으로 구분됩니다:
_*from module import *에 의해 임포트되지 않습니다._match문 내의case패턴에서,_는 soft keyword 이며 wildcard 를 나타내는 것입니다.한편, 대화형 인터프리터는 마지막 평가 결과물을 변수
_에 저장합니다. (print와 같은 내장 함수와 함께,builtins모듈에 저장됩니다.)그 외의 장소에서
_는 일반적인 식별자입니다. 종종 “특별한” 항목에 이름을 붙이기 위해 사용되지만, 파이썬 자체에 특별한 의미를 갖지는 않습니다.참고
이름
_은 종종 국제화(internationalization)와 관련되어 사용됩니다. 이 관례에 관해서는gettext모듈의 문서를 참조하십시오.또한 사용되지 않는 변수를 표기할 때도 흔히 사용됩니다.
__*__시스템 정의 이름, 비공식적으로 “던더(dunder)” 이름이라고 알려졌습니다. 이 이름들은 인터프리터와 그 구현(표준 라이브러리를 포함합니다)이 정의합니다. 현재 정의된 시스템 이름은 특수 메서드 이름들 섹션과 그 외의 곳에서 논의됩니다. 파이썬의 미래 버전에서는 더 많은 것들이 정의될 가능성이 큽니다. 어떤 문맥에서건, 명시적으로 문서로 만들어진 사용법을 벗어나는
__*__이름의 모든 사용은, 경고 없이 손상될 수 있습니다.__*클래스-비공개 이름. 이 부류의 이름들을 클래스 정의 문맥에서 사용하면 뒤섞인 형태로 변형됩니다. 부모 클래스와 자식 클래스의 “비공개(private)” 어트리뷰트 간의 이름 충돌을 피하기 위함입니다. 식별자 (이름) 섹션을 보세요.
2.3.4. 이름에 포함된 비 ASCII 문자¶
비 ASCII 문자를 포함하는 이름은 above 규칙과 문법 외에 추가적인 정규화 및 검증이 필요합니다. 예를 들어, ř_1, 蛇 또는 साँप 는 유효한 이름이지만, r〰2, € 또는 🐍 은 그렇지 않습니다.
이 섹션에서는 정확한 규칙을 설명합니다.
모든 이름은 파싱 과정에서 normalization form NFKC로 변환됩니다. 이는 예를 들어, 특정 문자의 타이포그래피 변형이 “기본” 형태로 변환됨을 의미합니다. 가령 fiⁿₐˡᵢᶻₐᵗ Choudिὸₙ 는 finalization 으로 정규화되므로, 파이썬은 이들을 동일한 이름으로 취급합니다.
>>> fiⁿₐˡᵢᶻₐᵗᵢᵒₙ = 3
>>> finalization
3
참고
정규화는 어휘 단계에서만 수행됩니다. 이름을 문자열 로 받는 런타임 함수들은 일반적으로 인자를 정규화하지 않습니다. 예를 들어, 위에서 정의된 변수는 런타임에 globals() 딕셔너리에서 globals()["finalization"] 로는 접근 가능하지만 globals()["fiⁿₐˡᵢᶻₐᵗ Choudिὸₙ"] 로는 접근할 수 없습니다.
ASCII 전용 이름이 문자, 숫자 및 밑줄만 포함해야 하며 숫자로 시작할 수 없는 것과 마찬가지로, 유효한 이름은 반드시 “문자 형태” 집합인 xid_start 에 속하는 문자로 시작해야 하며 나머지 문자들은 “문자 및 숫자 형태” 집합인 xid_continue 에 속해야 합니다.
이 집합들은 유니코드 표준 부록 UAX-31 에 정의된 XID_Start 및 XID_Continue 집합을 기반으로 합니다. 파이썬의 xid_start 는 추가로 밑줄(_)을 포함합니다. 파이썬이 반드시 UAX-31 를 준수하는 것은 아니라는 점에 유의하십시오.
유니코드에서 정의한 XID_Start 및 XID_Continue 집합에 포함된 문자의 비규범적 목록은 유니코드 문자 데이터베이스의 DerivedCoreProperties.txt 파일에서 확인할 수 있습니다. 참고를 위해 xid_* 집합의 구성 규칙을 아래에 기술합니다.
id_start 집합은 다음의 합집합으로 정의됩니다.
유니코드 카테고리
<Lu>- 대문자(A부터Z까지 포함)유니코드 카테고리
<Ll>- 소문자(a부터z까지 포함)유니코드 카테고리
<Lt>- 타이틀케이스 문자유니코드 카테고리
<Lm>- 수식 문자유니코드 카테고리
<Lo>- 기타 문자유니코드 카테고리
<Nl>- 문자 형태 숫자{
"_"} - 밑줄<Other_ID_Start>- 하위 호환성을 지원하기 위한 PropList.txt 의 명시적인 문자 집합
그런 다음 xid_start``는 정규화 결과가 ``id_start id_continue* 형식이 아닌 모든 문자를 제거함으로써 NFKC 정규화 조건에서 이 집합을 닫습니다.
id_continue 집합은 다음의 합집합으로 정의됩니다.
id_start(위 참조)유니코드 카테고리
<Nd>- 십진수(0부터9까지 포함)유니코드 카테고리
<Pc>- 연결 문장 부호유니코드 카테고리
<Mn>- 비공백 표기유니코드 카테고리
<Mc>- 공백 결합 표기<Other_ID_Continue>- 하위 호환성을 지원하기 위한 PropList.txt 의 또 다른 명시적인 문자 집합
마찬가지로 xid_continue 는 NFKC 정규화 조건에서 이 집합을 닫습니다.
유니코드 카테고리는 unicodedata 모듈에 포함된 유니코드 문자 데이터베이스 버전을 사용합니다.
2.4. 리터럴¶
리터럴(literal)은 몇몇 내장형들의 상숫값을 위한 표기법입니다.
어휘 분석 관점에서 파이썬은 문자열, 바이트열 및 숫자 리터럴을 가집니다.
다른 “리터럴”은 어휘적으로 키워드 <keywords>`(``None`, True, False) 및 특수한 생략 기호 토큰 <lexical-ellipsis>`(`…``)을 사용하여 표기됩니다.
2.5. 문자열과 바이트열 리터럴¶
문자열 리터럴은 단일 따옴표(') 또는 큰따옴표(")로 둘러싸인 텍스트입니다. 예시는 다음과 같습니다.
"spam"
'eggs'
리터럴을 시작할 때 사용한 따옴표는 그 리터럴의 끝을 알리는 역할도 하므로, 문자열 리터럴은 다른 종류의 따옴표만 포함할 수 있습니다(이스케이프 시퀀스는 제외, 아래 참조). 예시는 다음과 같습니다.
'Say "Hello", please.'
"Don't do that!"
이러한 제한을 제외하고는 따옴표의 종류(' 또는 ")가 리터럴 파싱 방식에 영향을 주지 않습니다.
문자열 리터럴 내에서 백슬래시(\) 문자는 이스케이프 시퀀스 를 생성하며, 이는 백슬래시 뒤에 오는 문자에 따라 특별한 의미를 가집니다. 예를 들어, \" 는 큰따옴표 문자를 나타내며 문자열을 종료하지 않습니다.
>>> print("Say \"Hello\" to everyone!")
Say "Hello" to everyone!
그러한 시퀀스의 전체 목록과 더 자세한 내용은 아래의 이스케이프 시퀀스 를 참조하십시오.
2.5.1. 삼중 따옴표 문자열¶
문자열은 세 개씩 짝을 이루는 단일 따옴표 또는 큰따옴표로 둘러쌀 수도 있습니다. 이들은 일반적으로 삼중 따옴표 문자열 이라 불립니다.
"""이것은 삼중 따옴표 문자열입니다."""
삼중 인용 리터럴에서 이스케이프되지 않은 따옴표는 허용되며 유지되지만, 시작할 때 사용한 것과 동일한 종류(' 또는 ")의 이스케이프되지 않은 따옴표가 세 개 연속으로 나오면 리터럴이 종료됩니다:
"""이 문자열은 내부에 "따옴표"를 포함하고 있습니다."""
이스케이프되지 않은 개행도 허용되며 유지됩니다:
'''This triple-quoted string
continues on the next line.'''
2.5.2. 문자열 접두사¶
문자열 리터럴은 선택적인 접두사 를 가질 수 있으며, 이는 리터럴의 내용이 파싱되는 방식에 영향을 미칩니다. 예를 들어:
b"data"
f'{result=}'
허용되는 접두사는 다음과 같습니다.
b: 바이트열 리터럴r: 날 문자열f: 포맷 문자열 리터럴 (“f-string”)t: 템플릿 문자열 리터럴 (“t-string”)u: 영향 없음 (하위 호환성을 위해 허용됨)
각 유형에 대한 자세한 내용은 연결된 섹션을 참조하십시오.
접두사는 대소문자를 구분하지 않습니다(예를 들어, ‘B’는 ‘b’와 동일하게 작동합니다). ‘r’ 접두사는 ‘f’, ‘t’, 또는 ‘b’와 결합될 수 있으므로, ‘fr’, ‘rf’, ‘tr’, ‘rt’, ‘br’, 그리고 ‘rb’ 또한 유효한 접두사입니다.
Added in version 3.3: 날 바이트열 리터럴의 'br' 와 같은 의미가 있는 'rb' 접두어가 추가되었습니다.
파이썬 2.x 와 3.x 에서 동시에 지원하는 코드들의 유지보수를 단순화하기 위해 예전에 사용되던 유니코드 리터럴 (u'value')이 다시 도입되었습니다. 자세한 정보는 PEP 414 에 나옵니다.
2.5.3. 형식 문법¶
“f-문자열” 및 “t-문자열” 을 제외한 문자열 리터럴은 다음의 어휘 정의에 의해 설명됩니다.
이 정의들은 끝나는 따옴표가 리터럴을 종료함을 나타내기 위해 부정적 미리 보기 어서션 (!)를 사용합니다.
STRING: [stringprefix] (stringcontent) stringprefix: <("r" | "u" | "b" | "br" | "rb"), case-insensitive> stringcontent: | "'''" ( !"'''"longstringitem)* "'''" | '"""' ( !'"""'longstringitem)* '"""' | "'" ( !"'"stringitem)* "'" | '"' ( !'"'stringitem)* '"' stringitem:stringchar|stringescapeseqstringchar: <anysource_character, except backslash and newline> longstringitem:stringitem| newline stringescapeseq: "\" <anysource_character>
모든 어휘 정의와 마찬가지로 공백이 중요하다는 점에 주의하십시오. 특히, 접두사가 있는 경우 접두사 바로 뒤에 시작 따옴표가 와야 합니다.
2.5.4. 이스케이프 시퀀스¶
‘r’ 또는 ‘R’ 접두사가 없는 경우, 문자열 및 바이트열 리터럴의 이스케이프 시퀀스는 Standard C에서 사용되는 규칙과 유사하게 해석됩니다. 인식되는 이스케이프 시퀀스는 다음과 같습니다.
이스케이프 시퀀스 |
의미 |
|---|---|
|
|
|
|
|
|
|
|
|
ASCII 벨 (BEL) |
|
ASCII 백스페이스 (BS) |
|
ASCII 폼 피드 (FF) |
|
ASCII 라인 피드 (LF) |
|
ASCII 캐리지 리턴 (CR) |
|
ASCII 가로 탭 (TAB) |
|
ASCII 세로 탭 (VT) |
|
|
|
|
|
|
|
|
|
2.5.4.1. 무시되는 줄 끝¶
줄 끝에 역 슬래시를 추가하여 개행을 무시할 수 있습니다:
>>> 'This string will not include \
... backslashes or newline characters.'
'This string will not include backslashes or newline characters.'
동일한 결과는 삼중 인용 문자열 를 사용하거나, 괄호와 문자열 리터럴 연결 을 사용하여 얻을 수 있습니다.
2.5.4.2. 이스케이프된 문자¶
이스케이프되지 않은 날 문자열 <raw-strings>`이 아닌 파이썬 문자열 리터럴에 역 슬래시를 포함하려면 이를 두 번 써야 합니다. `\`` 이스케이프 시퀀스는 단일 역 슬래시 문자를 나타냅니다:
>>> print('C:\\Program Files')
C:\Program Files
마찬가지로, \' 및 \" 시퀀스는 각각 작은따옴표와 큰따옴표 문자를 나타냅니다:
>>> print('\' and \"')
' and "
2.5.4.3. 8진수 문자¶
\ooo 시퀀스는 8진수(기수 8) 값이 ooo 인 문자 를 나타냅니다:
>>> '\120'
'P'
최대 3개의 8진수(0~7)가 허용됩니다.
바이트열 리터럴에서 문자 는 주어진 값의 바이트 를 의미합니다. 문자열 리터럴에서는 주어진 값의 유니코드 문자를 의미합니다.
버전 3.11에서 변경: 값이 0o377 (255)보다 큰 8진수 이스케이프는 DeprecationWarning 을 발생시킵니다.
버전 3.12에서 변경: 값이 0o377 (255)보다 큰 8진수 이스케이프는 SyntaxWarning 을 발생시킵니다. 향후 파이썬 버전에서는 SyntaxError 를 발생시킬 것입니다.
2.5.4.4. 16진수 문자¶
\xhh 시퀀스는 16진수(기수 16) 값이 hh 인 문자 를 나타냅니다:
>>> '\x50'
'P'
표준 C와는 달리, 정확히 두 개의 16진수가 제공되어야 합니다.
바이트열 리터럴에서 문자 는 주어진 값의 바이트 를 의미합니다. 문자열 리터럴에서는 주어진 값의 유니코드 문자를 의미합니다.
2.5.4.5. 이름이 있는 유니코드 문자¶
\N{name} 시퀀스는 주어진 이름 을 가진 유니코드 문자를 나타냅니다:
>>> '\N{LATIN CAPITAL LETTER P}'
'P'
>>> '\N{SNAKE}'
'🐍'
이 시퀀스는 바이트열 리터럴 에서 나타날 수 없습니다.
버전 3.3에서 변경: 이름 별칭 지원이 추가되었습니다.
2.5.4.6. 16진수 유니코드 문자¶
이 시퀀스인 \uxxxx 및 \Uxxxxxxxx 는 주어진 16진수(기수 16) 값의 유니코드 문자를 나타냅니다. \u 의 경우 정확히 네 자리가 필요하며, \u 의 경우 정확히 여덟 자리가 필요합니다. 후자는 모든 유니코드 문자를 인코딩할 수 있습니다.
>>> '\u1234'
'ሴ'
>>> '\U0001f40d'
'🐍'
이 시퀀스들은 바이트열 리터럴 에서 나타날 수 없습니다.
2.5.4.7. 인식되지 않는 이스케이프 시퀀스¶
Standard C와 달리, 인식되지 않는 모든 이스케이프 시퀀스는 문자열에서 변경되지 않은 상태로 남습니다. 즉, 결과에 역 슬래시가 그대로 포함됩니다.:
>>> print('\q')
\q
>>> list('\q')
['\\', 'q']
바이트열 리터럴의 경우, 문자열 리터럴에서만 인식되는 이스케이프 시퀀스(\N..., \u..., \U...)는 인식되지 않는 이스케이프로 분류된다는 점에 주의하십시오.
버전 3.6에서 변경: 인식되지 않는 이스케이프 시퀀스는 DeprecationWarning 을 발생시킵니다.
버전 3.12에서 변경: 인식되지 않는 이스케이프 시퀀스는 SyntaxWarning 을 발생시킵니다. 향후 파이썬 버전에서는 SyntaxError 를 발생시킬 것입니다.
2.5.5. 바이트열 리터럴¶
바이트열 리터럴`은 항상 ‘``b`’ 또는 ‘B’ 접두사가 붙으며, str 타입 대신 bytes 타입의 인스턴스를 생성합니다. 바이트열 리터럴은 ASCII 문자만 포함할 수 있으며, 숫자 값이 128 이상인 바이트는 반드시 이스케이프 시퀀스(일반적으로 16진수 문자 또는 8진수 문자)로 표현해야 합니다:
>>> b'\x89PNG\r\n\x1a\n'
b'\x89PNG\r\n\x1a\n'
>>> list(b'\x89PNG\r\n\x1a\n')
[137, 80, 78, 71, 13, 10, 26, 10]
마찬가지로, 영(zero) 바이트는 이스케이프 시퀀스(일반적으로 \0 또는 \x00)를 사용하여 표현해야 합니다.
2.5.6. 날 문자열 리터럴¶
문자열 및 바이트열 리터럴 모두에 ‘r ‘ 또는 ‘R ‘ 문자를 접두사로 추가할 수 있습니다. 이러한 구조는 각각 날 문자열 리터럴 및 날 바이트열 리터럴 이라 불리며 역 슬래시를 리터럴 문자로 취급합니다. 그 결과, 날 문자열 리터럴에서는 이스케이프 시퀀스 가 특별하게 처리되지 않습니다:
>>> r'\d{4}-\d{2}-\d{2}'
'\\d{4}-\\d{2}-\\d{2}'
날 리터럴에서 조차, 따옴표는 역 슬래시로 이스케이프 됩니다. 하지만 역 슬래시가 결과에 남게 됩니다; 예를 들어, r"\"" 는 올바른 문자열 리터럴인데, 두 개의 문자가 들어있습니다: 역 슬래시와 큰따옴표; r"\" 는 올바른 문자열 리터럴이 아닙니다 (날 문자열조차 홀수개의 역 슬래시로 끝날 수 없습니다.). 좀 더 명확하게 말하자면, 날 리터럴은 하나의 역 슬래시로 끝날 수 없습니다(역 슬래시가 뒤에 오는 따옴표를 이스케이프 시키기 때문입니다). 역 슬래시와 바로 뒤에 오는 개행문자는 줄 결합이 아니라 리터럴에 포함되는 두 개의 문자로 인식됨에 주의해야 합니다.
2.5.7. 포맷 문자열 리터럴¶
Added in version 3.6.
버전 3.8에서 변경: 디버그 지정자(=)가 추가되었습니다.
버전 3.12에서 변경: f-문자열 내 표현식에 대한 많은 제한이 제거되었습니다. 특히 중첩된 문자열, 주석, 역 슬래시가 이제 허용됩니다.
포맷 문자열 리터럴 또는 f-문자열 은 ‘f ‘ 또는 ‘F ‘ 접두사가 붙은 문자열 리터럴입니다. 다른 문자열 리터럴과 달리, f-문자열은 상수가 아닙니다. 이들은 중괄호 {} 로 구분된 치환 필드 를 포함할 수 있습니다. 치환 필드는 실행 시 평가되는 표현식을 포함합니다. 예를 들어:
>>> who = 'nobody'
>>> nationality = 'Spanish'
>>> f'{who.title()} expects the {nationality} Inquisition!'
'Nobody expects the Spanish Inquisition!'
치환 필드 외부의 중복된 중괄호({{ 또는 }})는 해당되는 단일 중괄호로 대체됩니다:
>>> print(f'{{...}}')
{...}
치환 필드 이외의 다른 문자들은 일반적인 문자열 리터럴과 동일하게 취급됩니다. 즉, (리터럴이 날 문자열로 표시되지 않은 경우를 제외하고) 이스케이프 시퀀스가 디코딩되며, 삼중 인용 f-문자열에서 개행을 사용할 수 있습니다:
>>> name = 'Galahad'
>>> favorite_color = 'blue'
>>> print(f'{name}:\t{favorite_color}')
Galahad: blue
>>> print(rf"C:\Users\{name}")
C:\Users\Galahad
>>> print(f'''Three shall be the number of the counting
... and the number of the counting shall be three.''')
Three shall be the number of the counting
and the number of the counting shall be three.
포맷 문자열 리터럴 내의 표현식은 일반적인 파이썬 표현식과 동일하게 취급됩니다. 각 표현식은 포맷 문자열 리터럴이 나타나는 문맥에서 왼쪽에서 오른쪽 순서로 평가됩니다. 빈 표현식은 허용되지 않으며, lambda`와 대입 표현식 `:=``은 모두 명시적인 괄호로 둘러싸여야 합니다:
>>> f'{(half := 1/2)}, {half * 42}'
'0.5, 21.0'
치환 필드 내부에서 외부 f-문자열의 인용 방식을 재사용하는 것이 허용됩니다:
>>> a = dict(x=2)
>>> f"abc {a["x"]} def"
'abc 2 def'
치환 필드 내에서도 역 슬래시가 허용되며, 다른 상황과 동일하게 평가됩니다:
>>> a = ["a", "b", "c"]
>>> print(f"List a contains:\n{"\n".join(a)}")
List a contains:
a
b
c
f-문자열을 중첩하여 사용하는 것이 가능합니다:
>>> name = 'world'
>>> f'Repeated:{f' hello {name}' * 3}'
'Repeated: hello world hello world hello world'
이식 가능한 파이썬 프로그램은 5단계 이상의 중첩을 사용하지 않아야 합니다.
CPython은 f-문자열의 중첩을 제한하지 않습니다.
치환 표현식은 단일 따옴표와 삼중 따옴표를 사용하는 f-문자열 모두에서 개행을 포함할 수 있으며 주석을 포함할 수도 있습니다. 치환 필드 내의 # 뒤에 오는 모든 내용은 주석으로 처리됩니다(닫는 중괄호나 따옴표도 포함). 따라서 주석이 있는 경우 치환 필드는 다른 줄에서 닫혀야 합니다:
>>> a = 2
>>> f"abc{a # This comment }" continues until the end of the line
... + 3}"
'abc5'
표현식 뒤에 치환 필드가 선택적으로 다음을 포함할 수 있습니다.
하나 이상의 디버그 지정자 — 양쪽 중 한쪽 또는 양쪽에 공백이 있을 수 있는 등호(
=);변환 지정자(conversion specifier) —
!s,!r또는!a; 그리고/또는콜론(
:)으로 시작하는 포맷 지정자(format specifier).
이 필드들이 평가되는 방식에 대한 자세한 내용은 Standard Library f-문자열 섹션 을 참조하십시오.
해당 섹션에서 설명하듯이, 포맷 지정자 는 치환 필드 값을 포매팅하기 위해 format() 함수의 두 번째 인자로 전달됩니다. 예를 들어, 포맷 지정어 간이 언어 를 사용하여 필드의 너비와 채우기 문자를 지정할 수 있습니다:
>>> number = 14.3
>>> f'{number:20.7f}'
' 14.3000000'
최상위 포맷 지정자는 중첩된 치환 필드를 포함할 수 있습니다:
>>> field_size = 20
>>> precision = 7
>>> f'{number:{field_size}.{precision}f}'
' 14.3000000'
이러한 중첩된 필드는 고유의 변환 필드와 포맷 지정자 를 포함할 수 있습니다:
>>> number = 3
>>> f'{number:{field_size}}'
' 3'
>>> f'{number:{field_size:05}}'
'00000000000000000003'
하지만 이러한 중첩된 필드는 더 깊이 중첩된 치환 필드를 포함할 수 없습니다.
포맷 문자열 리터럴은 표현식을 포함하지 않더라도 독스트링 으로 사용할 수 없습니다:
>>> def foo():
... f"Not a docstring"
...
>>> print(foo.__doc__)
None
더 보기
PEP 498 – 리터럴 문자열 보간
PEP 701 – f-문자열의 구문 공식화
관련된 포맷 문자열 메커니즘을 사용하는
str.format().
2.5.8. t-문자열¶
Added in version 3.14.
템플릿 문자열 리터럴 또는 t-문자열 은 ‘t ‘ 또는 ‘T ‘가 접두어로 붙은 문자열 리터럴입니다. 이 문자열들은 포맷 문자열 리터럴 과 동일한 구문 규칙을 따릅니다. 평가 규칙의 차이점은 Standard Library t-문자열 섹션 을 참조하십시오.
2.5.9. f-문자열을 위한 공식 문법¶
F-strings are handled partly by the lexical analyzer, which produces the
tokens FSTRING_START, FSTRING_MIDDLE
and FSTRING_END, and partly by the parser, which handles
expressions in the replacement field.
The exact way the work is split is a CPython implementation detail.
이에 대응하여, f-문자열 문법은 어휘 및 구문 정의 의 혼합체입니다.
다음 상황에서 공백은 유의미하게 처리됩니다:
FSTRING_START에서(접두어와 따옴표 사이) 공백이 없을 수 있습니다.FSTRING_MIDDLE의 공백은 리터럴 문자열 내용의 일부입니다.fstring_replacement_field``에서 ``f_debug_specifier``가 존재하는 경우, 여는 중괄호 이후부터 ``f_debug_specifier``까지의 모든 공백과 ``f_debug_specifier바로 뒤의 공백이 표현식의 일부로 유지됩니다.표현식은 토큰화 단계에서 처리되지 않으며,
{토큰과=뒤의 토큰 위치를 사용하여 소스 코드에서 가져옵니다.
FSTRING_MIDDLE 정의는 특수 문자(백슬래시, 개행, {, }) 및 시퀀스(f_quote)를 나타내기 위해 부정형 미리보기 (!)를 사용합니다.
fstring:FSTRING_STARTfstring_middle*FSTRING_ENDFSTRING_START:fstringprefix("'" | '"' | "'''" | '"""') FSTRING_END:f_quotefstringprefix: <("f" | "fr" | "rf"), case-insensitive> f_debug_specifier: '=' f_quote: <the quote character(s) used in FSTRING_START> fstring_middle: |fstring_replacement_field|FSTRING_MIDDLEFSTRING_MIDDLE: | (!"\" !newline!'{' !'}' !f_quote)source_character|stringescapeseq| "{{" | "}}" | <newline, in triple-quoted f-strings only> fstring_replacement_field: | '{'f_expression[f_debug_specifier] [fstring_conversion] [fstring_full_format_spec] '}' fstring_conversion: | "!" ("s" | "r" | "a") fstring_full_format_spec: | ':'fstring_format_spec* fstring_format_spec: |FSTRING_MIDDLE|fstring_replacement_fieldf_expression: | ','.(conditional_expression| "*"or_expr)+ [","] |yield_expression
참고
위의 문법 스니펫에서 f_quote 및 FSTRING_MIDDLE 규칙은 문맥 의존적입니다. 즉, 이들은 가장 가까운 외부 fstring``의 ``FSTRING_START 내용에 따라 달라집니다.
이 템플릿을 바탕으로 더 전통적인 공식 문법을 구축하는 것은 독자의 과제로 남겨둡니다.
t-문자열을 위한 문법은 f-문자령를 위한 문법과 동일하며, 규칙 및 토큰 이름의 시작 부분과 접두어에 f 대신 t 가 사용됩니다.
tstring: TSTRING_START tstring_middle* TSTRING_END <rest of the t-string grammar is omitted; see above>
2.6. 숫자 리터럴¶
NUMBER 토큰은 숫자 리터럴을 나타내며, 여기에는 정수, 부동 소수점 수, 허수라는 세 가지 유형이 있습니다.
NUMBER:integer|floatnumber|imagnumber
숫자 리터럴의 숫자 값은 각각 int, float, 또는 complex 클래스 생성자에 문자열로 전달되었을 때와 동일합니다. 모든 유효한 생성자 입력이 유효한 리터럴인 것은 아니라는 점에 주의하십시오.
숫자 리터럴에는 부호가 포함되지 않습니다. 예를 들어, -1 이라는 구문은 실제로 단항 연산자 - 와 리터럴 1 로 구성된 표현식입니다.
2.6.1. 정수 리터럴¶
정수 리터럴은 정수를 나타냅니다. 예를 들면:
7
3
2147483647
사용 가능한 메모리에 저장할 수 있는 용량을 제외하고, 정수 리터럴의 길이에 제한은 없습니다:
7922816251426433759354395033679228162514264337593543950336
밑줄은 가독성을 높이기 위해 숫자를 그룹화하는 데 사용할 수 있으며, 리터럴의 숫자 값을 결정할 때는 무시됩니다. 예를 들어, 다음 리터럴들은 서로 동일합니다:
100_000_000_000
100000000000
1_00_00_00_00_000
밑줄은 숫자 사이에서만 올 수 있습니다. 예를 들어, _123, 321_, 그리고 123__321 은 유효한 리터럴이 아닙니다.
정수는 각각 0b, 0o, 0x 접두사를 사용하여 이진법(2진법), 팔진법(8진법), 또는 16진법으로 지정할 수 있습니다. 16진수 10에서 15까지의 숫자는 대소문자 구분 없이 A`~`F 문자로 표현됩니다. 예를 들면:
0b100110111
0b_1110_0101
0o177
0o377
0xdeadbeef
0xDead_Beef
밑줄은 진수 지정자(base specifier) 뒤에 올 수 있습니다. 예를 들어, 0x_1f 는 유력한 리터럴이지만, 0_x1f 와 0x__1f 는 아닙니다.
0이 아닌 10진수에서 앞부분에 0을 붙이는 것은 허용되지 않습니다. 예를 들어, 0123 은 유효한 리터럴이 아닙니다. 이는 파이썬 3.0 이전 버전에서 사용되던 C 스타일의 팔진수 리터럴과 구분하기 위한 것입니다.
공식적으로 정수 리터럴은 다음 어휘 정의에 의해 설명됩니다:
integer:decinteger|bininteger|octinteger|hexinteger|zerointegerdecinteger:nonzerodigit(["_"]digit)* bininteger: "0" ("b" | "B") (["_"]bindigit)+ octinteger: "0" ("o" | "O") (["_"]octdigit)+ hexinteger: "0" ("x" | "X") (["_"]hexdigit)+ zerointeger: "0"+ (["_"] "0")* nonzerodigit: "1"..."9" digit: "0"..."9" bindigit: "0" | "1" octdigit: "0"..."7" hexdigit:digit| "a"..."f" | "A"..."F"
버전 3.6에서 변경: 리터럴에서 숫자들의 그룹을 표현할 목적으로 밑줄을 허락합니다.
2.6.2. 실수 리터럴¶
3.14 또는 1.5 와 같은 부동 소수점(float) 리터럴은 실수의 근사치 를 나타냅니다.
이들은 각각 10진수 숫자로 구성된 정수 부분과 소수 부분으로 구성됩니다. 각 부분은 소수점(.)으로 구분됩니다:
2.71828
4.0
정수 리터럴과 달리 부동 소수점 리터럴에서는 앞에 0을 붙이는 것이 허용됩니다. 예를 들어, 077.010 은 유효하며 77.01 과 동일한 숫자를 나타냅니다.
정수 리터럴에서와 마찬가지로, 가독성을 돕기 위해 숫자 사이에 단일 밑줄을 사용할 수 있습니다:
96_485.332_123
3.14_15_93
이 두 부분 중 하나는 비어 있을 수 있지만 둘 다 비어 있을 수는 없습니다. 예를 들면:
10. # (10.0과 동일)
.001 # (0.001과 동일)
선택적으로 정수 및 소수 부분 뒤에 지수(exponent) 가 올 수 있습니다. 이는 문자 e 또는 E, 그 뒤에 오는 선택적인 부호인 + 또는 -, 그리고 정수/소수부와 동일한 형식을 갖는 숫자로 구성됩니다. e 또는 E 는 “10의 거듭제곱을 곱함”을 나타냅니다:
1.0e3 # (1.0×10³ 또는 1000.0을 의미)
1.166e-5 # (1.166×10⁻⁵ 또는 0.00001166을 의미)
6.02214076e+23 # (6.02214076×10²³ 또는 602214076000000000000000.0을 의미)
정수와 지수 부분만 있는 부동 소수점 수에서는 소수점을 생략할 수 있습니다:
1e3 # (1.e3 및 1.0e3와 동일)
0e0 # (0.과 동일)
공식적으로 부동 소수점 리터럴은 다음 어휘 정의에 의해 설명됩니다:
floatnumber: |digitpart"." [digitpart] [exponent] | "."digitpart[exponent] |digitpartexponentdigitpart:digit(["_"]digit)* exponent: ("e" | "E") ["+" | "-"]digitpart
버전 3.6에서 변경: 리터럴에서 숫자들의 그룹을 표현할 목적으로 밑줄을 허락합니다.
2.6.3. 허수 리터럴¶
파이썬은 복소수 객체를 지원하지만 복소수 리터럴은 없습니다. 대신, 허수 리터럴 이 실수 부분이 0인 복소수를 나타냅니다.
예를 들어, 수학에서 복소수 3+4.2i 는 실수 3에 허수 4.2i 를 더한 것으로 표기됩니다. 파이썬도 이와 유사한 구문을 사용하지만, 허수 단위를 i 대신 j 로 표기합니다:
3+4.2j
이것은 정수 리터럴 인 3, 연산자 인 +, 그리고 허수 리터럴 인 4.2j 로 구성된 표현식입니다. 이들은 세 개의 별개 토큰이므로 그 사이에 공백을 허용합니다:
3 + 4.2j
각 토큰 내부에는 공백이 허용되지 않습니다. 특히 j 접미사는 앞에 오는 숫자와 분리될 수 없습니다.
j 앞의 숫자는 부동 소수점 리터럴과 동일한 구법을 따릅니다. 따라서 다음은 유효한 허수 리터럴입니다:
4.2j
3.14j
10.j
.001j
1e100j
3.14e-10j
3.14_15_93j
부동 소수점 리터럴과 달리, 허수 리터럴이 정수 부분만 갖는 경우 소수점을 생략할 수 있습니다. 이때 숫자는 여전히 정수가 아닌 부동 소수점 수로 평가됩니다:
10j
0j
1000000000000000000000000j # (1e+24j와 동일)
j 접미사는 대소문자를 구분하지 않습니다. 즉, 대신 J 를 사용할 수 있습니다:
3.14J # (3.14j와 동일)
공식적으로 허수 리터럴은 다음 어휘 정의에 의해 설명됩니다:
imagnumber: (floatnumber|digitpart) ("j" | "J")
2.7. 연산자와 구분자¶
The following grammar defines operator and delimiter tokens,
that is, the generic OP token type.
A list of these tokens and their names
is also available in the token module documentation.
OP: | assignment_operator | bitwise_operator | comparison_operator | enclosing_delimiter | other_delimiter | arithmetic_operator | "..." | other_op assignment_operator: "+=" | "-=" | "*=" | "**=" | "/=" | "//=" | "%=" | "&=" | "|=" | "^=" | "<<=" | ">>=" | "@=" | ":=" bitwise_operator: "&" | "|" | "^" | "~" | "<<" | ">>" comparison_operator: "<=" | ">=" | "<" | ">" | "==" | "!=" enclosing_delimiter: "(" | ")" | "[" | "]" | "{" | "}" other_delimiter: "," | ":" | "!" | ";" | "=" | "->" arithmetic_operator: "+" | "-" | "**" | "*" | "//" | "/" | "%" other_op: "." | "@"
참고
일반적으로 연산자 는 표현식 을 결합하는 데 사용되고, 구분자 는 다른 목적을 수행합니다. 그러나 두 범주 사이에는 명확하고 공식적인 구분은 없습니다.
일부 토큰은 사용법에 따라 연산자나 구분자 역할을 할 수 있습니다. 예를 들어, * 는 곱셈 연산자인 동시에 시퀀스 언패킹을 위한 구분자이며, @ 는 행렬 곱셈인 동시에 데코레이터를 도입하는 구분자입니다.
일부 토큰의 경우 구분이 불분명합니다. 예를 들어, 어떤 사람들은 ., (, ) 를 구분자로 간주하는 반면, 다른 이들은 이를 getattr() 연산자 및 함수 호출 연산자로 봅니다.
파이썬의 일부 연산자(예를 들어 and, or, not in)는 “심볼(symbol)”(연산자 토큰) 대신 키워드 토큰을 사용합니다.
세 개의 연속된 마침표(...)는 Ellipsis 리터럴로서 특별한 의미를 가집니다.
2.1.3. 주석¶
주석은 문자열 리터럴에 포함되지 않는 해시 문자(
#)로 시작하고 물리적인 줄의 끝에서 끝납니다. 묵시적인 줄 결합 규칙이 유효하지 않은 이상, 주석은 논리적인 줄을 종료시킵니다. 주석은 문법이 무시합니다.