Правильний відступ для багаторядкових рядків Python

Яке правильне відступ для багаторядкових рядків Python у функції?

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

або

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

чи щось інше?

Дивно виглядає, що в першому прикладі рядок висить за межами функції.

Ви, мабуть, хочете вирівнятися з """

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

Оскільки нові рядки та пробіли включені в сам рядок, вам доведеться його обробити. Якщо ви цього не хочете робити, і у вас є багато тексту, можливо, ви хочете його окремо зберігати у текстовому файлі. Якщо текстовий файл не працює добре для вашої програми, і ви не хочете післяобробляти, я, ймовірно, пітиму з

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

Якщо ви хочете післяобробити багаторядковий рядок, щоб обрізати деталі, які вам не потрібні, вам слід розглянути textwrapмодуль або техніку для післяобробки документації, представленої в 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)

textwrap.dedentФункція дозволяє почати з правильним відступом в джерелі , а потім позбавити його з тексту перед використанням.

Як відзначають деякі інші, компроміс полягає в тому, що це додатковий виклик функції в буквальному сенсі; враховуйте це, вирішуючи, де розмістити ці буквари у своєму коді.

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)

Трейлінг \у літеральному повідомленні журналу полягає у тому, щоб переривання рядків не було в прямому; таким чином, літерал не починається з порожнього рядка, а замість цього починається з наступного повного рядка.

Зворотним значенням textwrap.dedentє вхідна рядок із усіма загальними відступами провідного пробілу, видаленими у кожному рядку рядка. Отже, наведене вище log_messageзначення буде:

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

Використовуйте inspect.cleandocтак:

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

Відносний відступ збережеться, як очікувалося. Як коментується нижче, якщо ви хочете зберегти попередні порожні рядки, використовуйте textwrap.dedent. Однак це також зберігає перерву першого рядка.

Примітка . Доброю практикою є відступ логічних блоків коду під відповідним контекстом для уточнення структури. Наприклад, рядок, що належить до змінної string.

Один варіант, який, здається, відсутній в інших відповідях (лише згаданий глибоко в коментарі від naxa), є наступний:

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

Це дозволить належним чином вирівняти, приєднати рядки неявно, та все ж зберегти зсув рядків, що, як на мене, є однією з причин, чому я хотів би використати багаторядкові рядки.

Він не вимагає жодної післяобробки, але вам потрібно вручну додати місце \nв будь-якому даному місці, на якому потрібно завершити рядок. Або в рядку, або як окремий рядок після. Останню простіше скопіювати та вставити.

Ще кілька варіантів. У програмі Ipython із включеним pylab дедент вже знаходиться в просторі імен. Я перевірив, і це від matplotlib. Або його можна імпортувати за допомогою:

from matplotlib.cbook import dedent

У документації йдеться про те, що він швидший, ніж еквівалентний текстовому обгортанні, а в моїх тестах на ipython - це в середньому в 3 рази швидше з моїми швидкими тестами. Він також має перевагу тим, що він відкидає будь-які провідні порожні рядки, що дозволяє вам бути гнучкими в побудові рядка:

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

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

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

Використання Matplotlib на цих трьох прикладах дасть однаковий розумний результат. Функція виділення текстового обгортання матиме провідний порожній рядок із 1-м прикладом.

Очевидним недоліком є ​​те, що текстове обговорення знаходиться в стандартній бібліотеці, тоді як matplotlib є зовнішнім модулем.

Деякі компроміси тут ... присвячені функції роблять ваш код більш читабельним, коли рядки визначаються, але потребують опрацювання пізніше, щоб отримати рядок у використаному форматі. У документах очевидно, що ви повинні використовувати правильний відступ, оскільки більшість застосувань docstring виконають необхідну обробку.

Коли мені потрібен недовгий рядок у моєму коді, я знаходжу наступний негарно некрасивий код, у якому я дозволяю довгому рядку випасти із вкладеного відступу. Однозначно виходить з ладу "Красиве - це краще, ніж потворне". Але можна стверджувати, що воно простіше і явніше, ніж прихильна альтернатива.

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

Якщо ви хочете швидке та просте рішення та вбережете себе від введення нових рядків, замість цього ви можете вибрати список, наприклад:

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

я віддаю перевагу

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

або

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

Мої два копійки, уникнути кінця рядка, щоб отримати відступи:

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

Я прийшов сюди, шукаючи простий 1-вкладиш, щоб вилучити / виправити рівень ідентифікації доктрини для друку, не роблячи його виглядати неохайним , наприклад, змусивши його "висіти за межами функції" в сценарії.

Ось що я закінчив:

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

Очевидно, якщо ви маєте відступи з пробілами (наприклад, 4), а не клавішею вкладки, використовуйте щось подібне:

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

І вам не потрібно видаляти перший символ, якщо вам подобається, що ваші docstrings виглядають так:

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

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

Перший варіант хороший - з відступом. Це в стилі python - забезпечує читабельність коду.

Щоб правильно відобразити його:

print string.lstrip()

Це залежить від того, як ви бажаєте відобразити текст. Якщо ви хочете, щоб усе було вирівняно ліворуч, то або відформатуйте його, як у першому фрагменті, або повторіть рядки ліворуч, обрізаючи весь простір.

Для рядків ви можете відразу після обробки рядка. Для документації потрібно замість цього обробити функцію. Ось рішення для обох, які ще читаються.

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__

У мене є подібна проблема, код став дійсно нечитабельним за допомогою мультиліній, я вийшов із чимось подібним

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

так, на початку це може виглядати жахливо, але вбудований синтаксис був досить складним, і додавання чогось наприкінці (наприклад, '\ n "') не було рішенням

Ви можете використовувати цю функцію 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


"""))

Результат:

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