Uma linha de código Python pode conhecer seu nível de aninhamento de indentação?

De algo assim:

print(get_indentation_level())

    print(get_indentation_level())

        print(get_indentation_level())

Eu gostaria de obter algo parecido com isto:

1
2
3

O código pode se ler dessa maneira?

Tudo o que eu quero é que a saída das partes mais aninhadas do código seja mais aninhada. Da mesma forma que isso facilita a leitura do código, a saída é mais fácil de ler.

É claro que eu poderia implementar isso manualmente, usando, por exemplo .format(), mas o que eu tinha em mente era uma função de impressão personalizada que seria print(i*' ' + string)onde iestá o nível de indentação. Essa seria uma maneira rápida de obter uma saída legível no meu terminal.

Existe uma maneira melhor de fazer isso que evite a formatação manual cuidadosa?

Se você deseja recuo em termos de nível de aninhamento, em vez de espaços e guias, as coisas ficam complicadas. Por exemplo, no seguinte código:

if True:
    print(
get_nesting_level())

a chamada para get_nesting_levelestá realmente aninhada em um nível, apesar do fato de que não há espaços em branco à esquerda na linha da get_nesting_levelchamada. Enquanto isso, no seguinte código:

print(1,
      2,
      get_nesting_level())

a chamada para get_nesting_levelestá aninhada com zero nível de profundidade, apesar da presença de espaços em branco à esquerda em sua linha.

No código a seguir:

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

if True:
    print(get_nesting_level())

as duas chamadas get_nesting_levelestão em diferentes níveis de aninhamento, apesar do espaço em branco inicial ser idêntico.

No código a seguir:

if True: print(get_nesting_level())

esses níveis zero aninhados ou um? Em termos INDENTe DEDENTtokens na gramática formal, os níveis são zero, mas você pode não se sentir da mesma maneira.

Se você quiser fazer isso, terá que tokenizar o arquivo inteiro até o ponto da chamada e contar INDENTe DEDENTtokens. O tokenizemódulo seria muito útil para essa função:

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

Sim, isso é definitivamente possível, aqui está um exemplo de trabalho:

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()

Você pode usar sys.current_frame.f_linenopara obter o número da linha. Então, para encontrar o número do nível de recuo, você precisa encontrar a linha anterior com recuo zero e, subtraindo o número da linha atual do número dessa linha, você obterá o número de recuo:

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

Demo:

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

Se você quiser o número do nível de indentação com base nas linhas anteriores, :basta fazê-lo com uma pequena alteração:

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(':'))

Demo:

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

E como resposta alternativa, aqui está uma função para obter o número de indentação (espaço em branco):

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]))

Para resolver o problema "real" que leva à sua pergunta, você pode implementar um gerenciador de contexto que monitora o nível de withindentação e faz com que a estrutura do bloco no código corresponda aos níveis de indentação da saída. Dessa forma, o recuo do código ainda reflete o recuo da saída sem acoplar muito os dois. Ainda é possível refatorar o código em diferentes funções e ter outros recuos baseados na estrutura do código que não interferem no recuo da saída.

#!/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()

Resultado:

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.