Kann eine Zeile Python-Code die Verschachtelungsebene für Einrückungen kennen?

Von so etwas:

print(get_indentation_level())

    print(get_indentation_level())

        print(get_indentation_level())

Ich möchte so etwas bekommen:

1
2
3

Kann sich der Code auf diese Weise selbst lesen?

Ich möchte nur, dass die Ausgabe der stärker verschachtelten Teile des Codes stärker verschachtelt ist. Auf die gleiche Weise, wie dies das Lesen von Code erleichtert, würde dies das Lesen der Ausgabe erleichtern.

Natürlich könnte ich dies manuell implementieren, z. B. .format(), aber ich hatte eine benutzerdefinierte Druckfunktion im Sinn, print(i*' ' + string)bei der idie Einrückungsstufe angegeben wird. Dies wäre eine schnelle Möglichkeit, eine lesbare Ausgabe auf meinem Terminal zu erstellen.

Gibt es einen besseren Weg, um mühsame manuelle Formatierungen zu vermeiden?

Wenn Sie Einrückungen in Bezug auf die Verschachtelungsebene anstelle von Leerzeichen und Tabulatoren wünschen, wird es schwierig. Zum Beispiel im folgenden Code:

if True:
    print(
get_nesting_level())

Der Aufruf von get_nesting_levelist tatsächlich eine Ebene tief verschachtelt, obwohl in der Zeile des get_nesting_levelAnrufs kein führendes Leerzeichen vorhanden ist . Inzwischen im folgenden Code:

print(1,
      2,
      get_nesting_level())

Der Aufruf von get_nesting_levelist trotz des Vorhandenseins führender Leerzeichen in seiner Zeile null Ebenen tief verschachtelt.

Im folgenden Code:

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

if True:
    print(get_nesting_level())

Die beiden Aufrufe von get_nesting_levelbefinden sich auf unterschiedlichen Verschachtelungsebenen, obwohl das führende Leerzeichen identisch ist.

Im folgenden Code:

if True: print(get_nesting_level())

Ist das verschachtelte Null-Ebenen oder Eins? In Bezug auf INDENTund DEDENTToken in der formalen Grammatik ist es null Stufen tief, aber Sie fühlen sich möglicherweise nicht so.

Wenn Sie dies tun möchten, müssen Sie die gesamte Datei bis zum Zeitpunkt des Aufrufs tokenisieren und zählen INDENTund DEDENTtoken. Das tokenizeModul wäre für eine solche Funktion sehr nützlich:

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

Ja, das ist definitiv möglich, hier ist ein funktionierendes Beispiel:

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

Sie können verwenden sys.current_frame.f_lineno, um die Zeilennummer zu erhalten. Um die Anzahl der Einrückungsstufen zu ermitteln, müssen Sie die vorherige Zeile mit der Einrückung Null suchen und dann die aktuelle Zeilennummer von der Nummer dieser Zeile abziehen. Sie erhalten die Anzahl der Einrückungen:

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

Wenn Sie die Nummer der Einrückungsstufe basierend auf den vorherigen Zeilen mit möchten :, können Sie dies einfach mit einer kleinen Änderung tun:

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

Als alternative Antwort gibt es hier eine Funktion zum Abrufen der Anzahl der Einrückungen (Leerzeichen):

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

Um das "echte" Problem zu lösen, das zu Ihrer Frage führt, können Sie einen Kontextmanager implementieren, der die Einrückungsstufe verfolgt und die withBlockstruktur im Code den Einrückungsstufen der Ausgabe entspricht. Auf diese Weise spiegelt der Codeeinzug immer noch den Ausgabeeinzug wider, ohne beide zu stark zu koppeln. Es ist weiterhin möglich, den Code in verschiedene Funktionen umzugestalten und andere Einrückungen basierend auf der Codestruktur zu verwenden, die nicht mit der Ausgabeeinrückung in Konflikt geraten.

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

Ausgabe:

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.