2. Lexical analysis

Python 程序由* parser 读取。解析器的 Importing 是由词法分析器生成的令牌*流。本章介绍词法分析器如何将文件分解为令牌。

Python 将程序文本作为 Unicode 代码点读取；源文件的编码可以由编码语句指定，默认为 UTF-8，有关详细信息，请参见 PEP 3120。如果无法解码源文件，则引发SyntaxError。

2.1. 行结构

Python 程序分为多个逻辑行。

2.1.1. 逻辑行

逻辑行的结尾由令牌 NEWLINE 表示。语句不能跨越逻辑行边界，除非语法允许使用 NEWLINE(例如，复合语句中的语句之间)。pass遵循显式或隐式“线连接”规则，由一条或多条“物理行”构成一条逻辑行。

2.1.2. 物理行

物理行是由行尾序列终止的字符序列。在源文件和字符串中，可以使用任何标准平台的行终止 Sequences-使用 ASCII LF(换行)的 Unix 形式，使用 ASCII 序列 CR LF(返回然后换行)的 Windows 形式，或使用 ASCII 序列的旧 Macintosh 形式。 ASCII CR(返回)字符。无论平台如何，所有这些形式都可以平等使用。Importing 的结尾还充当finally物理行的隐式终止符。

嵌入 Python 时，应使用换行符的标准 C 约定将源代码字符串传递给 Python API(代表 ASCII LF 的\n字符是行终止符)。

2.1.3. Comments

Comments 以不属于字符串 Literals 的哈希字符(#)开头，并在物理行的结尾处结束。Comments 表示逻辑行的结尾，除非调用了隐式行连接规则。语法将忽略 Comments。

2.1.4. 编码语句

如果 Python 脚本的第一行或第二行中的 Comments 与正则表达式coding[=:]\s*([-\w.]+)匹配，则将该 Comments 作为编码语句处理；否则，将其作为编码语句处理。该表达式的第一组命名源代码文件的编码。编码语句必须单独出现。如果是第二行，则第一行也必须是仅 Comments 行。推荐的编码表达式形式为

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

GNU Emacs 也认识到这一点，并且

# vim:fileencoding=<encoding-name>

被 Bram Moolenaar 的 VIM 认可。

如果未找到编码语句，则默认编码为 UTF-8.另外，如果文件的第一个字节是 UTF-8 字节 Sequences 标记(b'\xef\xbb\xbf')，则语句的文件编码为 UTF-8(Microsoft 的 notepad 支持)。

如果语句了编码，则编码名称必须由 Python 识别。该编码用于所有词法分析，包括字符串 Literals，Comments 和标识符。

2.1.5. 显式连接

可以使用反斜杠字符(\)将两条或更多条物理行连接为逻辑行，如下所示：当一条物理行以不属于字符串 Literals 或 Comments 的一部分的反斜杠结尾时，将其与以下行合并成一个逻辑行，删除反斜杠和以下行尾字符。例如：

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

以反斜杠结尾的行不能带有 Comments。反斜杠不会 continue 发表 Comment。除字符串 Literals 外，反斜杠不会延续令牌(即，字符串 Literals 之外的令牌不能使用反斜杠在物理行之间分割)。反斜杠在字符串 Literals 之外的其他地方是非法的。

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

隐含的连续行可以带有 Comments。连续线的缩进并不重要。允许使用空白连续行。隐式连续行之间没有 NEWLINE 令牌。在三引号字符串中也可能出现隐含的连续行(请参见下文)；在这种情况下，他们将无法发表 Comment。

2.1.7. 空行

仅包含空格，制表符，换页符和可能包含 Comments 的逻辑行将被忽略(即，不会生成 NEWLINE 令牌)。在语句的交互式 Importing 期间，根据 read-eval-print 循环的实现，空白行的处理可能有所不同。在标准的交互式解释器中，一个完全空白的逻辑行(即不包含空格或 Comments 的逻辑行)终止多行语句。

2.1.8. Indentation

逻辑行开头的前导空格(空格和制表符)用于计算行的缩进级别，而缩进级别又用于确定语句的分组。

制表符被替换为(从左到右)一到八个空格，这样，包括替换在内的字符总数为八个的倍数(这与 Unix 所使用的规则相同)。然后，第一个非空白字符之前的空格总数将确定该行的缩进。缩进不能使用反斜线分割成多条物理行；直到第一个反斜杠的空格都会确定缩进。

如果源文件混合制表符和空格，使得含义取决于制表符在空格中的价值，则缩进被视为不一致。在这种情况下，将引发TabError。

跨平台兼容性说明： 由于非 UNIX 平台上的文本编辑器的性质，在单个源文件中将空格和制表符混合用于缩进是不明智的。还应注意，不同平台可能会明确限制最大缩进级别。

行的开头可能会出现换页符；上面的缩进计算将忽略它。前导空格中其他位置出现的换页字符具有不确定的效果(例如，它们可能会将空格计数重置为零)。

连续行的缩进级别用于使用堆栈生成 INDENT 和 DEDENT 令牌，如下所示。

在读取文件的第一行之前，将单个零压入堆栈。这将不再弹出。压入堆栈的数字将始终严格按照从下到上的 Sequences 递增。在每条逻辑行的开头，将行的缩进级别与堆栈顶部进行比较。如果相等，则什么也不会发生。如果较大，则将其压入堆栈，并生成一个 INDENT 令牌。如果较小，则必须是堆栈中出现的数字之一；弹出堆栈中所有较大的数字，并为弹出的每个数字生成一个 DEDENT 令牌。在文件末尾，将为堆栈上剩余的每个大于零的数字生成一个 DEDENT 令牌。

这是一个正确(尽管令人困惑)缩进的 Python 代码示例：

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. 令牌之间的空白

除了逻辑行的开头或字符串 Literals 外，空格字符空格，制表符和换页符可以互换使用以分隔标记。仅当两个令牌的级联可以被解释为其他令牌时(例如，ab 是一个令牌，而 b 是两个令牌)，才需要在两个令牌之间使用空格。

2.2. 其他token

除了 NEWLINE，INDENT 和 DEDENT，还存在以下类别的令牌：标识符，关键字，Literals，运算符和定界符。空格字符(前面讨论过的行终止符除外)不是标记，而是用来分隔标记。在存在歧义的地方，当从左向右读取时，令牌包括形成合法令牌的最长字符串。

2.3. 标识符和关键字

标识符(也称为* name *)由以下词汇定义描述。

Python 中标识符的语法基于 Unicode 标准附件 UAX-31，其详细说明和更改如下所述；另请参阅 PEP 3131。

在 ASCII 范围(U 0001..U 007F)中，标识符的有效字符与 Python 2.x 中的相同：大写和小写字母A至Z，下划线_以及除第一个字符外的数字0至9。

Python 3.0 引入了 ASCII 范围之外的其他字符(请参见 PEP 3131)。对于这些字符，分类使用unicodedata模块中包含的 Unicode 字符数据库的版本。

标识符的长度是无限的。情况很重要。

identifier   ::=  xid_start xid_continue*
id_start     ::=  <all characters in general categories Lu, Ll, Lt, Lm, Lo, Nl, the underscore, and characters with the Other_ID_Start property>
id_continue  ::=  <all characters in id_start, plus characters in the categories Mn, Mc, Nd, Pc and others with the Other_ID_Continue property>
xid_start    ::=  <all characters in id_start whose NFKC normalization is in "id_start xid_continue*">
xid_continue ::=  <all characters in id_continue whose NFKC normalization is in "id_continue*">

上面提到的 Unicode 类别代码代表：

• • Lu *-大写字母
• • Ll *-小写字母
• • LT *-标题字母
• • LM *-修饰词
• • Lo *-其他字母
• • Nl *-字母数字
• • Mn *-非间距标记
• • MC *-间距组合标记
• • ND *-十进制数字
• • PC *-连接器标点
• • Other_ID_Start *-PropList.txt中的字符列表，以支持向后兼容
• • Other_ID_Continue *-同样

解析时，所有标识符都转换为标准形式 NFKC；标识符的比较基于 NFKC。

列出 Unicode 4.1 的所有有效标识符字符的非规范 HTML 文件可在https://www.unicode.org/Public/13.0.0/ucd/DerivedCoreProperties.txt找到。

2.3.1. Keywords

以下标识符用作保留字或语言的“关键字”，而不能用作普通标识符。它们的拼写必须与此处完全相同：

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. 保留的标识符类别

某些类别的标识符(除关键字外)具有特殊含义。这些类由前划线和下划线字符的模式标识：

• _*

  • 未由from module import *导入。在交互式解释器中使用特殊标识符_来存储上一次评估的结果；它存储在builtins模块中。当不在交互模式下时，_没有特殊含义且未定义。参见import 语句部分。

• __*__

  • 系统定义的名称，非正式地称为“ dunder”名称。这些名称由解释器及其实现(包括标准库)定义。当前的系统名称将在特殊方法名称部分和其他地方讨论。将来的 Python 版本中可能会定义更多内容。 *在任何情况下，任何未使用__*__名称的操作(未遵循明确记录的使用方法)都会遭到破坏，恕不另行通知。

• __*

  • 类私有名称。当在类定义的上下文中使用时，此类别中的名称将被重写，以使用变形的形式来帮助避免 Base Class 和派生类的“私有”属性之间的名称冲突。参见Identifiers (Names)部分。

2.4. Literals

Literals 是某些内置类型的常量值的表示法。

2.4.1. 字符串和字节 Literals

字符串 Literals 由以下词汇定义描述：

stringliteral   ::=  [stringprefix](shortstring | longstring)
stringprefix    ::=  "r" | "u" | "R" | "U" | "f" | "F"
                     | "fr" | "Fr" | "fR" | "FR" | "rf" | "rF" | "Rf" | "RF"
shortstring     ::=  "'" shortstringitem* "'" | '"' shortstringitem* '"'
longstring      ::=  "'''" longstringitem* "'''" | '"""' longstringitem* '"""'
shortstringitem ::=  shortstringchar | stringescapeseq
longstringitem  ::=  longstringchar | stringescapeseq
shortstringchar ::=  <any source character except "\" or newline or the quote>
longstringchar  ::=  <any source character except "\">
stringescapeseq ::=  "\" <any source character>

bytesliteral   ::=  bytesprefix(shortbytes | longbytes)
bytesprefix    ::=  "b" | "B" | "br" | "Br" | "bR" | "BR" | "rb" | "rB" | "Rb" | "RB"
shortbytes     ::=  "'" shortbytesitem* "'" | '"' shortbytesitem* '"'
longbytes      ::=  "'''" longbytesitem* "'''" | '"""' longbytesitem* '"""'
shortbytesitem ::=  shortbyteschar | bytesescapeseq
longbytesitem  ::=  longbyteschar | bytesescapeseq
shortbyteschar ::=  <any ASCII character except "\" or newline or the quote>
longbyteschar  ::=  <any ASCII character except "\">
bytesescapeseq ::=  "\" <any ASCII character>

这些产生式未表示的一种语法限制是stringprefix或bytesprefix与 Literals 的其余部分之间不允许有空格。源字符集由编码语句定义。如果源文件中未给出编码语句，则为 UTF-8；否则为 UTF-8.参见Encoding declarations部分。

用简单的英语：两种类型的 Literals 都可以用匹配的单引号(')或双引号(")括起来。也可以将它们括在匹配的组中，该组具有三个单引号或双引号(通常称为三重引号字符串)。反斜杠(\)字符用于转义具有特殊含义的字符，例如换行符，反斜杠本身或引号字符。

字节字面量始终以'b'或'B'为前缀；它们产生的是bytes类型的实例，而不是str类型的实例。它们只能包含 ASCII 字符；数值等于或大于 128 的字节必须用转义符表示。

字符串和字节 Literals 都可以选择以字母'r'或'R'作为前缀；这样的字符串称为“原始字符串”，并将反斜杠视为 Literals 字符。结果，在字符串 Literals 中，原始字符串中的'\U'和'\u'转义符未得到特殊处理。鉴于 Python 2.x 的原始 unicodeLiterals 的行为不同于 Python 3.x 的'ur'语法。

版本 3.3 中的新Function：原始字节 Literals 的'rb'前缀已作为'br'的同义词添加。

3.3 版中的新增Function：重新引入了对 Unicode 遗留 Literals(u'value')的支持，以简化对双重 Python 2.x 和 3.x 代码库的维护。有关更多信息，请参见 PEP 414。

前缀为'f'或'F'的字符串 Literals 是格式化的字符串 Literals；参见格式化的字符串 Literals。 'f'可以与'r'组合，但不能与'b'或'u'组合，因此可以使用原始格式化的字符串，但不能使用格式化的字节 Literals。

在三重引号 Literals 中，允许(并保留)未转义的换行符和引号，但连续三个未转义的引号会终止 Literals。 (“引号”是用于打开 Literals 的字符，即'或".)

除非存在'r'或'R'前缀，否则将根据类似于标准 C 的规则解释字符串和字节文本中的转义序列。可识别的转义序列为：

仅在字符串 Literals 中识别的转义序列是：

Notes:

• 与标准 C 一样，最多可以接受三个八进制数字。

• 与标准 C 中不同，仅需要两个十六进制数字。

• 在字节 Literals 中，十六进制和八进制转义表示具有给定值的字节。在字符串 Literals 中，这些转义符表示具有给定值的 Unicode 字符。

• 在版本 3.3 中更改：已添加对名称别名[1]的支持。

• 确实需要四个十六进制数字。

• 任何 Unicode 字符都可以用这种方式编码。恰好需要八个十六进制数字。

与标准 C 不同，所有无法识别的转义序列都保留在字符串中，即结果中留有反斜杠。 (此行为在调试时非常有用：如果转义序列 Importing 错误，则更容易将输出识别为break.)还必须注意，仅在字符串 Literals 中识别的转义序列属于无法识别的字节转义类别。Literals。

即使使用原始 Literals，也可以使用反斜杠对引号进行转义，但是反斜杠仍保留在结果中。例如，r"\""是由两个字符组成的有效字符串 Literals：反斜杠和双引号； r"\"不是有效的字符串 Literals(即使原始字符串也不能以奇数个反斜杠结尾)。具体来说，原始 Literals 不能以单个反斜杠结尾(因为反斜杠会转义以下引号字符)。还要注意，单个反斜杠后跟换行符被解释为这两个字符作为 Literals 的一部分，不被解释为行的延续。

2.4.2. 字符串 Literals 串联

允许使用可能使用不同的引用约定的多个相邻的字符串或字节 Literals(由空格分隔)，它们的含义与它们的串联相同。因此，"hello" 'world'等效于"helloworld"。此Function可用于减少所需的反斜杠数量，在长行之间方便地分割长字符串，甚至可为字符串的部分添加 Comments，例如：

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

请注意，此Function在语法级别定义，但在编译时实现。必须在运行时使用''运算符来连接字符串表达式。还要注意，Literals 串联可以为每个组件使用不同的引用样式(甚至混合原始字符串和三重引号字符串)，并且格式化的字符串 Literals 可以与纯字符串 Literals 串联。

2.4.3. 格式化的字符串 Literals

3.6 版的新Function。

格式的字符串 Literals或* f-string *是前缀为'f'或'F'的字符串 Literals。这些字符串可能包含替换字段，这些替换字段由大括号{}分隔的表达式。尽管其他字符串 Literals 始终具有恒定值，但是格式化的字符串实际上是在运行时评估的表达式。

转义序列的解码方式与普通字符串 Literals 中的解码方式相同(除非 Literals 也被标记为原始字符串)。解码后，字符串内容的语法为：

f_string          ::=  (literal_char | "{{" | "}}" | replacement_field)*
replacement_field ::=  "{" f_expression ["!" conversion] [":" format_spec] "}"
f_expression      ::=  (conditional_expression | "*" or_expr)
                         ("," conditional_expression | "," "*" or_expr)* [","]
                       | yield_expression
conversion        ::=  "s" | "r" | "a"
format_spec       ::=  (literal_char | NULL | replacement_field)*
literal_char      ::=  <any code point except "{", "}" or NULL>

花括号外的字符串部分将按字面进行处理，除了将任何双大括号'{{'或'}}'替换为相应的单个大括号。单个大括号'{'标记了一个替换字段，该字段以 Python 表达式开头。表达式之后，可能会有一个转换字段，由感叹号'!'引入。也可以附加格式说明符，由冒号':'引起。替换字段以大括号'}'结尾。

格式化字符串 Literals 中的表达式被视为带括号的常规 Python 表达式，但有一些 exception。不允许使用空表达式，并且lambda和赋值表达式:=都必须用显式括号括起来。替换表达式可以包含换行符(例如，用三引号引起来的字符串)，但不能包含 Comments。每个表达式在格式化的字符串 Literals 出现的上下文中按从左到右的 Sequences 求值。

在 3.7 版中进行了更改：在 Python 3.7 之前，由于实现问题，格式化格式的字符串 Literals 中的await表达式和包含async for子句的理解都是非法的。

如果指定了转换，则在格式化之前转换对表达式求值的结果。转换'!s'调用结果str()，'!r'调用repr()，'!a'调用ascii()。

然后使用format()协议格式化结果。格式说明符将传递到表达式或转换结果的format()方法。当Ellipsis格式说明符时，将传递一个空字符串。然后，格式化结果将包含在整个字符串的finally值中。

顶级格式说明符可能包含嵌套的替换字段。这些嵌套字段可能包括其自己的转换字段和format specifiers，但可能不包括嵌套更深的替换字段。 格式说明符迷你语言与字符串.format()方法所使用的相同。

格式化的字符串 Literals 可以串联，但是替换字段不能在 Literals 之间分割。

格式化字符串 Literals 的一些示例：

>>> name = "Fred"
>>> f"He said his name is {name!r}."
"He said his name is 'Fred'."
>>> f"He said his name is {repr(name)}."  # repr() is equivalent to !r
"He said his name is 'Fred'."
>>> width = 10
>>> precision = 4
>>> value = decimal.Decimal("12.34567")
>>> f"result: {value:{width}.{precision}}"  # nested fields
'result:      12.35'
>>> today = datetime(year=2017, month=1, day=27)
>>> f"{today:%B %d, %Y}"  # using date format specifier
'January 27, 2017'
>>> number = 1024
>>> f"{number:#0x}"  # using integer format specifier
'0x400'

与常规字符串 Literals 共享相同语法的结果是，替换字段中的字符不得与外部格式化的字符串 Literals 中使用的引用冲突：

f"abc {a["x"]} def"    # error: outer string literal ended prematurely
f"abc {a['x']} def"    # workaround: use different quoting

格式表达式中不允许反斜杠，并且会引发错误：

f"newline: {ord('\n')}"  # raises SyntaxError

要包含需要反斜杠转义的值，请创建一个临时变量。

>>> newline = ord('\n')
>>> f"newline: {newline}"
'newline: 10'

格式化的字符串 Literals 不能用作文档字符串，即使它们不包含表达式也是如此。

>>> def foo():
...     f"Not a docstring"
...
>>> foo.__doc__ is None
True

另请参阅 PEP 498以获取添加格式化字符串 Literals 的建议，以及str.format()，该提案使用相关的格式字符串机制。

2.4.4. 数值 Literals

数字 Literals 有三种类型：整数，浮点数和虚数。没有复杂的 Literals(可以pass添加实数和虚数来形成复数)。

请注意，数字 Literals 不包含符号。像-1这样的短语实际上是由一元运算符'-'和 Literals1组成的表达式。

2.4.5. 整数 Literals

整数 Literals 由以下词汇定义描述：

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

除了可以存储在可用内存中的整数之外，整数 Literals 的长度没有限制。

用于确定 Literals 数字值的下划线将被忽略。它们可用于对数字进行分组以增强可读性。下划线可以出现在数字之间以及在基本说明符(如0x)之后。

请注意，不允许使用非零十进制数字开头的零。这是为了消除 C 样式八进制 Literals 的歧义，Python 在 3.0 版之前使用了这些样式。

整数 Literals 的一些示例：

7     2147483647                        0o177    0b100110111
3     79228162514264337593543950336     0o377    0xdeadbeef
      100_000_000_000                   0b_1110_0101

在版本 3.6 中进行了更改：现在允许在文本中使用下划线进行分组。

2.4.6. 浮点 Literals

浮点 Literals 由以下词汇定义描述：

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

请注意，整数和指数部分始终使用基数 10 进行解释。例如，077e010是合法的，并且表示与77e10相同的数字。浮点 Literals 的允许范围取决于实现。与整数 Literals 一样，数字分组支持下划线。

浮点 Literals 的一些示例：

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

在版本 3.6 中进行了更改：现在允许在文本中使用下划线进行分组。

2.4.7. 虚构 Literals

虚构的 Literals 由以下词汇定义描述：

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

虚数 Literals 产生一个复数，其实部为 0.0. 复数表示为Pair浮点数，并且对它们的范围有相同的限制。要创建具有非零实数的复数，请向其添加一个浮点数，例如(3+4j)。虚构 Literals 的一些示例：

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

2.5. Operators

以下标记是运算符：

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

2.6. Delimiters

以下标记用作语法中的定界符：

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

该句点也可以出现在浮点数和虚数 Literals 中。三个句点的序列作为Ellipsis号有特殊含义。列表的后半部分，扩展的赋值运算符，在词法上充当定界符，但也执行操作。

以下打印 ASCII 字符作为其他标记的一部分具有特殊含义，或者对于词法分析器而言是重要的：

'       "       #       \

以下印刷 ASCII 字符未在 Python 中使用。它们出现在字符串 Literals 和 Comments 之外是一个无条件错误：

$       ?       `

Footnotes

• [1]
  • http://www.unicode.org/Public/11.0.0/ucd/NameAliases.txt