2. 구문 분석
************

파이썬 프로그램은 *파서(parser)* 에 의해 읽힌다. 파서의 입력은 *구문
분석기(lexical analyzer)* 가 만들어내는 *토큰(token)* 들의 스트림이다.
이 장에서는 구문 분석기가 어떻게 파일을 토큰들로 분해하는지 설명한다.

Python uses the 7-bit ASCII character set for program text.

버전 2.3에 추가: An encoding declaration can be used to indicate that
string literals and comments use an encoding different from ASCII.

For compatibility with older versions, Python only warns if it finds
8-bit characters; those warnings should be corrected by either
declaring an explicit encoding, or using escape sequences if those
bytes are binary data, instead of characters.

The run-time character set depends on the I/O devices connected to the
program but is generally a superset of ASCII.

**Future compatibility note:** It may be tempting to assume that the
character set for 8-bit characters is ISO Latin-1 (an ASCII superset
that covers most western languages that use the Latin alphabet), but
it is possible that in the future Unicode text editors will become
common.  These generally use the UTF-8 encoding, which is also an
ASCII superset, but with very different use for the characters with
ordinals 128-255.  While there is no consensus on this subject yet, it
is unwise to assume either Latin-1 or UTF-8, even though the current
implementation appears to favor Latin-1.  This applies both to the
source character set and the run-time character set.


2.1. 줄 구조(Line structure)
============================

파이썬 프로그램은 여러 개의 *논리적인 줄(logical lines)* 들로 나뉜다.


2.1.1. 논리적인 줄
------------------

논리적인 줄의 끝은 NEWLINE 토큰으로 표현된다. 문법이 허락하지 않는 이
상 (예를 들어 복합문에서 문장들 사이) 문장은 논리적인 줄 간의 경계를
가로지를 수 없다. 논리적인 줄은 명시적이거나 묵시적인 *줄 결합(line
joining)* 규칙에 따라 하나 이상의 *물리적인 줄(physical lines)* 들로
구성된다.


2.1.2. 물리적인 줄
------------------

A physical line is a sequence of characters terminated by an end-of-
line sequence.  In source files and strings, any of the standard
platform line termination sequences can be used - the Unix form using
ASCII LF (linefeed), the Windows form using the ASCII sequence CR LF
(return followed by linefeed), or the old Macintosh form using the
ASCII CR (return) character.  All of these forms can be used equally,
regardless of platform. The end of input also serves as an implicit
terminator for the final physical line.

파이썬을 내장할 때는, 소스 코드 문자열은 반드시 줄 종료 문자에 표준 C
관행(ASCII LF를 표현하는 "\n" 문자로 줄이 종료된다)을 적용해서 파이썬
API로 전달되어야 한다.


2.1.3. 주석
-----------

주석은 문자열 리터럴에 포함되지 않는 해시 문자("#")로 시작하고 물리적
인 줄의 끝에서 끝난다. 묵시적인 줄 결합 규칙이 유효하지 않은 이상, 주
석은 논리적인 줄을 종료시킨다. 주석은 문법이 무시한다; 토큰으로 만들어
지지 않는다.


2.1.4. 인코딩 선언
------------------

파이썬 스크립트의 첫 번 째나 두 번째 줄에 있는 주석이 정규식
"coding[=:]\s*([-\w.]+)" 과 매치되면, 이 주석은 인코딩 선언으로 처리된
다. 이 정규식의 첫 번째 그룹은 소스 코드 파일의 인코딩 이름을 지정한다
. 인코딩 선언은 줄 전체에 홀로 나와야 한다. 만약 두 번째 줄이라면, 첫
번째 줄 역시 주석만 있어야 한다. 인코딩 선언의 권장 형태는 두 개다. 하
나는

   # -*- coding: <encoding-name> -*-

인데 GNU Emacs에서도 인식된다. 다른 하나는

   # vim:fileencoding=<encoding-name>

which is recognized by Bram Moolenaar's VIM. In addition, if the first
bytes of the file are the UTF-8 byte-order mark ("'\xef\xbb\xbf'"),
the declared file encoding is UTF-8 (this is supported, among others,
by Microsoft's **notepad**).

If an encoding is declared, the encoding name must be recognized by
Python. The encoding is used for all lexical analysis, in particular
to find the end of a string, and to interpret the contents of Unicode
literals. String literals are converted to Unicode for syntactical
analysis, then converted back to their original encoding before
interpretation starts.


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:   # Looks like a valid date
           return 1

역 슬래시로 끝나는 줄은 주석이 포함될 수 없다. 역 슬래시는 주석을 결합
하지 못한다. 역 슬래시는 문자열 리터럴을 제외한 어떤 토큰도 결합하지
못한다 (즉, 문자열 리터럴 이외의 어떤 토큰도 역 슬래시를 사용해서 두
줄에 나누어 기록할 수 없다.). 문자열 리터럴 밖에 있는 역 슬래시가 앞에
서 언급한 장소 이외의 곳에 등장하는 것은 문법에 어긋난다.


2.1.6. 묵시적인 줄 결합
-----------------------

괄호("()"), 꺾쇠괄호("[]"), 중괄호("{}")가 사용되는 표현은 역 슬래시
없이도 여러 개의 물리적인 줄로 나눌 수 있다. 예를 들어:

   month_names = ['Januari', 'Februari', 'Maart',      # These are the
                  'April',   'Mei',      'Juni',       # Dutch names
                  'Juli',    'Augustus', 'September',  # for the months
                  'Oktober', 'November', 'December']   # of the year

묵시적으로 이어지는 줄들은 주석을 포함할 수 있다. 이어지는 줄들의 들여
쓰기는 중요하지 않다. 중간에 빈 줄이 들어가도 된다. 묵시적으로 줄 결합
하는 줄 들 간에는 NEWLINE 토큰이 만들어지지 않는다. 묵시적으로 이어지
는 줄들은 삼중 따옴표 된 문자열들에서도 등장할 수 있는데 (아래를 보라
), 이 경우는 주석이 포함될 수 없다.


2.1.7. 빈 줄
------------

A logical line that contains only spaces, tabs, formfeeds and possibly
a comment, is ignored (i.e., no NEWLINE token is generated).  During
interactive input of statements, handling of a blank line may differ
depending on the implementation of the read-eval-print loop.  In the
standard implementation, an entirely blank logical line (i.e. one
containing not even whitespace or a comment) terminates a multi-line
statement.


2.1.8. 들여쓰기
---------------

논리적인 줄의 제일 앞에 오는 공백(스페이스와 탭)은 줄의 들여쓰기 수준
을 계산하는 데 사용되고, 이는 다시 문장들의 묶음을 결정하는 데 사용되
게 된다.

First, tabs are replaced (from left to right) by one to eight spaces
such that the total number of characters up to and including the
replacement is a multiple of eight (this is intended to be the same
rule as used by Unix).  The total number of spaces preceding the first
non-blank character then determines the line's indentation.
Indentation cannot be split over multiple physical lines using
backslashes; the whitespace up to the first backslash determines the
indentation.

**크로스-플랫폼 호환성 유의 사항:** UNIX 이외의 플랫폼에서 편집기들이
동작하는 방식 때문에, 하나의 파일 내에서 들여쓰기를 위해 탭과 스페이스
를 섞어 쓰는 것은 현명한 선택이 아니다. 다른 플랫폼들에서는 최대 들여
쓰기 수준에 제한이 있을 수도 있다는 점도 주의해야 한다.

폼 피드 문자는 줄의 처음에 나올 수 있다; 앞서 설명한 들여쓰기 수준 계
산에서는 무시된다. 페이지 넘김 문자 앞에 공백이나 탭이 있는 경우는 정
의되지 않은 효과를 줄 수 있다 (가령, 스페이스 수가 0으로 초기화될 수
있다).

연속된 줄의 들여쓰기 수준은, 스택을 사용해서, 다음과 같은 방법으로
INDENT와 DEDENT 토큰을 만드는 데 사용된다.

파일의 첫 줄을 읽기 전에 0하나를 스택에 넣는다(push); 이 값은 다시 꺼
내는(pop) 일이 없다. 스택에 넣는 값은 항상 스택의 아래에서 위로 올라갈
때 단조 증가한다. 각 논리적인 줄의 처음에서 줄의 들여쓰기 수준이 스택
의 가장 위에 있는 값과 비교된다. 같다면 아무런 일도 일어나지 않는다.
더 크다면 그 값을 스택에 넣고 하나의 INDENT 토큰을 만든다. 더 작다면
이 값은 스택에 있는 값 중 하나여만 한다. 이 값보다 큰 모든 스택의 값들
을 꺼내고(pop), 꺼낸 횟수만큼의 DEDENT 토큰을 만든다. 파일의 끝에서,
스택에 남아있는 0보다 큰 값의 개수만큼 DEDENT 토큰을 만든다.

여기에 (혼란스럽다 할지라도) 올바르게 들여쓰기 된 파이썬 코드 조각이
있다:

   def perm(l):
           # Compute the list of all permutations of 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):                       # error: first line indented
   for i in range(len(l)):             # error: not indented
       s = l[:i] + l[i+1:]
           p = perm(l[:i] + l[i+1:])   # error: unexpected indent
           for x in p:
                   r.append(l[i:i+1] + x)
               return r                # error: inconsistent dedent

(사실, 처음 세 개의 에러는 파서가 감지한다. 단지 마지막 에러만 구문 분
석기가 감지한다. --- "return r" 의 들여쓰기가 스택에 있는 값과 일치하
지 않는다.)


2.1.9. 토큰 사이의 공백
-----------------------

논리적인 줄의 처음과 문자열 리터럴을 제외하고, 공백 문자인 스페이스,
탭, 폼 피드는 토큰을 분리하기 위해 섞어 쓸 수 있다. 두 토큰을 붙여 쓸
때 다른 토큰으로 해석될 수 있는 경우만 토큰 사이에 공백이 필요하다. (
예를 들어, ab 는 하나의 토큰이지만, a b 는 두 개의 토큰이다.)


2.2. 다른 토큰들
================

NEWLINE, INDENT, DEDENT 와는 별도로, 다음과 같은 유형의 토큰들이 존재
한다: *식별자(identifier)*, *키워드(keyword)*, *리터럴(literal)*, *연
산자(operator)*, *구분자(delimiter)*. (앞에서 살펴본 줄 종료 이외의)
공백 문자들은 토큰이 아니지만, 토큰을 분리하는 역할을 담당한다. 모호할
경우, 왼쪽에서 오른쪽으로 읽을 때, 하나의 토큰은 올바르고 가능한 한 최
대 길이의 문자열로 구성되는 것을 선호한다.


2.3. 식별자와 키워드
====================

Identifiers (also referred to as *names*) are described by the
following lexical definitions:

   identifier ::= (letter|"_") (letter | digit | "_")*
   letter     ::= lowercase | uppercase
   lowercase  ::= "a"..."z"
   uppercase  ::= "A"..."Z"
   digit      ::= "0"..."9"

식별자는 길이에 제한이 없고, 케이스(case)는 구분된다.


2.3.1. 키워드
-------------

다음 식별자들은 예약어, 또는 언어의 키워드, 로 사용되고, 일반적인 식별
자로 사용될 수 없다. 여기 쓰여 있는 것과 정확히 같게 사용되어야 한다:

   and       del       from      not       while
   as        elif      global    or        with
   assert    else      if        pass      yield
   break     except    import    print
   class     exec      in        raise
   continue  finally   is        return
   def       for       lambda    try

버전 2.4으로 변경: "None" became a constant and is now recognized by
the compiler as a name for the built-in object "None".  Although it is
not a keyword, you cannot assign a different object to it.

버전 2.5으로 변경: Using "as" and "with" as identifiers triggers a
warning.  To use them as keywords, enable the "with_statement" future
feature .

버전 2.6으로 변경: "as" and "with" are full keywords.


2.3.2. 식별자의 예약 영역
-------------------------

(키워드와는 별개로) 어떤 부류의 식별자들은 특별한 의미가 있다. 이 부류
의 식별자들은 시작과 끝의 밑줄 문자 패턴으로 구분된다:

"_*"
   Not imported by "from module import *".  The special identifier "_"
   is used in the interactive interpreter to store the result of the
   last evaluation; it is stored in the "__builtin__" module.  When
   not in interactive mode, "_" has no special meaning and is not
   defined. See section 임포트(import) 문.

   주석: 이름 "_" 은 종종 국제화(internationalization)와 관련되어 사
     용된다 . 이 관례에 관해서는 "gettext" 모듈의 문서를 참조하라.

"__*__"
   시스템 정의 이름. 이 이름들은 인터프리터와 그 구현 (표준 라이브러리
   를 포함한다)이 정의한다. 현재 정의된 시스템 이름은 특수 메서드 이름
   들 섹션과 그 외의 곳에서 논의된다. 파이썬의 미래 버전에서는 더 많은
   것들이 정의될 가능성이 크다. 어떤 문맥에서건, 명시적으로 문서로 만
   들어진 사용법을 벗어나는 "__*__" 이름의 *모든* 사용은, 경고 없이 손
   상될 수 있다.

"__*"
   클래스-비공개 이름. 이 부류의 이름들을 클래스 정의 문맥에서 사용하
   면 뒤섞인 형태로 변형된다. 부모 클래스와 자식 클래스의 "비공개
   (private)" 어트리뷰트 간의 이름 충돌을 피하기 위함이다. 식별자 (이
   름) 섹션을 보라.


2.4. 리터럴
===========

리터럴(literal)은 몇몇 내장형들의 상숫값을 위한 표기법이다.


2.4.1. String literals
----------------------

문자열 리터럴은 다음과 같은 구문 정의로 기술된다:

   stringliteral   ::= [stringprefix](shortstring | longstring)
   stringprefix    ::= "r" | "u" | "ur" | "R" | "U" | "UR" | "Ur" | "uR"
                    | "b" | "B" | "br" | "Br" | "bR" | "BR"
   shortstring     ::= "'" shortstringitem* "'" | '"' shortstringitem* '"'
   longstring      ::= "'''" longstringitem* "'''"
                  | '"""' longstringitem* '"""'
   shortstringitem ::= shortstringchar | escapeseq
   longstringitem  ::= longstringchar | escapeseq
   shortstringchar ::= <any source character except "\" or newline or the quote>
   longstringchar  ::= <any source character except "\">
   escapeseq       ::= "\" <any ASCII character>

One syntactic restriction not indicated by these productions is that
whitespace is not allowed between the "stringprefix" and the rest of
the string literal. The source character set is defined by the
encoding declaration; it is ASCII if no encoding declaration is given
in the source file; see section 인코딩 선언.

In plain English: String literals can be enclosed in matching single
quotes ("'") or double quotes (""").  They can also be enclosed in
matching groups of three single or double quotes (these are generally
referred to as *triple-quoted strings*).  The backslash ("\")
character is used to escape characters that otherwise have a special
meaning, such as newline, backslash itself, or the quote character.
String literals may optionally be prefixed with a letter "'r'" or
"'R'"; such strings are called *raw strings* and use different rules
for interpreting backslash escape sequences.  A prefix of "'u'" or
"'U'" makes the string a Unicode string.  Unicode strings use the
Unicode character set as defined by the Unicode Consortium and ISO
10646.  Some additional escape sequences, described below, are
available in Unicode strings. A prefix of "'b'" or "'B'" is ignored in
Python 2; it indicates that the literal should become a bytes literal
in Python 3 (e.g. when code is automatically converted with 2to3).  A
"'u'" or "'b'" prefix may be followed by an "'r'" prefix.

In triple-quoted strings, unescaped newlines and quotes are allowed
(and are retained), except that three unescaped quotes in a row
terminate the string.  (A "quote" is the character used to open the
string, i.e. either "'" or """.)

Unless an "'r'" or "'R'" prefix is present, escape sequences in
strings are interpreted according to rules similar to those used by
Standard C.  The recognized escape sequences are:

+-------------------+-----------------------------------+---------+
| 이스케이프 시퀀스 | 의미                              | 유의 사 |
|                   |                                   | 항      |
+===================+===================================+=========+
| "\newline"        | Ignored                           |         |
+-------------------+-----------------------------------+---------+
| "\\"              | 역 슬래시 ("\")                   |         |
+-------------------+-----------------------------------+---------+
| "\'"              | 작은따옴표 ("'")                  |         |
+-------------------+-----------------------------------+---------+
| "\""              | 큰따옴표 (""")                    |         |
+-------------------+-----------------------------------+---------+
| "\a"              | ASCII 벨 (BEL)                    |         |
+-------------------+-----------------------------------+---------+
| "\b"              | ASCII 백스페이스 (BS)             |         |
+-------------------+-----------------------------------+---------+
| "\f"              | ASCII 폼 피드 (FF)                |         |
+-------------------+-----------------------------------+---------+
| "\n"              | ASCII 라인 피드 (LF)              |         |
+-------------------+-----------------------------------+---------+
| "\N{name}"        | Character named *name* in the     |         |
|                   | Unicode database (Unicode only)   |         |
+-------------------+-----------------------------------+---------+
| "\r"              | ASCII 캐리지 리턴 (CR)            |         |
+-------------------+-----------------------------------+---------+
| "\t"              | ASCII 가로 탭 (TAB)               |         |
+-------------------+-----------------------------------+---------+
| "\uxxxx"          | Character with 16-bit hex value   | (1)     |
|                   | *xxxx* (Unicode only)             |         |
+-------------------+-----------------------------------+---------+
| "\Uxxxxxxxx"      | Character with 32-bit hex value   | (2)     |
|                   | *xxxxxxxx* (Unicode only)         |         |
+-------------------+-----------------------------------+---------+
| "\v"              | ASCII 세로 탭 (VT)                |         |
+-------------------+-----------------------------------+---------+
| "\ooo"            | 8진수 *ooo* 로 지정된 문자        | (3,5)   |
+-------------------+-----------------------------------+---------+
| "\xhh"            | 16진수 *hh* 로 지정된 문자        | (4,5)   |
+-------------------+-----------------------------------+---------+

유의 사항:

1. Individual code units which form parts of a surrogate pair can
   be encoded using this escape sequence.

2. Any Unicode character can be encoded this way, but characters
   outside the Basic Multilingual Plane (BMP) will be encoded using a
   surrogate pair if Python is compiled to use 16-bit code units (the
   default).

3. 표준 C와 마찬가지로, 최대 세 개의 8진수가 허용된다.

4. 표준 C와는 달리, 정확히 두 개의 16진수가 제공되어야 한다.

5. In a string literal, hexadecimal and octal escapes denote the
   byte with the given value; it is not necessary that the byte
   encodes a character in the source character set. In a Unicode
   literal, these escapes denote a Unicode character with the given
   value.

Unlike Standard C, all unrecognized escape sequences are left in the
string unchanged, i.e., *the backslash is left in the string*.  (This
behavior is useful when debugging: if an escape sequence is mistyped,
the resulting output is more easily recognized as broken.)  It is also
important to note that the escape sequences marked as "(Unicode only)"
in the table above fall into the category of unrecognized escapes for
non-Unicode string literals.

When an "'r'" or "'R'" prefix is present, a character following a
backslash is included in the string without change, and *all
backslashes are left in the string*.  For example, the string literal
"r"\n"" consists of two characters: a backslash and a lowercase "'n'".
String quotes can be escaped with a backslash, but the backslash
remains in the string; for example, "r"\""" is a valid string literal
consisting of two characters: a backslash and a double quote; "r"\""
is not a valid string literal (even a raw string cannot end in an odd
number of backslashes).  Specifically, *a raw string cannot end in a
single backslash* (since the backslash would escape the following
quote character).  Note also that a single backslash followed by a
newline is interpreted as those two characters as part of the string,
*not* as a line continuation.

When an "'r'" or "'R'" prefix is used in conjunction with a "'u'" or
"'U'" prefix, then the "\uXXXX" and "\UXXXXXXXX" escape sequences are
processed while  *all other backslashes are left in the string*. For
example, the string literal "ur"\u0062\n"" consists of three Unicode
characters: 'LATIN SMALL LETTER B', 'REVERSE SOLIDUS', and 'LATIN
SMALL LETTER N'. Backslashes can be escaped with a preceding
backslash; however, both remain in the string.  As a result, "\uXXXX"
escape sequences are only recognized when there are an odd number of
backslashes.


2.4.2. 문자열 리터럴 이어붙이기
-------------------------------

Multiple adjacent string literals (delimited by whitespace), possibly
using different quoting conventions, are allowed, and their meaning is
the same as their concatenation.  Thus, ""hello" 'world'" is
equivalent to ""helloworld"".  This feature can be used to reduce the
number of backslashes needed, to split long strings conveniently
across long lines, or even to add comments to parts of strings, for
example:

   re.compile("[A-Za-z_]"       # letter or underscore
              "[A-Za-z0-9_]*"   # letter, digit or underscore
             )

Note that this feature is defined at the syntactical level, but
implemented at compile time.  The '+' operator must be used to
concatenate string expressions at run time.  Also note that literal
concatenation can use different quoting styles for each component
(even mixing raw strings and triple quoted strings).


2.4.3. 숫자 리터럴
------------------

There are four types of numeric literals: plain integers, long
integers, floating point numbers, and imaginary numbers.  There are no
complex literals (complex numbers can be formed by adding a real
number and an imaginary number).

숫자 리터럴이 부호를 포함하지 않는 것에 주의해야 한다; "-1" 과 같은 구
문은 일 항 연산자 '"-"' 과 리터럴 "1" 로 구성된 표현식이다.


2.4.4. Integer and long integer literals
----------------------------------------

Integer and long integer literals are described by the following
lexical definitions:

   longinteger    ::= integer ("l" | "L")
   integer        ::= decimalinteger | octinteger | hexinteger | bininteger
   decimalinteger ::= nonzerodigit digit* | "0"
   octinteger     ::= "0" ("o" | "O") octdigit+ | "0" octdigit+
   hexinteger     ::= "0" ("x" | "X") hexdigit+
   bininteger     ::= "0" ("b" | "B") bindigit+
   nonzerodigit   ::= "1"..."9"
   octdigit       ::= "0"..."7"
   bindigit       ::= "0" | "1"
   hexdigit       ::= digit | "a"..."f" | "A"..."F"

Although both lower case "'l'" and upper case "'L'" are allowed as
suffix for long integers, it is strongly recommended to always use
"'L'", since the letter "'l'" looks too much like the digit "'1'".

Plain integer literals that are above the largest representable plain
integer (e.g., 2147483647 when using 32-bit arithmetic) are accepted
as if they were long integers instead. [1]  There is no limit for long
integer literals apart from what can be stored in available memory.

Some examples of plain integer literals (first row) and long integer
literals (second and third rows):

   7     2147483647                        0177
   3L    79228162514264337593543950336L    0377L   0x100000000L
         79228162514264337593543950336             0xdeadbeef


2.4.5. 실수 리터럴
------------------

실수 리터럴은 다음과 같은 구문 정의로 표현된다:

   floatnumber   ::= pointfloat | exponentfloat
   pointfloat    ::= [intpart] fraction | intpart "."
   exponentfloat ::= (intpart | pointfloat) exponent
   intpart       ::= digit+
   fraction      ::= "." digit+
   exponent      ::= ("e" | "E") ["+" | "-"] digit+

Note that the integer and exponent parts of floating point numbers can
look like octal integers, but are interpreted using radix 10.  For
example, "077e010" is legal, and denotes the same number as "77e10".
The allowed range of floating point literals is implementation-
dependent. Some examples of floating point literals:

   3.14    10.    .001    1e100    3.14e-10    0e0

Note that numeric literals do not include a sign; a phrase like "-1"
is actually an expression composed of the unary operator "-" and the
literal "1".


2.4.6. 허수 리터럴
------------------

허수 리터럴은 다음과 같은 구문 정의로 표현된다:

   imagnumber ::= (floatnumber | intpart) ("j" | "J")

허수 리터럴은 실수부가 0.0인 복소수를 만든다. 복소수는 실수와 같은 범
위 제약이 적용되는 한 쌍의 실수로 표현된다. 0이 아닌 실수부를 갖는 복
소수를 만들려면, 실수를 더하면 된다. 예를 들어, "(3+4j)". 허수 리터럴
의 몇 가지 예를 든다:

   3.14j   10.j    10j     .001j   1e100j  3.14e-10j


2.5. 연산자
===========

다음과 같은 토큰들은 연산자다:

   +       -       *       **      /       //      %
   <<      >>      &       |       ^       ~
   <       >       <=      >=      ==      !=      <>

The comparison operators "<>" and "!=" are alternate spellings of the
same operator.  "!=" is the preferred spelling; "<>" is obsolescent.


2.6. 구분자
===========

다음 토큰들은 문법에서 구분자(delimiter)로 기능한다:

   (       )       [       ]       {       }      @
   ,       :       .       `       =       ;
   +=      -=      *=      /=      //=     %=
   &=      |=      ^=      >>=     <<=     **=

The period can also occur in floating-point and imaginary literals.  A
sequence of three periods has a special meaning as an ellipsis in
slices. The second half of the list, the augmented assignment
operators, serve lexically as delimiters, but also perform an
operation.

다음의 인쇄되는 ASCII 문자들은 다른 토큰들 일부로서 특별한 의미를 같거
나, 그 밖의 경우 구문 분석기에 유의미하다:

   '       "       #       \

다음의 인쇄되는 ASCII 문자들은 파이썬에서 사용되지 않는다. 문자열 리터
럴과 주석 이외의 곳에서 사용되는 것은 조건 없는 에러다:

   $       ?

-[ 각주 ]-

[1] In versions of Python prior to 2.4, octal and hexadecimal
    literals in the range just above the largest representable plain
    integer but below the largest unsigned 32-bit number (on a machine
    using 32-bit arithmetic), 4294967296, were taken as the negative
    plain integer obtained by subtracting 4294967296 from their
    unsigned value.
