Một dòng mã Python có thể biết mức lồng nhau của nó không?

Từ một cái gì đó như thế này:

print(get_indentation_level())

    print(get_indentation_level())

        print(get_indentation_level())

Tôi muốn có được một cái gì đó như thế này:

1
2
3

Mã có thể tự đọc theo cách này?

Tất cả những gì tôi muốn là đầu ra từ các phần lồng nhau của mã được lồng nhiều hơn. Theo cùng một cách mà điều này làm cho mã dễ đọc hơn, nó sẽ làm cho đầu ra dễ đọc hơn.

Tất nhiên tôi có thể thực hiện điều này bằng tay, bằng cách sử dụng, ví dụ .format(), nhưng điều tôi có trong đầu là một chức năng in tùy chỉnh sẽ print(i*' ' + string)ở imức độ thụt lề. Đây sẽ là một cách nhanh chóng để làm cho đầu ra có thể đọc được trên thiết bị đầu cuối của tôi.

Có cách nào tốt hơn để làm điều này mà tránh định dạng thủ công không?

Nếu bạn muốn thụt lề về mức độ lồng nhau hơn là khoảng trắng và tab, mọi thứ trở nên khó khăn. Ví dụ: trong đoạn mã sau:

if True:
    print(
get_nesting_level())

cuộc gọi đến get_nesting_levelthực sự được lồng sâu một cấp, mặc dù thực tế là không có khoảng trắng hàng đầu trên dòng của get_nesting_levelcuộc gọi. Trong khi đó, trong đoạn mã sau:

print(1,
      2,
      get_nesting_level())

lời kêu gọi get_nesting_levelđược lồng vào các mức 0 sâu, bất chấp sự hiện diện của khoảng trắng hàng đầu trên đường dây của nó.

Trong đoạn mã sau:

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

if True:
    print(get_nesting_level())

hai lệnh gọi get_nesting_levelở các mức lồng nhau khác nhau, mặc dù thực tế là khoảng trắng hàng đầu giống hệt nhau.

Trong đoạn mã sau:

if True: print(get_nesting_level())

đó là mức không lồng nhau, hay một? Về mặt INDENTvà DEDENTmã thông báo trong ngữ pháp chính thức, nó không có cấp độ sâu, nhưng bạn có thể không cảm thấy như vậy.

Nếu bạn muốn làm điều này, bạn sẽ phải mã hóa toàn bộ tệp cho đến điểm của cuộc gọi và đếm INDENTvà DEDENTmã thông báo. Các tokenizemô-đun sẽ rất hữu ích cho một chức năng như vậy:

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

Vâng, điều đó chắc chắn có thể, đây là một ví dụ hoạt động:

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

Bạn có thể sử dụng sys.current_frame.f_linenođể có được số dòng. Sau đó, để tìm số cấp độ thụt đầu dòng, bạn cần tìm dòng trước đó với độ thụt bằng 0, sau đó trừ số dòng hiện tại khỏi số của dòng đó, bạn sẽ nhận được số lượng thụt dòng:

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

Bản giới thiệu:

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

Nếu bạn muốn số lượng mức thụt đầu dòng dựa trên các dòng previouse với :bạn chỉ có thể thực hiện với một chút thay đổi:

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

Bản giới thiệu:

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

Và như một câu trả lời thay thế ở đây là một chức năng để có được số lượng thụt đầu dòng (khoảng trắng):

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

Để giải quyết vấn đề của Real real mà dẫn đến câu hỏi của bạn, bạn có thể triển khai một trình quản lý ngữ cảnh theo dõi mức độ ấn định và làm cho withcấu trúc khối trong mã tương ứng với các mức thụt đầu ra. Bằng cách này, thụt mã vẫn phản ánh thụt đầu ra mà không khớp cả hai quá nhiều. Vẫn có thể cấu trúc lại mã thành các hàm khác nhau và có các vết lõm khác dựa trên cấu trúc mã không làm rối với thụt đầu ra.

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

Đầu ra:

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.