Как я могу сделать разрыв строки (продолжение строки) в Python?

У меня есть длинная строка кода, которую я хочу разбить на несколько строк. Что я использую и каков синтаксис?

Например, добавив кучу строк,

e = 'a' + 'b' + 'c' + 'd'

и иметь его в две строки, как это:

e = 'a' + 'b' +
    'c' + 'd'

Какая линия? Вы можете просто иметь аргументы на следующей строке без проблем:

a = dostuff(blahblah1, blahblah2, blahblah3, blahblah4, blahblah5, 
            blahblah6, blahblah7)

В противном случае вы можете сделать что-то вроде этого:

if a == True and \
   b == False

Проверьте руководство по стилю для получения дополнительной информации.

Из вашей строки примера:

a = '1' + '2' + '3' + \
    '4' + '5'

Или:

a = ('1' + '2' + '3' +
    '4' + '5')

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

Из PEP 8 - Руководство по стилю для кода Python :

Предпочтительный способ переноса длинных строк - использование подразумеваемого продолжения строки в Python внутри скобок, скобок и скобок. Длинные строки можно разбить на несколько строк, заключив выражения в скобки. Их следует использовать вместо использования обратной косой черты для продолжения строки.

Обратные слеши могут все еще быть подходящими время от времени. Например, длинные, множественные операторы with не могут использовать неявное продолжение, поэтому допустимы обратные слеши:

with open('/path/to/some/file/you/want/to/read') as file_1, \
        open('/path/to/some/file/being/written', 'w') as file_2:
    file_2.write(file_1.read())

Еще один такой случай с утверждениями утверждения.

Удостоверьтесь, чтобы сделать отступ для продолжения строки соответствующим образом. Предпочтительное место для бинарного оператора - после оператора, а не перед ним. Некоторые примеры:

class Rectangle(Blob):

    def __init__(self, width, height,
                 color='black', emphasis=None, highlight=0):
        if (width == 0 and height == 0 and
                color == 'red' and emphasis == 'strong' or
                highlight > 100):
            raise ValueError("sorry, you lose")
        if width == 0 and height == 0 and (color == 'red' or
                                           emphasis is None):
            raise ValueError("I don't think so -- values are %s, %s" %
                             (width, height))
        Blob.__init__(self, width, height,
                      color, emphasis, highlight)

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

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

Из PEP8: должен ли разрыв строки идти до или после двоичного оператора? :

Дональд Кнут объясняет традиционное правило в своей серии «Компьютеры и набор текста»: «Хотя формулы внутри абзаца всегда ломаются после двоичных операций и отношений, отображаемые формулы всегда ломаются перед двоичными операциями» [3].

Следуя традиции математики, обычно получается более читаемый код:

# Yes: easy to match operators with operands
income = (gross_wages
          + taxable_interest
          + (dividends - qualified_dividends)
          - ira_deduction
          - student_loan_interest)

В коде Python допускается разрыв до или после двоичного оператора, если соглашение согласовано локально. Для нового кода предлагается стиль Кнута.

[3]: The TeXBook Дональда Кнута, страницы 195 и 196

Опасность в использовании обратной косой черты для завершения строки состоит в том, что если после обратной косой черты добавляется пробел (что, конечно, очень трудно увидеть), обратная косая черта больше не выполняет то, о чем вы думали.

Смотрите Python Idioms and Anti-Idioms (для Python 2 или Python 3 ) для получения дополнительной информации.

Поставьте \в конце своей строки или заключите заявление в скобки ( .. ). От IBM :

b = ((i1 < 20) and
     (i2 < 30) and
     (i3 < 40))

или

b = (i1 < 20) and \
    (i2 < 30) and \
    (i3 < 40)

Вы можете разбивать строки между скобками и скобками. Кроме того, вы можете добавить символ обратной косой черты \в строку, чтобы явно разбить его:

x = (tuples_first_value,
     second_value)
y = 1 + \
    2

Изо рта лошади: явное соединение линий

Две или более физических строки могут быть объединены в логические строки с помощью символов обратной косой черты ( \) следующим образом: когда физическая строка заканчивается обратной косой чертой, которая не является частью строкового литерала или комментария, она объединяется со следующими, образуя одну логическую строку , удаляя обратную косую черту и следующий символ конца строки. Например:

if 1900 < year < 2100 and 1 <= month <= 12 \
   and 1 <= day <= 31 and 0 <= hour < 24 \
   and 0 <= minute < 60 and 0 <= second < 60:   # Looks like a valid date
        return 1

Строка, заканчивающаяся обратной косой чертой, не может содержать комментарий. Обратная косая черта не продолжает комментарий. Обратная косая черта не продолжает токен, за исключением строковых литералов (т. Е. Токены, отличные от строковых литералов, не могут быть разбиты по физическим строкам с помощью обратной косой черты). Обратная косая черта недопустима в других местах строки вне строкового литерала.

Возможно, это не Pythonic, но я обычно использую список с функцией join для написания длинной строки, например SQL-запросов:

query = " ".join([
    'SELECT * FROM "TableName"',
    'WHERE "SomeColumn1"=VALUE',
    'ORDER BY "SomeColumn2"',
    'LIMIT 5;'
])

Взято из Руководства Автостопщика по Python ( продолжение строки ):

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

Лучшее решение - использовать круглые скобки вокруг ваших элементов. Оставленный с закрытой круглой скобкой в ​​конце строки, интерпретатор Python присоединится к следующей строке, пока круглые скобки не будут закрыты. То же самое относится и к фигурным и квадратным скобкам.

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

С учетом вышесказанного, вот пример, учитывающий множественный импорт (при превышении лимитов строк, определенных в PEP-8 ), также применяемый к строкам в целом:

from app import (
    app, abort, make_response, redirect, render_template, request, session
)

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

long_string = "a very long string"
print("a very long string")

будет заменен на

long_string = (
  "a "
  "very "
  "long "
  "string"
)
print(
  "a "
  "very "
  "long "
  "string"
)

Вывод для обоих операторов печати:

a very long string

Обратите внимание на круглые скобки в влиянии.

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

s = (
  "2+2="
  f"{2+2}"
)

Используйте оператор продолжения строки, т.е. "\"

Примеры:

# Ex.1

x = 1
s =  x + x**2/2 + x**3/3 \
       + x**4/4 + x**5/5 \
       + x**6/6 + x**7/7 \
       + x**8/8
print(s)
# 2.7178571428571425


----------


# Ex.2

text = ('Put several strings within parentheses ' \
        'to have them joined together.')
print(text)


----------


# Ex.3

x = 1
s =  x + x**2/2 \
       + x**3/3 \
       + x**4/4 \
       + x**6/6 \
       + x**8/8
print(s)
# 2.3749999999999996