2. 어휘 분석¶
Python 프로그램은 parser 에 의해 읽힙니다. 파서의 입력은 lexical analyzer (또는 tokenizer 로 알려진) 에 의해 생성된 토큰 스트림입니다. 이 장에서는 lexical analyzer가 이러한 토큰들을 생성하는 방법을 설명합니다.
렉시컬 분석기는 프로그램 텍스트의 인코딩 (기본값은 UTF-8)을 결정하고, 텍스트를 :ref:`소스 문자 <lexical-source-character>`로 디코드합니다. 텍스트를 디코드할 수 없는 경우, :exc:`SyntaxError`가 발생합니다.
다음으로, 구문 분석기(lexical analyzer)는 원본 문자를 사용하여 토큰 스트림을 생성합니다. 생성된 토큰의 유형은 일반적으로 처리될 다음 원본 문자에 따라 결정됩니다. 유사하게, 분석기의 다른 특수 동작은 아직 처리되지 않은 첫 번째 원본 문자에 의존합니다. 다음 표는 이러한 원본 문자들에 대한 간략한 요약을 제공하며, 더 많은 정보가 포함된 섹션으로 연결되는 링크를 제공합니다.
문자 |
다음 토큰 (또는 기타 관련 문서) |
|---|---|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2.1. 줄 구조(Line structure)¶
파이썬 프로그램은 여러 개의 논리적인 줄(logical lines) 들로 나뉩니다.
2.1.1. 논리적인 줄¶
논리적 줄의 끝은 토큰 구문 문장들은 :data:!NEWLINE`이 구문에 의해 허용되는 곳을 제외하고는 논리적 줄 경계를 넘을 수 없습니다 (예: 복합 문장의 문장 사이). 논리적 줄은 다음 규칙에 따라 하나 이상의 물리적 줄*로 구성됩니다: :ref:`explicit <explicit-joining>` 또는 :ref:`implicit <implicit-joining>` *줄 결합.
2.1.2. 물리적인 줄¶
물리적인 줄은 다음 줄 끝 시퀀스 중 하나로 종료되는 문자들의 순서입니다:
ASCII LF (개행문자)를 사용하는 유닉스 형식,
ASCII 시퀀스를 사용하는 윈도우 형식 CR LF(캐리지 리턴 다음에 오는 개행 문자),
ASCII CR(캐리지 리턴) 문자를 사용하는 ‘Classic Mac OS’ 형식입니다.
플랫폼에 관계없이, 이 시퀀스들은 모두 단일 ASCII LF (개행 문자)로 대체됩니다(이는 string literals 내부에서도 수행됩니다.). 각 줄은 어떤 시퀀스를 사용해도 되며; 파일 내에서 일관적일 필요는 없습니다.
입력의 끝 역시 마지막 물리적인 줄에 대한 암시적 종료자 역할을 합니다.
형식적으로는 다음과 같습니다:
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 제어 문자를 제외한 모든 유니코드 코드 포인트가 Python 소스에서 나타날 수 있습니다.
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이 하나 푸시되며, 이 값은 다시는 pop되지 않습니다. 스택에 푸시되는 숫자는 항상 바닥에서 위로 갈수록 엄격하게 증가합니다. 각 논리적 라인의 시작 시, 해당 라인의 들여쓰기 수준이 스택의 최상단과 비교됩니다. 같으면 아무 일도 일어나지 않습니다. 더 크면, 스택에 푸시되고 INDENT 토큰 하나가 생성됩니다. 더 작으면, 반드시 스택에 존재하는 숫자 중 하나여야 하며; 스택에서 더 큰 모든 숫자는 pop되며, 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), 탭 및 개행문자(formfeed)를 간간이 사용하여 토큰을 분리할 수 있습니다:
whitespace: ' ' | tab | formfeed
공백은 두 개의 토큰 사이에만 필요합니다. 그렇지 않으면 연결되었을 때 다른 토큰으로 해석될 수 있기 때문입니다. 예를 들어, ab 는 하나의 토큰이지만 a b 는 두 개의 토큰입니다. 하지만, +a 와 + a 모두 + 와 a 의 두 토큰을 생성합니다. 왜냐하면 +a 는 유효하지 않은 토큰이기 때문입니다.
2.1.10. 종료 마커¶
비대화형 입력의 끝에서, 어휘 분석기는 ENDMARKER 토큰을 생성합니다.
2.2. 다른 토큰들¶
NEWLINE, INDENT 및 DEDENT 외에, 다음과 같은 카테고리의 토큰이 존재합니다: 식별자(identifiers)*와 *키워드 (NAME), 리터럴*(예: :data:`~token.NUMBER` 및 :data:`~token.STRING`과 같은 것), 그리고 다른 기호(*연산자 및 구분자, OP). 공백 문자(논리적 라인 종결자는 앞서 논의된 것 제외)는 토큰이 아니며, 토큰을 구분하는 역할을 합니다. 모호성이 존재하는 경우, 토큰은 왼쪽에서 오른쪽으로 읽었을 때 유효한 토큰을 형성하는 가장 긴 가능한 문자열로 구성됩니다.
2.3. 이름 (식별자 및 키워드)¶
NAME 토큰은 식별자, 키워드 및 소프트 키워드 를 나타냅니다.
이름은 다음 문자들로 구성됩니다:
대문자와 소문자 문자(
A-Z및a-z),밑줄(underscore) (
_),숫자(digit) (
0부터9까지)로, 첫 문자로 사용될 수 없고,비 ASCII 문자. 유효한 이름은 “문자 형태(letter-like)” 및 “숫자 형태(digit-like)” 문자만을 포함할 수 있습니다. 자세한 내용은 :ref:`lexical-names-nonascii`를 참조하십시오.
이름은 최소 한 개의 문자를 포함해야 하지만, 최대 길이는 없습니다. 대소문자가 구별됩니다.
형식적으로 이름은 다음 어휘 정의로 기술됩니다:
NAME:name_startname_continue* name_start: "a"..."z" | "A"..."Z" | "_" | <non-ASCII character> name_continue: name_start | "0"..."9" identifier: <NAME, except keywords>
참고하건대, 이 문법에 의해 일치하는 모든 이름이 유효한 것은 아닙니다. 자세한 내용은 :ref:`lexical-names-nonascii`를 참조하십시오.
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.
일부 이름은 특정 컨텍스트에서만 예약어입니다. 이것들은 소프트 키워드 라고 알려져 있습니다:
:keyword:`type``은 :keyword:`type 문에서 사용될 때 해당됩니다.
:keyword:`lazy``는 `:keyword:`import 문 앞에 사용될 때 해당됩니다.
이들은 구문상으로 특정 컨텍스트에서 키워드 역할을 하지만, 이러한 구분은 토큰화 시가 아니라 파서 수준에서 이루어집니다.
소프트 키워드로 사용되므로, 이들은 식별자 이름으로 이 이름을 사용하는 기존 코드와의 호환성을 유지하면서 문법 내에서 사용할 수 있습니다.
버전 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ⁿ<0xE2><0x82><0x90>ˡᵢ<0xE1><0xB6><0xBB><0xE2><0x82><0x90>ᵗᵢᵒ<0xE2><0x82><0x99> 은 finalization 으로 정규화되므로 파이썬은 이를 동일한 이름으로 취급합니다:
>>> fiⁿₐˡᵢᶻₐᵗᵢᵒₙ = 3
>>> finalization
3
참고
정규화는 어휘적 레벨에서만 수행됩니다. 이름을 문자열 로 받는 런타임 함수들은 일반적으로 인수를 정규화하지 않습니다. 예를 들어, 위에서 정의된 변수는 globals() 딕셔너리에서 globals()["finalization"] 으로 런타임에 접근 가능하지만, globals()["fiⁿ<0xE2><0x82><0x90>ˡᵢ<0xE1><0xB6><0xBB><0xE2><0x82><0x90>ᵗᵢᵒ<0xE2><0x82><0x99>"] 으로는 접근할 수 없습니다.
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``는 NFKC 정규화에 의해 이 세트를 닫으며, ``id_start id_continue* 형태의 정규화가 아닌 모든 문자를 제거합니다.
집합 id_continue 는 다음 요소들의 합으로 정의됩니다:
id_start(위 참조)유니코드 범주
<Nd>- 십진수 숫자 (0``부터 ``9포함)유니코드 범주
<Pc>- 연결 구두점유니코드 범주
<Mn>- 공백 없음 마크유니코드 범주
<Mc>- 간격 결합 마크<Other_ID_Continue>- 하위 호환성을 지원하기 위한 PropList.txt 의 또 다른 명시적인 문자 집합
마찬가지로, xid_continue 는 NFKC 정규화에 의해 이 세트를 닫습니다.
유니코드 범주들은 unicodedata 모듈에 포함된 유니코드 캐릭터 데이터베이스 버전을 사용합니다.
2.4. 리터럴¶
리터럴(literal)은 몇몇 내장형들의 상숫값을 위한 표기법입니다.
In terms of lexical analysis, Python has string, bytes and numeric literals.
Other “literals” are lexically denoted using keywords
(None, True, False) and the special
ellipsis token (...).
2.5. 문자열과 바이트열 리터럴¶
문자열 리터럴은 한 개의 작은따옴표(')나 큰따옴표(")로 묶인 텍스트입니다. 예를 들면:
"spam"
'eggs'
리터럴을 시작하는 따옴표는 또한 그것을 종료하므로, 문자열 리터럴은 다른 따옴표만 포함할 수 있습니다 (이스케이프 시퀀스의 경우는 제외하고 아래 참조). 예를 들면:
'Say "Hello", please.'
"Don't do that!"
이러한 제한사항을 제외하면, 따옴표 문자의 선택(' 또는 ")은 리터럴이 파싱되는 방식에 영향을 주지 않습니다.
문자열 리터럴 내부에서 역 슬래시(\) 문자는 이스케이프 시퀀스 를 도입하며, 이는 역 슬래시 뒤의 문자에 따라 특별한 의미를 가집니다. 예를 들어, \" 는 큰따옴표 문자를 나타내며 문자열을 종료하지 않습니다:
>>> print("Say \"Hello\" to everyone!")
Say "Hello" to everyone!
전체 목록 및 더 자세한 내용은 아래의 :ref:`이스케이프 시퀀스 <escape-sequences>`를 참조하세요.
2.5.1. 삼중 따옴표 문자열¶
문자열은 또한 한 쌍의 세 개의 작은따옴표나 큰따옴표로 묶일 수 있습니다. 이를 일반적으로 :dfn:`triple-quoted strings`<span class=”text”> (삼중 따옴표 된 문자열)</span>이라고 부릅니다:
"""이것은 삼중따옴표로 묶인 문자열입니다."""
삼중 인용 부호 내에서는 이스케이프되지 않은 따옴표가 허용되며 (그대로 유지되지만), 동일한 종류의 따옴표(' 또는 ")가 연달아 세 번 나타나면 리터럴이 종료됩니다. 단, 시작 시 사용된 경우에 한합니다.
"""이 문자열 안에는 "따옴표"가 들어있습니다."""
개행된 줄 바꿈도 허용되며 유지됩니다:
'''This triple-quoted string
continues on the next line.'''
2.5.2. 문자열 접두사¶
문자열 리터럴은 선택적인 :dfn:`prefix`를 가질 수 있으며, 이것이 리터럴의 내용이 구문 분석되는 방식에 영향을 줍니다. 예를 들면:
b"data"
f'{result=}'
허용된 접두사는 다음과 같습니다:
r: Raw stringf: Formatted string literal (“f-string”)t: Template string literal (“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. 형식화 문법(Formal grammar)¶
“f-strings” <f-strings>`와 :ref:”t-strings” <t-strings>`를 제외한 문자열 리터럴은 다음의 어휘적 정의에 의해 설명됩니다.
이러한 정의들은 negative lookaheads (!)를 사용하여 끝나는 따옴표가 리터럴을 종료함을 나타냅니다.
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. 줄 끝에서 무시됨 (Ignored end of line)¶
백슬래시는 줄의 맨 끝에 추가되어 개행(newline)을 무시할 수 있습니다:
>>> 'This string will not include \
... backslashes or newline characters.'
'This string will not include backslashes or newline characters.'
동일한 결과는 :ref:`triple-quoted strings <strings>`를 사용하거나, 괄호와 :ref:`string literal concatenation <string-concatenation>`을 사용하여 얻을 수 있습니다.
2.5.4.2. 이스케이프된 문자¶
널 raw Python 문자열 리터럴에 백슬래시를 포함하려면, 두 번 사용해야 합니다. \\ 이스케이프 시퀀스는 단일 역 슬래시 문자를 나타냅니다:
>>> print('C:\\Program Files')
C:\Program Files
마찬가지로, \' 및 \" 시퀀스는 각각 작은따옴표와 큰따옴표 문자를 나타냅니다:
>>> print('\' and \"')
' and "
2.5.4.3. 8진수 문자¶
시퀀스 \ooo 는 8진수(기수 8) 값이 ooo 인 문자 를 나타냅니다:
>>> '\120'
'P'
최대 세 자리의 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. 이름 지정 유니코드 문자¶
시퀀스 :samp:`\N\{{name}\}`는 주어진 name 값을 가진 유니코드 문자를 나타냅니다:
>>> '\N{LATIN CAPITAL LETTER P}'
'P'
>>> '\N{SNAKE}'
'🐍'
이 시퀀스는 :ref:`bytes literals <bytes-literal>`에서 나타날 수 없습니다.
버전 3.3에서 변경: name aliases 지원이 추가되었습니다.
2.5.4.6. 16진수 유니코드 문자¶
이러한 시퀀스 \uxxxx 및 \Uxxxxxxxx 는 주어진 16진수(기수 16) 값을 가진 유니코드 문자를 나타냅니다. \u 의 경우 정확히 네 자리, \U 의 경우 정확히 여덟 자리가 필요합니다. 후자는 모든 유니코드 문자를 인코딩할 수 있습니다.
>>> '\u1234'
'ሴ'
>>> '\U0001f40d'
'🐍'
이러한 시퀀스는 :ref:`bytes literals <bytes-literal>`에서 나타날 수 없습니다.
2.5.4.7. 인식되지 않는 이스케이프 시퀀스¶
Standard C와는 달리, 모든 인식되지 않은 이스케이프 시퀀스는 문자열에서 변경되지 않고 그대로 유지됩니다. 즉, 역 슬래시가 결과에 남습니다:
>>> print('\q')
\q
>>> list('\q')
['\\', 'q']
바이트열 리터럴의 경우, 문자열 리터럴에서만 인식되는 이스케이프 시퀀스 (\N..., \u..., \U...)는 인식되지 않는 이스케이프의 범주에 속한다는 점에 유의하십시오.
버전 3.6에서 변경: 인식되지 않는 이스케이프 시퀀스는 :exc:`DeprecationWarning`을 발생시킵니다.
버전 3.12에서 변경: 유효하지 않은 이스케이프 시퀀스는 SyntaxWarning 을 생성합니다. 향후 파이썬 버전에서는 SyntaxError 를 발생시킬 것입니다.
2.5.5. 바이트열 리터럴¶
바이트열 리터럴`는 항상 ‘``b`’ 또는 ‘B’로 접두사가 붙으며, bytes 타입의 인스턴스를 생성합니다. str 타입을 대신 사용합니다. 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]
마찬가지로, 널 바이트는 이스케이프 시퀀스(일반적으로 \0 또는 \x00)를 사용하여 표현해야 합니다.
2.5.6. 날 문자열 리터럴¶
문자열 및 바이트열 리터럴은 선택적으로 ‘r’ 또는 ‘R’ 접두사가 붙을 수 있습니다. 이러한 구조는 각각 날 문자열 리터럴`과 :dfn:`날 바이트열 리터럴`이라고 불리며, 백슬래시를 문자로 취급합니다. 결과적으로, 날 문자열 리터럴에서는 :ref:`이스케이프 시퀀스 <escape-sequences> 가 특별하게 처리되지 않습니다:
>>> 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-string 내부의 표현식에 대한 많은 제한 사항이 제거되었습니다. 주목할 만한 점은 중첩 문자열, 주석 및 백슬래시가 이제 허용된다는 것입니다.
포맷 문자열 리터럴 또는 f-string 은 ‘f ‘ 또는 ‘F ‘로 접두사가 붙는 문자열 리터럴입니다. 다른 문자열 리터럴과 달리, f-strings는 상수 값을 가지지 않습니다. 이들은 중괄호 {} 로 구분된 치환 필드 를 포함할 수 있습니다. 치환 필드는 런타임에 평가되는 표현식들을 담고 있습니다. 예를 들면:
>>> who = 'nobody'
>>> nationality = 'Spanish'
>>> f'{who.title()} expects the {nationality} Inquisition!'
'Nobody expects the Spanish Inquisition!'
치환 필드 밖에 있는 모든 이중 중괄호({{ 또는 }})는 해당 단일 중괄호로 대체됩니다:
>>> print(f'{{...}}')
{...}
치환 필드 밖에 있는 다른 문자들은 일반 문자열 리터럴과 유사하게 처리됩니다. 이는 이스케이프 시퀀스가 디코드됨을 의미합니다 (리터럴이 날 문자열로 표시된 경우 제외) 그리고 삼중 따옴표를 사용한 f-strings에서 줄 바꿈이 가능함을 의미합니다:
>>> 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-string 따옴표 유형을 다시 사용하는 것이 허용됩니다:
>>> 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-string을 중첩하는 것이 가능합니다:
>>> name = 'world'
>>> f'Repeated:{f' hello {name}' * 3}'
'Repeated: hello world hello world hello world'
이식 가능한 파이썬 프로그램은 5단계 이상의 중첩을 사용해서는 안 됩니다.
CPython에서는 f-string의 중첩에 제한을 두지 않습니다.
치환 표현식은 단일 따옴표 및 삼중 따옴표로 둘러싸인 f-strings 모두에서 개행문자를 포함할 수 있으며 주석도 포함할 수 있습니다. 치환 필드 내에서 # 다음에 오는 모든 내용은 주석으로 처리됩니다 (닫는 중괄호와 따옴표조차도 그렇습니다). 따라서 주석이 있는 치환 필드는 반드시 다른 줄에서 닫혀야 합니다:
>>> a = 2
>>> f"abc{a # This comment }" continues until the end of the line
... + 3}"
'abc5'
표현식 뒤에는, 치환 필드가 선택적으로 다음을 포함할 수 있습니다:
디버그 지정자 – 등호(=), 공백으로 한쪽 또는 양쪽에 선택적으로 둘러싸일 수 있음;
변환 지정자 —
!s,!r또는!a; 및/또는콜론(
:)으로 접두가 붙은 포맷 지정자.
이러한 필드가 평가되는 방법에 대한 자세한 내용은 표준 라이브러리 의 f-string 섹션`을 참조하십시오.
해당 섹션에서 설명하듯이, 포맷 지정자 는 치환 필드의 값을 포매팅하기 위해 format() 함수의 두 번째 인수로 전달됩니다. 예를 들어, 이를 사용하여 필드 너비 및 패딩 문자를 지정할 수 있습니다: Format Specification Mini-Language:
>>> number = 14.3
>>> f'{number:20.7f}'
' 14.3000000'
최상위 포맷 지정자는 중첩된 치환 필드를 포함할 수 있습니다:
>>> field_size = 20
>>> precision = 7
>>> f'{number:{field_size}.{precision}f}'
' 14.3000000'
이러한 중첩된 필드는 자신만의 변환 필드와 :ref:`포맷 지정자 <formatspec>`를 포함할 수 있습니다:
>>> number = 3
>>> f'{number:{field_size}}'
' 3'
>>> f'{number:{field_size:05}}'
'00000000000000000003'
하지만, 이러한 중첩된 필드는 더 깊이 중첩된 치환 필드를 포함할 수는 없습니다.
포맷 문자열 리터럴은 표현식을 포함하지 않아도 :term:`독스트링 <docstring>`으로 사용될 수 없습니다.
>>> 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.
A template string literal or t-string is a string literal
that is prefixed with ‘t’ or ‘T’.
These strings follow the same syntax rules as
formatted string literals.
For differences in evaluation rules, see the
Standard Library section on t-strings
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-문자열 문법은 <notation-lexical-vs-syntactic> 어휘 및 구문 정의의 혼합물`입니다.
이러한 상황에서는 공백이 중요합니다:
`:py:data:`~token.FSTRING_START``에는 공백이 없을 수도 있습니다 (접두사와 따옴표 사이의 공백).
fstring\_replacement\_field에서는f_debug_specifier가 존재하는 경우, 여는 중괄호 뒤부터f_debug_specifier까지의 모든 공백뿐만 아니라f_debug_specifier바로 뒤따르는 공백도 표현식의 일부로 유지됩니다.표현식은 토큰화 단계에서 처리되지 않으며,
{토큰과=`뒤의 토큰 위치를 사용하여 소스 코드로부터 검색됩니다.
FSTRING_\_MIDDLE 정의는 특수 문자(백슬래시, 개행 문자, {, }) 및 시퀀스(f_quote)를 나타내기 위해 <lexical-lookaheads> 음성 탐색` (!)을 사용합니다.
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 대신 `t`를 사용한다는 점을 제외하고는 f-문자열과 동일합니다.
tstring: TSTRING_START tstring_middle* TSTRING_END <rest of the t-string grammar is omitted; see above>
2.6. 숫자 리터럴¶
NUMBER tokens represent numeric literals, of which there are
three types: integers, floating-point numbers, and imaginary numbers.
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 (2진수), 0o (8진수) 또는 0x (16진수)를 사용하여 지정할 수 있습니다. 16진수 숫자 10부터 15까지는 대소문자를 구분하지 않는 문자 A-F 로 표현됩니다. 예를 들면:
0b100110111
0b_1110_0101
0o177
0o377
0xdeadbeef
0xDead_Beef
밑줄은 진수 지정자 뒤에 올 수 있습니다. 예를 들어, 0x__\_1f 는 유효한 리터럴이지만, 0_\_x1f 와 0x__\_\_1f 는 그렇지 않습니다.
0이 아닌 십진수의 선행 0은 허용되지 않습니다. 예를 들어, 0123 은 유효한 리터럴이 아닙니다. 이는 파이썬이 3.0 버전 이전에 사용하던 C 스타일의 8진수 리터럴과의 모호성을 해결하기 위함입니다.
형식적으로 정수 리터럴은 다음 어휘 정의에 의해 설명됩니다:
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. 실수 리터럴¶
실수(float) 리터럴, 예를 들어 3.14 또는 1.5 는 실수들의 근사치 를 나타냅니다.
이들은 정수 부분과 분수 부분으로 구성되며, 각 부분은 십진 숫자로 이루어져 있습니다. 이 부분들은 소수점 . 으로 구분됩니다:
2.71828
4.0
정수 리터럴과는 달리 선행 0이 허용됩니다. 예를 들어, 077.010 는 유효하며, 77.01 과 같은 숫자를 나타냅니다.
정수 리터럴에서와 마찬가지로, 이해를 돕기 위해 숫자 사이에 밑줄이 올 수 있습니다:
96_485.332_123
3.14_15_93
이 두 부분 중 어느 하나는 비어 있을 수 있으며, 둘 다 비어 있을 수는 없습니다. 예를 들면:
10. # (10.0과 동일)
.001 # (0.001과 동일)
선택적으로, 정수 부분과 분수 부분이 지수 로 이어질 수 있습니다: 문자 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.을 나타냄)
정수 부분과 지수 부분만 있는 float의 경우 소수점을 생략할 수 있습니다:
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 은 “심볼”(연산자 토큰) 대신 키워드 토큰을 사용합니다.
세 개의 연속된 점(...) 시퀀스는 특수한 의미를 가지며 Ellipsis 리터럴로 간주됩니다.
2.1.3. 주석¶
주석은 문자열 리터럴에 포함되지 않는 해시 문자(
#)로 시작하고 물리적인 줄의 끝에서 끝납니다. 묵시적인 줄 결합 규칙이 유효하지 않은 이상, 주석은 논리적인 줄을 종료시킵니다. 주석은 문법이 무시합니다.