Czy wiersz kodu Pythona może znać poziom zagnieżdżenia wcięć?

Z czegoś takiego:

print(get_indentation_level())

    print(get_indentation_level())

        print(get_indentation_level())

Chciałbym dostać coś takiego:

1
2
3

Czy kod może się w ten sposób odczytać?

Chcę tylko, aby dane wyjściowe z bardziej zagnieżdżonych części kodu były bardziej zagnieżdżone. W ten sam sposób, w jaki ułatwia to odczytanie kodu, ułatwiłoby to odczytanie danych wyjściowych.

Oczywiście mogę zaimplementować to ręcznie, za pomocą np .format(), ale to, co miał na myśli, był zwyczaj Funkcja drukowania co print(i*' ' + string)gdzie ijest poziom wcięcia. Byłby to szybki sposób na uzyskanie czytelnego wyniku na moim terminalu.

Czy istnieje lepszy sposób na to, aby uniknąć żmudnego ręcznego formatowania?

Jeśli chcesz wcięcia pod względem poziomu zagnieżdżenia, a nie spacji i tabulatorów, sprawy stają się trudne. Na przykład w poniższym kodzie:

if True:
    print(
get_nesting_level())

wywołanie get_nesting_leveljest faktycznie zagnieżdżone o jeden poziom w głąb, pomimo faktu, że w wierszu get_nesting_levelwywołania nie ma wiodących białych znaków . Tymczasem w poniższym kodzie:

print(1,
      2,
      get_nesting_level())

wywołanie get_nesting_leveljest zagnieżdżone w głębi zera, pomimo obecności wiodących białych znaków w jego linii.

W poniższym kodzie:

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

if True:
    print(get_nesting_level())

te dwa wywołania get_nesting_levelznajdują się na różnych poziomach zagnieżdżenia, mimo że wiodące białe znaki są identyczne.

W poniższym kodzie:

if True: print(get_nesting_level())

czy to zagnieżdżone poziomy zerowe czy jeden? Jeśli chodzi o INDENTi DEDENTtokeny w gramatyce formalnej, jest to poziom zerowy, ale możesz nie czuć tego samego.

Jeśli chcesz to zrobić, będziesz musiał tokenizować cały plik do momentu wywołania, liczenia INDENTi DEDENTtokenów. tokenizeModuł byłby bardzo przydatny dla takiej funkcji:

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

Tak, to zdecydowanie możliwe, oto działający przykład:

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

Możesz użyć sys.current_frame.f_lineno, aby uzyskać numer linii. Następnie, aby znaleźć liczbę poziomów wcięć, musisz znaleźć poprzednią linię z zerowym wcięciem, a następnie odejmując bieżący numer linii od numeru tej linii, otrzymasz liczbę wcięć:

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

Próbny:

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

Jeśli chcesz, aby numer poziomu wcięcia był oparty na poprzednich wierszach :, możesz to zrobić z niewielką zmianą:

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

Próbny:

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

Alternatywną odpowiedzią jest tutaj funkcja obliczania liczby wcięć (białych znaków):

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

Aby rozwiązać „prawdziwy” problem, który doprowadził do twojego pytania, możesz zaimplementować menedżera kontekstu, który śledzi poziom withwcięć i sprawi, że struktura blokowa w kodzie będzie odpowiadać poziomom wcięć wyjścia. W ten sposób wcięcie kodu nadal odzwierciedla wcięcie wyjścia bez zbytniego łączenia obu. Nadal istnieje możliwość refaktoryzacji kodu na różne funkcje i inne wcięcia oparte na strukturze kodu, które nie zakłócają wcięcia wyjścia.

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

Wynik:

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.