Lõm đúng cách cho chuỗi multiline Python

Sự thụt lề thích hợp cho các chuỗi multiline Python trong một hàm là gì?

    def method():
        string = """line one
line two
line three"""

hoặc là

    def method():
        string = """line one
        line two
        line three"""

hay cái gì khác?

Nó trông có vẻ kỳ lạ khi có chuỗi treo bên ngoài hàm trong ví dụ đầu tiên.

Bạn có thể muốn xếp hàng với """

def foo():
    string = """line one
             line two
             line three"""

Vì các dòng mới và khoảng trắng được bao gồm trong chính chuỗi, bạn sẽ phải xử lý nó. Nếu bạn không muốn làm điều đó và bạn có rất nhiều văn bản, bạn có thể muốn lưu trữ nó một cách riêng biệt trong một tệp văn bản. Nếu một tệp văn bản không hoạt động tốt cho ứng dụng của bạn và bạn không muốn xử lý hậu kỳ, có lẽ tôi sẽ đi cùng

def foo():
    string = ("this is an "
              "implicitly joined "
              "string")

Nếu bạn muốn xử lý một chuỗi nhiều dòng để cắt bớt các phần bạn không cần, bạn nên xem xét textwrapmô-đun hoặc kỹ thuật cho các tài liệu hậu xử lý được trình bày trong PEP 257 :

def trim(docstring):
    if not docstring:
        return ''
    # Convert tabs to spaces (following the normal Python rules)
    # and split into a list of lines:
    lines = docstring.expandtabs().splitlines()
    # Determine minimum indentation (first line doesn't count):
    indent = sys.maxint
    for line in lines[1:]:
        stripped = line.lstrip()
        if stripped:
            indent = min(indent, len(line) - len(stripped))
    # Remove indentation (first line is special):
    trimmed = [lines[0].strip()]
    if indent < sys.maxint:
        for line in lines[1:]:
            trimmed.append(line[indent:].rstrip())
    # Strip off trailing and leading blank lines:
    while trimmed and not trimmed[-1]:
        trimmed.pop()
    while trimmed and not trimmed[0]:
        trimmed.pop(0)
    # Return a single string:
    return '\n'.join(trimmed)

Các textwrap.dedentchức năng cho phép một để bắt đầu với thụt đầu dòng đúng trong nguồn , và sau đó tách nó từ các văn bản trước khi sử dụng.

Sự đánh đổi, như một số người khác lưu ý, là đây là một chức năng bổ sung gọi theo nghĩa đen; hãy tính đến điều này khi quyết định nơi đặt những chữ này trong mã của bạn.

import textwrap

def frobnicate(param):
    """ Frobnicate the scrognate param.

        The Weebly-Ruckford algorithm is employed to frobnicate
        the scrognate to within an inch of its life.

        """
    prepare_the_comfy_chair(param)
    log_message = textwrap.dedent("""\
            Prepare to frobnicate:
            Here it comes...
                Any moment now.
            And: Frobnicate!""")
    weebly(param, log_message)
    ruckford(param)

Việc theo dõi \trong thông điệp nhật ký bằng chữ là để đảm bảo rằng ngắt dòng không theo nghĩa đen; theo cách đó, nghĩa đen không bắt đầu bằng một dòng trống, và thay vào đó bắt đầu với dòng đầy đủ tiếp theo.

Giá trị trả về từ textwrap.dedentlà chuỗi đầu vào với tất cả các vết lõm khoảng trắng hàng đầu phổ biến được loại bỏ trên mỗi dòng của chuỗi. Vì vậy, log_messagegiá trị trên sẽ là:

Prepare to frobnicate:
Here it comes...
    Any moment now.
And: Frobnicate!

Sử dụng inspect.cleandocnhư vậy:

def method():
    string = inspect.cleandoc("""
        line one
        line two
        line three""")

Lõm tương đối sẽ được duy trì như mong đợi. Như đã nhận xét dưới đây, nếu bạn muốn giữ các dòng trống trước, hãy sử dụng textwrap.dedent. Tuy nhiên, điều đó cũng giữ cho dòng đầu tiên bị phá vỡ.

Lưu ý: Đó là cách thực hành tốt để thụt các khối mã logic trong ngữ cảnh liên quan của nó để làm rõ cấu trúc. Ví dụ: chuỗi nhiều dòng thuộc về biến string.

Một tùy chọn dường như bị thiếu trong các câu trả lời khác (chỉ được đề cập sâu trong một nhận xét của naxa) là:

def foo():
    string = ("line one\n"          # Add \n in the string
              "line two"  "\n"      # Add "\n" after the string
              "line three\n")

Điều này sẽ cho phép căn chỉnh phù hợp, tham gia các dòng hoàn toàn và vẫn giữ sự thay đổi dòng, mà đối với tôi, đó là một trong những lý do tại sao tôi muốn sử dụng chuỗi đa dòng.

Nó không yêu cầu bất kỳ quá trình hậu xử lý nào, nhưng bạn cần thêm thủ công \ntại bất kỳ địa điểm cụ thể nào mà bạn muốn dòng kết thúc. Hoặc là nội tuyến hoặc là một chuỗi riêng biệt sau. Cái sau dễ dàng hơn để sao chép-dán vào.

Một số tùy chọn khác. Trong Ipython với pylab được kích hoạt, cống hiến đã có trong không gian tên. Tôi đã kiểm tra và nó là từ matplotlib. Hoặc nó có thể được nhập với:

from matplotlib.cbook import dedent

Trong tài liệu có ghi rằng nó nhanh hơn so với textwrap tương đương và trong các thử nghiệm của tôi trong ipython, nó thực sự nhanh hơn trung bình 3 lần so với các thử nghiệm nhanh của tôi. Nó cũng có lợi ích là nó loại bỏ bất kỳ dòng trống hàng đầu nào, điều này cho phép bạn linh hoạt trong cách bạn xây dựng chuỗi:

"""
line 1 of string
line 2 of string
"""

"""\
line 1 of string
line 2 of string
"""

"""line 1 of string
line 2 of string
"""

Sử dụng suy luận matplotlib trên ba ví dụ này sẽ cho kết quả hợp lý như nhau. Hàm suy luận textwrap sẽ có một dòng trống hàng đầu với ví dụ thứ nhất.

Bất lợi rõ ràng là textwrap nằm trong thư viện tiêu chuẩn trong khi matplotlib là mô-đun bên ngoài.

Một số sự đánh đổi ở đây ... các hàm suy diễn làm cho mã của bạn dễ đọc hơn khi các chuỗi được xác định, nhưng yêu cầu xử lý sau để có được chuỗi ở định dạng có thể sử dụng được. Trong tài liệu, rõ ràng là bạn nên sử dụng thụt lề chính xác vì hầu hết việc sử dụng chuỗi doc sẽ thực hiện xử lý theo yêu cầu.

Khi tôi cần một chuỗi không dài trong mã của mình, tôi tìm thấy mã xấu được thừa nhận sau đây khi tôi để chuỗi dài thoát ra khỏi vết lõm kèm theo. Chắc chắn thất bại trong "Đẹp thì tốt hơn xấu.", Nhưng người ta có thể lập luận rằng nó đơn giản và rõ ràng hơn so với sự thay thế hoàn hảo.

def example():
    long_string = '''\
Lorem ipsum dolor sit amet, consectetur adipisicing
elit, sed do eiusmod tempor incididunt ut labore et
dolore magna aliqua. Ut enim ad minim veniam, quis
nostrud exercitation ullamco laboris nisi ut aliquip.\
'''
    return long_string

print example()

Nếu bạn muốn một giải pháp nhanh chóng và dễ dàng và tự cứu mình khỏi việc nhập các dòng mới, bạn có thể chọn một danh sách thay thế, ví dụ:

def func(*args, **kwargs):
    string = '\n'.join([
        'first line of very long string and',
        'second line of the same long thing and',
        'third line of ...',
        'and so on...',
        ])
    print(string)
    return

tôi thích

    def method():
        string = \
"""\
line one
line two
line three\
"""

hoặc là

    def method():
        string = """\
line one
line two
line three\
"""

Hai xu của tôi, thoát khỏi cuối dòng để có được các vết lõm:

def foo():
    return "{}\n"\
           "freq: {}\n"\
           "temp: {}\n".format( time, freq, temp )

Tôi đến đây để tìm kiếm một lớp lót đơn giản để loại bỏ / sửa mức độ nhận dạng của chuỗi doc để in, mà không làm cho nó trông không gọn gàng , ví dụ bằng cách làm cho nó "treo bên ngoài chức năng" trong tập lệnh.

Đây là những gì tôi đã làm:

import string
def myfunction():

    """
    line 1 of docstring
    line 2 of docstring
    line 3 of docstring"""

print str(string.replace(myfunction.__doc__,'\n\t','\n'))[1:] 

Rõ ràng, nếu bạn thụt lề bằng dấu cách (ví dụ 4) thay vì phím tab, hãy sử dụng cái gì đó như thế này:

print str(string.replace(myfunction.__doc__,'\n    ','\n'))[1:]

Và bạn không cần phải xóa ký tự đầu tiên nếu bạn muốn các tài liệu của mình trông giống như thế này:

    """line 1 of docstring
    line 2 of docstring
    line 3 of docstring"""

print string.replace(myfunction.__doc__,'\n\t','\n') 

Tùy chọn đầu tiên là lựa chọn tốt - bao gồm thụt đầu dòng. Đó là trong phong cách python - cung cấp khả năng đọc cho mã.

Để hiển thị đúng:

print string.lstrip()

Nó phụ thuộc vào cách bạn muốn văn bản hiển thị. Nếu bạn muốn tất cả được căn lề trái thì hãy định dạng nó như trong đoạn trích đầu tiên hoặc lặp qua các dòng bên trái - cắt xén tất cả khoảng trắng.

Đối với chuỗi bạn có thể chỉ sau khi xử lý chuỗi. Đối với tài liệu bạn cần sau khi xử lý chức năng thay thế. Đây là một giải pháp cho cả hai vẫn có thể đọc được.

class Lstrip(object):
    def __rsub__(self, other):
        import re
        return re.sub('^\n', '', re.sub('\n$', '', re.sub('\n\s+', '\n', other)))

msg = '''
      Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod
      tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim
      veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea
      commodo consequat. Duis aute irure dolor in reprehenderit in voluptate
      velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat
      cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id
      est laborum.
      ''' - Lstrip()

print msg

def lstrip_docstring(func):
    func.__doc__ = func.__doc__ - Lstrip()
    return func

@lstrip_docstring
def foo():
    '''
    Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod
    tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim
    veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea
    commodo consequat. Duis aute irure dolor in reprehenderit in voluptate
    velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat
    cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id
    est laborum.
    '''
    pass


print foo.__doc__

Tôi đang gặp vấn đề tương tự, mã thực sự không thể đọc được bằng cách sử dụng đa dòng, tôi đã đưa ra một cái gì đó như

print("""aaaa
"""   """bbb
""")

vâng, lúc đầu có thể trông khủng khiếp nhưng cú pháp nhúng khá phức tạp và việc thêm một cái gì đó ở cuối (như '\ n "') không phải là một giải pháp

Bạn có thể sử dụng chức năng này trim_indent .

import re


def trim_indent(s: str):
    s = re.sub(r'^\n+', '', s)
    s = re.sub(r'\n+$', '', s)
    spaces = re.findall(r'^ +', s, flags=re.MULTILINE)
    if len(spaces) > 0 and len(re.findall(r'^[^\s]', s, flags=re.MULTILINE)) == 0:
        s = re.sub(r'^%s' % (min(spaces)), '', s, flags=re.MULTILINE)
    return s


print(trim_indent("""


        line one
            line two
                line three
            line two
        line one


"""))

Kết quả:

"""
line one
    line two
        line three
    line two
line one
"""