深入理解Python赋值语句的BNF结构

霞舞

发布时间：2025-09-01 21:39:01

281人浏览过

来源于php中文网

原创

深入理解Python赋值语句的BNF结构

本文旨在深入解析Python赋值语句的巴科斯-诺尔范式（BNF）结构，特别是针对初学者常遇到的困惑：一个简单的数字字面量（如9）如何符合复杂的右侧表达式语法。通过详细追溯从starred_expression到literal的完整解析路径，并强调BNF中可选语法元素的设计，揭示Python语法解析的内在机制。

Python赋值语句的BNF核心结构

python语言的语法规则由其官方文档中定义的巴科斯-诺尔范式（bnf）所描述。赋值语句是python中最基本的操作之一，其bnf定义如下：

assignment_stmt ::=  (target_list "=")+ (starred_expression | yield_expression)
target_list     ::=  target ("," target)* [","]
target          ::=  identifier
                     | "(" [target_list] ")"
                     | "[" [target_list] "]"
                     | attributeref
                     | subscription
                     | slicing
                     | "*" target

从上述定义中可以看出，一个赋值语句（assignment_stmt）由一个或多个目标列表（target_list）和一个等号（=）组成，其右侧（RHS）则是一个starred_expression或yield_expression。例如，在a = 9这个简单的赋值中，a是target_list的一部分，而9则必须符合starred_expression或yield_expression的语法。

右侧表达式的解析路径：从starred_expression到expression

对于a = 9这样的普通赋值，右侧的9显然不是一个yield_expression（它涉及生成器），因此它必须符合starred_expression的定义。starred_expression的BNF定义如下：

starred_expression ::=  expression | (starred_item ",")* [starred_item]
starred_item       ::=  assignment_expression | "*" or_expr

这里是理解9如何符合语法的关键点：starred_expression可以仅仅是一个expression。这意味着，只要9能够被解析为一个expression，它就能作为赋值语句的右侧部分。因此，我们的核心任务就变成了追溯expression如何最终包含像9这样的数字字面量。

逐步深入：从expression到literal

Python的expression是一个非常广泛的概念，它通过一系列的递归定义，逐步细化到最基本的语法单元，如字面量（literal）。下面是expression到integer的完整解析路径：

立即学习“Python免费学习笔记（深入）”；

expression: 可以是 conditional_expression 或 lambda_expr。
```
expression             ::=  conditional_expression | lambda_expr
```
9 不含 lambda，所以它被解析为 conditional_expression。
conditional_expression: 可以是 or_test ["if" or_test "else" expression]。
```
conditional_expression ::=  or_test ["if" or_test "else" expression]
```
9 不含 if/else，所以它被解析为 or_test。
or_test: 可以是 and_test 或 or_test "or" and_test。
```
or_test                ::=  and_test | or_test "or" and_test
```
9 不含 or，所以它被解析为 and_test。
and_test: 可以是 not_test 或 and_test "and" not_test。
```
and_test               ::=  not_test | and_test "and" not_test
```
9 不含 and，所以它被解析为 not_test。
not_test: 可以是 comparison 或 "not" not_test。
```
not_test               ::=  comparison | "not" not_test
```
9 不含 not，所以它被解析为 comparison。
comparison: 可以是 or_expr (comp_operator or_expr)*。
```
comparison             ::=  or_expr (comp_operator or_expr)*
```
9 不含比较运算符，所以它被解析为 or_expr。
or_expr: 可以是 xor_expr 或 or_expr "|" xor_expr。
```
or_expr                ::=  xor_expr | or_expr "|" xor_expr
```
9 不含位运算符 |，所以它被解析为 xor_expr。
xor_expr: 可以是 and_expr 或 xor_expr "^" and_expr。
```
xor_expr               ::=  and_expr | xor_expr "^" and_expr
```
9 不含位运算符 ^，所以它被解析为 and_expr。
and_expr: 可以是 shift_expr 或 and_expr "&" shift_expr。
```
and_expr               ::=  shift_expr | and_expr "&" shift_expr
```
9 不含位运算符 &，所以它被解析为 shift_expr。
shift_expr: 可以是 a_expr 或 shift_expr (">") a_expr。
```
shift_expr             ::=  a_expr | shift_expr ("<<" | ">>") a_expr
```
9 不含移位运算符 >，所以它被解析为 a_expr。
a_expr (additive expression): 可以是 m_expr 或 a_expr "+" m_expr 或 a_expr "-" m_expr。
```
a_expr                 ::=  m_expr | a_expr "+" m_expr | a_expr "-" m_expr
```
9 不含加减运算符，所以它被解析为 m_expr。

m_expr (multiplicative expression): 可以是 u_expr 或 m_expr "*" u_expr 等。

m_expr                 ::=  u_expr | m_expr "*" u_expr | m_expr "@" m_expr |
                              m_expr "//" u_expr | m_expr "/" u_expr |
                              m_expr "%" u_expr

9 不含乘、除、取模、矩阵乘法等运算符，所以它被解析为 u_expr。

u_expr (unary expression): 可以是 power 或 "-" u_expr 等。
```
u_expr                 ::=  power | "-" u_expr | "+" u_expr | "~" u_expr
```
9 不含一元运算符（如 -、+、~），所以它被解析为 power。
power: 可以是 (await_expr | primary) ["**" u_expr]。
```
power                  ::=  (await_expr | primary) ["**" u_expr]
```
9 不含 await 或 ** 运算符，所以它被解析为 primary。
primary: 可以是 atom 或 attributeref 等。
```
primary                ::=  atom | attributeref | subscription | slicing | call
```
9 不是属性引用、订阅、切片或函数调用，所以它被解析为 atom。
atom: 可以是 identifier、literal 或 enclosure。
```
atom                   ::=  identifier | literal | enclosure
```
9 既不是标识符也不是括号等，所以它被解析为 literal。

literal: 可以是 stringliteral、bytesliteral、integer、floatnumber 或 imagnumber。

literal                ::=  stringliteral | bytesliteral
                              | integer | floatnumber | imagnumber

9 显然是一个 integer。

integer: 可以是 decinteger、bininteger、octinteger 或 hexinteger。
```
integer                ::=  decinteger | bininteger | octinteger | hexinteger
```
9 是一个十进制整数，最终被解析为 decinteger。

至此，我们成功地将数字9追溯到了其最基本的语法单元：decinteger，它完全符合Python的BNF语法规则。

关键洞察：可选语法元素的重要性

在上述解析路径中，一个非常重要的设计原则是：从conditional_expression到power的每个语法元素，其“特征性”的运算符或关键字往往是可选的。例如：

conditional_expression 中的 if ... else ... 部分是可选的。
or_test 中的 or 关键字是可选的。
power 中的 ** 运算符是可选的。

这意味着，即使一个表达式不包含任何特定的运算符（如if、or、+、*、**等），它仍然可以被解析为这些更高级别的语法元素。例如，2**16 是一个 power，但 2 本身也符合 power 的定义。正是这种设计，使得一个简单的数字字面量能够通过层层递归，向上匹配到 expression，并最终符合 starred_expression 的要求。