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

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

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

или же

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

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

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

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

if (a == True and
    b == False):

или с явным разрывом строки:

if a == True and \
   b == False:

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

Используя круглые скобки, ваш пример может быть записан в несколько строк:

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

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

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

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

From the horse's mouth: Explicit line joining

Two or more physical lines may be joined into logical lines using backslash characters (\), as follows: when a physical line ends in a backslash that is not part of a string literal or comment, it is joined with the following forming a single logical line, deleting the backslash and the following end-of-line character. For example:

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

A line ending in a backslash cannot carry a comment. A backslash does not continue a comment. A backslash does not continue a token except for string literals (i.e., tokens other than string literals cannot be split across physical lines using a backslash). A backslash is illegal elsewhere on a line outside a string literal.

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

The preferred way of wrapping long lines is by using Python's implied line continuation inside parentheses, brackets and braces. Long lines can be broken over multiple lines by wrapping expressions in parentheses. These should be used in preference to using a backslash for line continuation.

Backslashes may still be appropriate at times. For example, long, multiple with-statements cannot use implicit continuation, so backslashes are acceptable:

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

Another such case is with assert statements.

Make sure to indent the continued line appropriately. The preferred place to break around a binary operator is after the operator, not before it. Some examples:

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: Должна ли строка разрываться до или после бинарного оператора?:

Donald Knuth explains the traditional rule in his Computers and Typesetting series: "Although formulas within a paragraph always break after binary operations and relations, displayed formulas always break before binary operations"[3].

Following the tradition from mathematics usually results in more readable code:

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

In Python code, it is permissible to break before or after a binary operator, as long as the convention is consistent locally. For new code Knuth's style is suggested.

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

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

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

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

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

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

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

Взято из Автостопом по Python (Продолжение линии):

When a logical line of code is longer than the accepted limit, you need to split it over multiple physical lines. The Python interpreter will join consecutive lines if the last character of the line is a backslash. This is helpful in some cases, but should usually be avoided because of its fragility: a white space added to the end of the line, after the backslash, will break the code and may have unexpected results.

A better solution is to use parentheses around your elements. Left with an unclosed parenthesis on an end-of-line the Python interpreter will join the next line until the parentheses are closed. The same behaviour holds for curly and square braces.

However, more often than not, having to split a long logical line is a sign that you are trying to do too many things at the same time, which may hinder readability.

При этом, вот пример, рассматривающий множественный импорт (при превышении ограничения линии, определенные на 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}"
)

Также можно разбить вызов методов (obj.method()) на несколько строк.

Заключите команду в скобки «()» и растяните на несколько строк:

> res = (some_object
         .apply(args)
         .filter()
         .values)

Например, я считаю полезным вызывать методы объектов Pandas / Holoviews по цепочке.