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


1076

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

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

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

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

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

Ответы:


1212

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

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

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


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

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

15
Ключевая часть цитаты из руководства по стилю гласит: «При необходимости вы можете добавить дополнительную пару скобок вокруг выражения, но иногда использование обратной косой черты выглядит лучше». Руководство по стилю не говорит, что вы должны добавить скобки, оно оставляет его на усмотрение автора.
Тони Мейер

23
Предположительно, PEP-8 изменился с тех пор, как были добавлены эти комментарии, так как теперь совершенно очевидно, что для переноса длинных строк необходимо добавить скобки: «Длинные строки можно разбить на несколько строк, заключив выражения в скобки».
Даниэль

46
PEP8 действительно изменился в 2010 году - «иногда использование обратной косой черты выглядит лучше».
e100

230

Из 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


3
Обратите внимание, что рекомендация изменилась в 2010 году: «Длинные строки можно разбить ..., заключив выражения в скобки. Их следует использовать вместо использования обратной косой черты ...», и все обратные косые черты были удалены из примера кода.
e100

1
@ e100: прочитайте текст, выделенный жирным шрифтом выше: The preferred way .. is by using Python's implied line continuation inside parenthesesэто то же самое, что и by wrapping expressions in parentheses. Я обновил пример
JFS

10
Но обратите внимание, что «иногда использование обратной косой черты выглядит лучше» также ушло.
e100


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

70

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

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


8
Это одна из причин, по которой приятно видеть конечные пробелы лучше; то есть что-то вроде set list listchars=trail:·в vim. :)
Бо

25

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

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

или

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

24

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

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

20

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

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

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

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


7
-1 потому что пример ИМО однотипный. Сложные условные выражения могут иметь вместо этого заключающие в скобки, что является более практичным (для редактирования или автоматической перемотки) и идиоматическим.
u0b34a0f6ae

4

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

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

2

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

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

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

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

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

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

1

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

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

0

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

Примеры:

# 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
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.