Оберните длинные строки в Python

Ответ 1

def fun():
    print(('{0} Here is a really long '
           'sentence with {1}').format(3, 5))

Смежные строковые литералы объединяются во время компиляции, так же как в C. http://docs.python.org/reference/lexical_analysis.html#string-literal-concatenation - хорошее место для получения дополнительной информации.

Ответ 2

Существует два подхода, которые не упомянуты выше, но оба из которых решают проблему таким образом, который соответствует PEP 8 и позволяет вам чтобы лучше использовать ваше пространство. Это:

msg = (
    'This message is so long, that it requires '
    'more than {x} lines.{sep}'
    'and you may want to add more.').format(
        x=x, sep=2*'\n')
print(msg)

Обратите внимание, как используются круглые скобки, чтобы мы не добавляли знаки плюс между чистыми строками и распространяли результат на несколько строк без необходимости явного продолжения строки '\' (уродливые и загроможденные). Преимущества одинаковы с тем, что описано ниже, разница в том, что вы можете сделать это в любом месте. По сравнению с предыдущей альтернативой визуально лучше проверять код, поскольку он четко и четко определяет начало и конец msg (сравните с msg += по одной строке, что требует еще одного шага мышления, чтобы вывести, что эти строки добавляют к та же строка - и что, если вы делаете опечатку, забывая + на одной случайной строке?).

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

Ближайшая альтернатива:

msg = 'This message is so long, that it requires '
msg += 'many lines to write, one reason for that\n'
msg += 'is that it contains numbers, like this '
msg += 'one: ' + str(x) +', which take up more space\n'
msg += 'to insert. Note how newlines are also included '
msg += 'and can be better presented in the code itself.'
print(msg)

Хотя предпочтительным является первое.

Другой подход похож на предыдущий, хотя он запускает сообщение в строке ниже print. Причина этого заключается в том, чтобы получить пространство слева, иначе print( сам "подталкивает" вас вправо. Это потребление отступов является унаследованным остальными линиями, содержащими сообщение, потому что согласно PEP 8 они должны совпадать с открывающей скобкой print над ними. Поэтому, если ваше сообщение было уже длинным, таким образом он был вынужден распространяться по еще большему количеству строк.

Контрастность:

raise TypeError('aaaaaaaaaaaaaaaa' +
                'aaaaaaaaaaaaaaaa' +
                'aaaaaaaaaaaaaaaa')

с этим (предлагается здесь):

raise TypeError(
    'aaaaaaaaaaaaaaaaaaaaaaaa' +
    'aaaaaaaaaaaaaaaaaaaaaaaa')

Распространение линии было уменьшено. Конечно, этот последний подход не применим так много к print, потому что это короткий вызов. Но это относится и к исключениям.

Возможна вариация:

raise TypeError((
    'aaaaaaaaaaaaaaaaaaaaaaaa'
    'aaaaaaaaaaaaaaaaaaaaaaaa'
    'aaaaa {x} aaaaa').format(x=x))

Обратите внимание, что вам не нужно иметь знаки плюса между чистыми строками. Кроме того, вдавливание направляет глаза читателя, без каких-либо бродячих скобок, висящих ниже слева. Замены очень читаемы. В частности, такой подход делает написанный код, который генерирует код или математические формулы, очень приятная задача.

Ответ 3

Вы можете использовать следующий код, где отступы не имеют значения:

>>> def fun():
        return ('{0} Here is a really long'
        ' sentence with {1}').format(3, 5)

Вам просто нужно заключить строку в круглые скобки.

Ответ 4

Вы можете использовать тот факт, что Python объединяет строковые литералы, которые отображаются рядом друг с другом:

>>> def fun():
...     print '{0} Here is a really long ' \
...           'sentence with {1}'.format(3, 5)

Ответ 5

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

>>> def fun():
...     format_string = '{0} Here is a really long ' \
...                     'sentence with {1}'
...     print format_string.format(3, 5)

Если строка слишком длинная, и вы выбираете короткое имя переменной, то при этом вы даже можете не разделить строку:

>>> def fun():
...     s = '{0} Here is a really long sentence with {1}'
...     print s.format(3, 5)

Ответ 6

Я удивлен, что никто не упомянул неявный стиль выше. Я предпочитаю использовать парены, чтобы обернуть строку, выравнивая строку визуально. Лично я думаю, что это выглядит чище и компактнее, чем начало строки в новой строке с вкладками.

Обратите внимание, что эти имена не являются частью вызова метода - они являются только конкатенацией неявных строковых литералов.

Python 2:

def fun():
    print ('{0} Here is a really '
           'long sentence with {1}').format(3, 5)

Python 3 (с паренями для функции печати):

def fun():
    print(('{0} Here is a really '
           'long sentence with {1}').format(3, 5))

Лично я считаю, что лучше всего отделить конкатенацию длинного строкового литерала от его печати:

def fun():
    s = ('{0} Here is a really '
         'long sentence with {1}').format(3, 5)
    print(s)

Ответ 7

Если это для длинной строки (например, для SQL-запроса), используйте тройной код

'''
hello
this 
is me 
'''