Як я можу зробити розрив рядка (продовження рядка) в 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 Code :

Кращим способом загортання довгих рядків є використання мається на увазі продовження Python у дужках, дужках та дужках. Довгі рядки можна розбити на кілька рядків, загортаючи вирази в дужки. Їх слід використовувати на користь використання зворотної косої риски для продовження рядка.

Іноді підводка може бути доречною. Наприклад, довгі множинні оператори не можуть використовувати неявне продовження, тому зворотні косої риси є прийнятними:

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

Рядок, що закінчується косою рисою, не може містити коментарів. Зворотний нахил не продовжує коментар. Похила косої риси не продовжує маркер, за винятком рядкових літералів (тобто маркери, відмінні від рядкових літералів, не можуть бути розділені на фізичні лінії за допомогою зворотної косої риси). Зворотна косої риси є незаконною в іншому місці на лінії, що знаходиться поза рядковим літералом.

Це може бути не пітонічним способом, але я, як правило, використовую список з функцією приєднання для написання довгих рядків, як 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