Правильный отступ для многострочных строк 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)

Завершающий конец \в литерале сообщения журнала должен гарантировать, что разрыв строки не находится в литерале; таким образом, литерал не начинается с пустой строки, а начинается со следующей полной строки.

Возвращаемое значение from 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 dedent уже находится в пространстве имен. Я проверил, и это из Matplotlib. Или это может быть импортировано с:

from matplotlib.cbook import dedent

В документации говорится, что она быстрее, чем эквивалентная textwrap, и в моих тестах на 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 dedent в этих трех примерах даст тот же разумный результат. Функция dedent textwrap будет иметь начальную пустую строку в первом примере.

Очевидным недостатком является то, что textwrap находится в стандартной библиотеке, а matplotlib - внешний модуль.

Некоторые компромиссы здесь ... функции dedent делают ваш код более читабельным, когда определяются строки, но требуют обработки позже, чтобы получить строку в пригодном для использования формате. В строках документации очевидно, что вы должны использовать правильный отступ, так как большинство использований строки документации выполнят требуемую обработку.

Когда мне нужна недлинная строка в моем коде, я нахожу следующий заведомо уродливый код, где я позволяю длинной строке выпасть из вмещающего отступа. Определенно терпит неудачу на «Красивое лучше, чем некрасивое.», Но можно утверждать, что это проще и более явно, чем альтернатива dedent.

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

И вам не нужно удалять первый символ, если вы хотите, чтобы строки документации выглядели так:

    """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
"""