【ZZ】Python 学习笔记 01 – 缩进

Python舍弃了传统的大括号，独到的利用缩进组织代码，使得Python代码更整齐，更清洁，但初学Python的缩进特性，却有着各式各样的疑问，这些疑问层出不穷，苦恼万分。

 

1、困惑

问1：若是混用Tab和空格，Python如何处理缩进的呢？

（注：虽然混用空格和Tab是bug的温床，但这个问题让我很困惑）

 

问2：每次缩进只能用一个Tab吗？能使用2个Tab缩进吗？能使用多个Tab吗？

(每次缩进，对于使用几个空格、几个Tab没有明确规定吗？)

问3：下面这个例子错在哪里？

if a > 5 :
         a = 103
     print "here"

（注：第2行比第1行缩进了2个Tab，第3行比第一行缩进了1个Tab，那么第3行还属于if语句的block吗？）

 

问4：下面这个例子错在哪里？

if a > 5 :
    a = 103
        b = 5

（注：第2行比第1行缩进了1个Tab，第3行比第1行缩进了2个Tab，那么第3行还属于if语句的block吗？）

 

2、释惑

         (在Python内部，缩进称为indent，indent是向右缩进，反过来，向左缩进称为dedent，是用来和indent配对的)

         Python对缩进的处理分为2个阶段：词法解析阶段和语法解析阶段。其中大部分处理在词法解析阶段完成。

1.         变量：tok->atbol

         Python的词法解析源文件是parser/Tokenizer.c，其对外的接口是：PyTokenizer_Get(…)。

         PyTokenizer_Get(…)函数是对static函数tok_get(…)的简易包装，Python对缩进的处理的起始处就在tok_get(…)这个函数中，即文件的第1201行：

1200:    /* Get indentation level */
1201:    if (tok->atbol) {
……:        ……
1204:        tok->atbol = 0;

在进入函数tok_get()，会判断变量tok->atbol是否为真，“atbol”全称是“at the begin of line”，标志当前的词法分析器，是否处于一行的开始。这个判断的意图很简单：只有一行开始的空格和Tab才能被看成缩进处理。

tok->atbol变量是在词法解析器每次遇到换行符’\n’时，才被置为1。

无论怎么样，在1204行，每次开始处理一个新行后，tok->atbol都会被置为0。

 

2.         混用Tab和空格会发生什么？

      在平时的认识中，只知道1个Tab至关于4个或者8个字符的宽度，从没想过Tab和空格混用时会发生什么事。假设如下的讨论中Tab至关于8个字符的宽度。

      Tab实际上是将当前的输入光标，位置移到下一个8字符宽度的边界。若是此时一行中已经输入了7个字符，Tab只会扩展1个字符的宽度，使得输入光标在8字符宽度的边界。若是此时已经输入1个字符，Tab会扩展7个字符的宽度，使得输入光标在8字符宽度的边界。

      那么根据以上分析，使用nchar表明已经输入的字符数，再输入一个Tab后，光标的位置能够用下面的计算公式表达：

pos = (nchar / 8 + 1) * 8

 

在Python的源码中，有相似的代码：

1210: col = (col/tok->tabsize + 1) * tok->tabsize;

 

其中，tok->tabsize表明一个Tab至关于几个字符的宽度。

3.         Python实际上是将Tab转换成空格处理缩进的

1205:for (;;) {
1206:     c = tok_nextc(tok);  
1207:     if (c == ' ')  
1208:             col++;  
1209:     else if (c == '\t')  
1210:             col = (col/tok->tabsize + 1) * tok->tabsize;  
1216:     else   
1217:             break;  1218:        
}

 

从1205行到1218行，是一个大循环，是用于计算遇到的空格、Tab数量的，一直到1217行，遇到的字符不是空格、也不是Tab时，从大循环里break出去。

1206行的tok_nextc(tok)，是读取下一个字符的函数。

1207-1208行，若是下个字符是空格，col变量的值就加1。

1209-1210行，若是下个字符是Tab，那么就按照将Tab扩展到tok->tabsize个字符宽度的边界，将Tab转换成空格的个数。

 

4.         变量tok->level，当tok->level == 0时，才进行缩进判断

        tok->level这个变量，每次遇到小括号”(“，中括号”[“，大括号”{“时，tok->level++。

        每次遇到小括号右端”)”，中括号右端”]”，大括号右端”}”时，tok->level--。

        以此看出，tok->level并不能准确记录小括号的嵌套数量，也不能准确记录中括号、大括号的嵌套数量。

        其实，tok->level只是用来标识，当前是否处于括号中。词法解析中，并不去关心括号的嵌套、配对是否正确，这些是语法解析器关心的问题。因此，在词法解析中，只须要用这一个变量，tok->level，用来标识当前是否处于括号中就能够了。

        以下例子：

1:  a = [ x for x in range(
2:             0, 10)  
3:      ]

 

在第2行，第3行，都有Tab缩进，但因为是处于括号（不论是小括号、中括号、大括号）中，这些Tab都不会被Python当成缩进处理的！

故：一行开始处的Tab和空格，若是是处于括号中，是不会被当成缩进处理的！

5.         词法解析器中的缩进栈tok->indstack

tok->indstack，是indent stack的缩写。栈顶是由变量tok->indent指示的。

        刚开始，tok->indstack缩进栈初始化代码以下：

k->indent = 0;
tok->indstack[0] = 0;

Python的词法解析器，会在每次遇到缩进时，在这个缩进栈里Push一条记录。

        其中，栈顶是用变量tok->indent指示的，栈顶元素就是经过如下代码读取的：

tok->indstack[tok->indent]

 

在以前的代码中，已经计算出了本行开始处空格的数量了，（Tab也已经转换成了空格的数量），记录在变量col中。

1234:        if (col == tok->indstack[tok->indent]) {
1235:                 /* No change */ 
1240:        }

下面就是开始作缩进判断了，在1234行，若是col的值和tok->indstack栈顶元素相同时，说明本行和上一行缩进量相同，不处理。

1241:        else if (col > tok->indstack[tok->indent]) { 
1242:                 /* Indent -- always one */    …… 
1252:                 tok->pendin++;
1253:                 tok->indstack[++tok->indent] = col;
1255:        }

若是本行的col，比缩进栈tok->indstack栈顶的元素大，表示本行比上一行发生了右缩进，indent。此时，不论本行使用了多少个空格，使用了多少个Tab，通通只算做缩进了一次！即tok->pendin++。

而后，在1253行，将本行的缩进量，col，Push进缩进栈中。

       

6.         变量tok->pendin

        注意到上面的代码中，缩进一次会tok->pendin++。

        能够看出，这个变量tok->pendin实际上是记录已经缩进的次数的，准确的来讲，若是tok->pendin == 0，说明没有发生过缩进。

        若是tok->pendin > 0，说明发生个tok->pendin次右缩进，即indent。

        若是tok->pendin < 0，说明发生过ABS(tok->pendin)次左缩进，即dedent。

        在Python的语法中，indent和dedent的个数必须配对，发生过几回indent，就要发生几回dedent，否则就会有语法错误。

        tok->pendin这个变量，并不在词法分析时起做用，而是语法解析器调用词法解析器的PyTokenizer_Get(…)接口时，发生做用。

 

7.         发生了dedent

        下面就是col比tok->indstack栈顶元素小的状况，即发生了dedent：

1256:        else {  1258:                 while (tok->indent > 0 && 
1259:                           col < tok->indstack[tok->indent]) { 
1260:                           tok->pendin--; 
1261:                           tok->indent--;  1262:                 } 
1263:                 if (col != tok->indstack[tok->indent]) { 
1264:                           tok->done = E_DEDENT; 
1265:                           tok->cur = tok->inp; 
1266:                           return ERRORTOKEN; 
1267:                 }  1272         }

 

首先，在1258-1262行，将缩进栈中比col大的元素Pop出来，Pop多少元素，就表明发生了几回dedent，经过tok->pendin--，来记录发生了几回dedent。

        在1263行，Pop出比col大的元素后，此时的col必须和缩进栈顶部的元素必须相同，不然就会报错！这里能够解释本文最开始提出的问题：

 

1.      if a > 5 :  
2.                       a = 10  
3.               print “here”

刚开始，tok->indstack缩进栈初始化时只有1项元素0，能够记为　[ 0 ]；

当词法解析器处理第1行时，没有任何空格和Tab，col的值为0，和tok->indstack的栈顶元素相同，说明没有发生任何缩进。

词法解析器处理第2行时，有2个Tab，按照以前Tab转换成空格的算法，col的值为16，那么发生一次indent，并将当前缩进量Push进tok->indstack内，即当前的tok->indstack能够记为[ 0, 16 ]；

在第3行，有1个Tab，按照以前的算法，col的值为8，比tok->indstack栈顶元素要小，那么就将比col大的元素都Pop出来，此时tok->indstack能够表示为　[ 0 ]；

 可是此时tok->indstack栈顶的元素0，和col的值8不相同，Python词法解析器就会报错！

 

总结：每次缩进indent，Python并不要求使用多少个空格和Tab，只要比上一行的缩进量大就算一次缩进；每次dedent，却须要和以前某次indent的量匹配！

 

8.         语法中的缩进处理

        Python的缩进分在词法分析器和语法分析器2个地方处理，上面所述的都是词法分析器的内容。下面是涉及到语法分析器的地方。

        Python的语法分析器的代码能够用如下伪码来描述：

1:      while(true) {  
2:               token = PyTokenizer_Get();  
3:               do_something( token );  
4:      }

 

语法解析器每次从词法解析器中获取一个词，Token。（经过PyTokenizer_Get调用）。

每获取一个Token，语法分析器就往前分析一步，一直到全部Token都处理完成。

Python全部的语法规则，都在Grammar/Grammar这个文件中，其中涉及到indent和dedent的，只有一处：

suite:simple_stmt | NEWLINE INDENT stmt+ DEDENT

   而suite，叫作block也许更好理解些，用在：if，for，while，def，class，try-except-finally这些语句中，简易列出以下：

if test : suite
for exprlist in testlist : suite
while test : suite
def Name() : suite
class Name : suite
try : suite 
except : suite
finally : suite

这里，只须要注意：INDENT和DEDENT必须是配对出现的！而且只能出如今以上这些语句中！

那么，以前的这个例子出错的缘由就能够解释了：

1.      if a > 5 :  
2.               a = 10  
3.                        b = 5

 

在第2行，由于是if语句的刚开始处，因此此时的缩进是合法的。

可是在第3行，并无语法规定此时能够缩进，因此此处的缩进是不合法的！语法分析器会报错！

 

9.         tok->pendin

        此时再来看语法解析器，伪码以下：

1:      while(true) {  
2:               token = PyTokenizer_Get();  
3:               do_something( token );  
4:      }

对于下面这个例子：

1:      if a > 10:  
2:               if b > 10:  
3:                        a = 5;  
4:      print “here”

 

语法解析器每次调用PyTokenizer_Get()，获取下一个Token，

在第2行，发生了1次缩进，PyTokenizer_Get()会返回一个INDENT，

 在第3行，比第2行又缩进了1次，PyTokenizer_Get()又会返回一个INDENT，

到了第4行，须要2个DEDENT才能和以前的2个INDENT配对！也就是说，语法解析器调用PyTokenizer_Get()，连续2次调用都返回DEDENT才行。

 

        继续看Parser/Tokenizer.c中的tok_get(…)函数代码：

1279：     if (tok->pendin != 0) {  
1280：              if (tok->pendin < 0) {  
1281：                       tok->pendin++;  
1282：                       return DEDENT;  
1283：              }  
1284：              else {  
1285：                       tok->pendin--;  
1286：                       return INDENT;  
1287：              }  
1288：     }

 

通过以前的代码，tok->pendin若是为0，说明本行没有发生过缩进，tok_get(…)就不会返回INDENT或者DEDENT；

1280行，若是tok->pendin < 0，说明发生过左缩进，即dedent，那么tok_get(…)就返回DEDENT，而且tok->pendin++；

1284行，若是tok->pendin > 0，说明发生过右缩进，即indent，那么tok_get(…)就返回INDENT，而且tok->pendin--;

 

再看以前的例子：

1:      if a > 10:  
2:               if b > 10:  
3:                        a = 5;  
4:      print “here”

 

 

在第2行，发生了一次indent，tok->pendin的值为1，此时tok->pendin > 0，就会执行tok->pendin--，并返回INDENT，tok->pendin的值恢复为0；

在第3行，又发生了一次indent，tok->pendin的值为1，此时tok->pendin > 0，又会tok->pendin--，并返回INDENT，tok->pendin的值恢复为0；

在第4行，发生了2次dedent，tok->pendin的值为-2，此时tok->pendin < 0，就会tok->pendin++，并返回DEDENT，tok->pendin的值为-1

语法解析器再次调用PyTokenizer_Get(…)时，此时tok->pendin == -1，（而且此时tok->atbol != 0），判断tok->pendin < 0，又会tok->pendin++，并返回DEDENT，此时的tok->pendin的值才恢复成0。

 

 这就是tok->pendin的做用。

 

 到此，关于Python缩进的分析就完成了。