一行Python代码可以知道其缩进嵌套级别吗？

从这样的事情：

print(get_indentation_level())

    print(get_indentation_level())

        print(get_indentation_level())

我想得到这样的东西：

1
2
3

代码可以这样读取吗？

我想要的只是更多嵌套代码部分的输出。以使代码易于阅读的方式，使输出易于阅读。

当然，我可以使用eg手动实现此功能.format()，但是我想到的是自定义打印功能，该功能print(i*' ' + string)在哪里i是缩进级别。这将是使终端上的输出可读的一种快速方法。

有没有更好的方法可以避免麻烦的手动格式化？

如果您想缩进而不是使用空格和制表符来嵌套级别，那么事情就会变得棘手。例如，在以下代码中：

if True:
    print(
get_nesting_level())

get_nesting_level尽管实际上在行的行上没有前导空格，但对的调用实际上嵌套了一层深度get_nesting_level呼叫。同时，在以下代码中：

print(1,
      2,
      get_nesting_level())

致电 get_nesting_level尽管该行中存在领先的空格，对仍嵌套在零级深度。

在下面的代码中：

if True:
  if True:
    print(get_nesting_level())

if True:
    print(get_nesting_level())

两次致电 get_nesting_level尽管前导空白是相同的，但这处于不同的嵌套级别。

在下面的代码中：

if True: print(get_nesting_level())

是嵌套的零级，还是一级？在INDENT和DEDENT形式语法中标记，深度为零，但是您可能会感觉不一样。

如果要执行此操作，则必须标记整个文件，直到调用，计数INDENT和DEDENT标记为止。该tokenize模块对于此类功能非常有用：

import inspect
import tokenize

def get_nesting_level():
    caller_frame = inspect.currentframe().f_back
    filename, caller_lineno, _, _, _ = inspect.getframeinfo(caller_frame)
    with open(filename) as f:
        indentation_level = 0
        for token_record in tokenize.generate_tokens(f.readline):
            token_type, _, (token_lineno, _), _, _ = token_record
            if token_lineno > caller_lineno:
                break
            elif token_type == tokenize.INDENT:
                indentation_level += 1
            elif token_type == tokenize.DEDENT:
                indentation_level -= 1
        return indentation_level

是的，绝对有可能，这是一个可行的示例：

import inspect

def get_indentation_level():
    callerframerecord = inspect.stack()[1]
    frame = callerframerecord[0]
    info = inspect.getframeinfo(frame)
    cc = info.code_context[0]
    return len(cc) - len(cc.lstrip())

if 1:
    print get_indentation_level()
    if 1:
        print get_indentation_level()
        if 1:
            print get_indentation_level()

您可以使用sys.current_frame.f_lineno以获取行号。然后，为了找到压痕级别的数量，您需要找到压痕为零的前一行，然后从该行的数量中减去当前行号，您将获得压痕数量：

import sys
current_frame = sys._getframe(0)

def get_ind_num():
    with open(__file__) as f:
        lines = f.readlines()
    current_line_no = current_frame.f_lineno
    to_current = lines[:current_line_no]
    previous_zoro_ind = len(to_current) - next(i for i, line in enumerate(to_current[::-1]) if not line[0].isspace())
    return current_line_no - previous_zoro_ind

演示：

if True:
    print get_ind_num()
    if True:
        print(get_ind_num())
        if True:
            print(get_ind_num())
            if True: print(get_ind_num())
# Output
1
3
5
6

如果您想要基于先前行的缩进级别编号，:则只需稍作更改即可：

def get_ind_num():
    with open(__file__) as f:
        lines = f.readlines()

    current_line_no = current_frame.f_lineno
    to_current = lines[:current_line_no]
    previous_zoro_ind = len(to_current) - next(i for i, line in enumerate(to_current[::-1]) if not line[0].isspace())
    return sum(1 for line in lines[previous_zoro_ind-1:current_line_no] if line.strip().endswith(':'))

演示：

if True:
    print get_ind_num()
    if True:
        print(get_ind_num())
        if True:
            print(get_ind_num())
            if True: print(get_ind_num())
# Output
1
2
3
3

作为替代答案，这里是一个用于获取缩进数量（空格）的函数：

import sys
from itertools import takewhile
current_frame = sys._getframe(0)

def get_ind_num():
    with open(__file__) as f:
        lines = f.readlines()
    return sum(1 for _ in takewhile(str.isspace, lines[current_frame.f_lineno - 1]))

为了解决导致您提出问题的“实际”问题，您可以实现一个contextmanager，它可以跟踪缩进级别并使with代码中的块结构与输出的缩进级别相对应。这样，代码缩进仍然可以反映输出缩进，而不会造成过多的耦合。仍然可以将代码重构为不同的功能，并基于代码结构使用其他缩进，而不会干扰输出缩进。

#!/usr/bin/env python
# coding: utf8
from __future__ import absolute_import, division, print_function


class IndentedPrinter(object):

    def __init__(self, level=0, indent_with='  '):
        self.level = level
        self.indent_with = indent_with

    def __enter__(self):
        self.level += 1
        return self

    def __exit__(self, *_args):
        self.level -= 1

    def print(self, arg='', *args, **kwargs):
        print(self.indent_with * self.level + str(arg), *args, **kwargs)


def main():
    indented = IndentedPrinter()
    indented.print(indented.level)
    with indented:
        indented.print(indented.level)
        with indented:
            indented.print('Hallo', indented.level)
            with indented:
                indented.print(indented.level)
            indented.print('and back one level', indented.level)


if __name__ == '__main__':
    main()

输出：

0
  1
    Hallo 2
      3
    and back one level 2

>>> import inspect
>>> help(inspect.indentsize)
Help on function indentsize in module inspect:

indentsize(line)
    Return the indent size, in spaces, at the start of a line of text.