Una riga di codice Python può conoscere il suo livello di annidamento del rientro?

Da qualcosa del genere:

print(get_indentation_level())

    print(get_indentation_level())

        print(get_indentation_level())

Vorrei ottenere qualcosa del genere:

1
2
3

Il codice può leggere se stesso in questo modo?

Tutto quello che voglio è che l'output delle parti più nidificate del codice sia più nidificato. Allo stesso modo in cui ciò semplifica la lettura del codice, renderebbe più semplice la lettura dell'output.

Ovviamente potrei implementarlo manualmente, usando ad esempio .format(), ma quello che avevo in mente era una funzione di stampa personalizzata che sarebbe print(i*' ' + string)dove si itrova il livello di rientro. Questo sarebbe un modo rapido per rendere l'output leggibile sul mio terminale.

Esiste un modo migliore per farlo che eviti una scrupolosa formattazione manuale?

Se si desidera il rientro in termini di livello di annidamento anziché spazi e tabulazioni, le cose si complicano. Ad esempio, nel seguente codice:

if True:
    print(
get_nesting_level())

la chiamata a get_nesting_levelè effettivamente annidata di un livello in profondità, nonostante il fatto che non vi siano spazi bianchi iniziali sulla linea della get_nesting_levelchiamata. Nel frattempo, nel seguente codice:

print(1,
      2,
      get_nesting_level())

la chiamata a get_nesting_levelè annidata a zero livelli di profondità, nonostante la presenza di spazi bianchi iniziali sulla sua linea.

Nel seguente codice:

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

if True:
    print(get_nesting_level())

le due chiamate get_nesting_levelsono a livelli di nidificazione diversi, nonostante il fatto che lo spazio bianco iniziale sia identico.

Nel seguente codice:

if True: print(get_nesting_level())

sono zero livelli nidificati o uno? In termini di INDENTe DEDENTtoken nella grammatica formale, ha zero livelli di profondità, ma potresti non sentirti allo stesso modo.

Se vuoi farlo, dovrai tokenizzare l'intero file fino al punto della chiamata, contare INDENTe DEDENTtoken. Il tokenizemodulo sarebbe molto utile per tale funzione:

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

Sì, è sicuramente possibile, ecco un esempio funzionante:

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

È possibile utilizzare sys.current_frame.f_linenoper ottenere il numero di riga. Quindi, per trovare il numero del livello di rientro devi trovare la riga precedente con rientro zero quindi sottraendo il numero di riga corrente dal numero di quella riga otterrai il numero di rientro:

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 vuoi il numero del livello di rientro in base alle righe precedenti, :puoi semplicemente farlo con un piccolo cambiamento:

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 come risposta alternativa qui è una funzione per ottenere il numero di rientri (spazi bianchi):

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

Per risolvere il problema "reale" che porta alla tua domanda, potresti implementare un gestore di contesto che tenga traccia del livello di withrientro e faccia corrispondere la struttura a blocchi nel codice ai livelli di rientro dell'output. In questo modo il rientro del codice riflette ancora il rientro in uscita senza accoppiare entrambi troppo. È ancora possibile riformattare il codice in diverse funzioni e avere altri rientri basati sulla struttura del codice che non interferisce con il rientro di output.

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

Produzione:

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.