Como posso fazer uma quebra de linha (continuação de linha) em Python?

Eu tenho uma longa linha de código que quero dividir entre várias linhas. O que eu uso e qual é a sintaxe?

Por exemplo, adicionando um monte de strings,

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

e tê-lo em duas linhas como esta:

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

Qual é a linha? Você pode apenas ter argumentos na próxima linha sem problemas:

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

Caso contrário, você pode fazer algo assim:

if a == True and \
   b == False

Consulte o guia de estilo para obter mais informações.

Na sua linha de exemplo:

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

Ou:

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

Observe que o guia de estilo diz que é preferível usar a continuação implícita entre parênteses, mas nesse caso específico, apenas adicionar parênteses em torno de sua expressão é provavelmente o caminho errado.

Do PEP 8 - Guia de Estilo para Código Python :

A maneira preferida de quebrar linhas longas é usando a continuação implícita de linhas do Python entre parênteses, colchetes e chaves. As linhas longas podem ser divididas em várias linhas envolvendo expressões entre parênteses. Eles devem ser usados ​​preferencialmente ao usar uma barra invertida para a continuação da linha.

As barras invertidas ainda podem ser apropriadas às vezes. Por exemplo, várias declarações with longas não podem usar continuação implícita; portanto, as barras invertidas são aceitáveis:

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

Outro caso é com declarações de afirmação.

Certifique-se de recuar a linha continuada adequadamente. O local preferido para contornar um operador binário é depois do operador, não antes dele. Alguns exemplos:

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)

O PEP8 agora recomenda a convenção oposta (para quebrar em operações binárias) usada pelos matemáticos e seus editores para melhorar a legibilidade.

O estilo de Donald Knuth de quebrar antes de um operador binário alinha os operadores verticalmente, reduzindo assim a carga de trabalho do olho ao determinar quais itens são adicionados e subtraídos.

Do PEP8: uma linha deve quebrar antes ou depois de um operador binário? :

Donald Knuth explica a regra tradicional em sua série Computers and Typesetting: "Embora as fórmulas dentro de um parágrafo sempre quebrem após operações e relações binárias, as fórmulas exibidas sempre quebram antes de operações binárias" [3].

Seguir a tradição da matemática geralmente resulta em código mais legível:

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

No código Python, é permitido quebrar antes ou depois de um operador binário, desde que a convenção seja consistente localmente. Para o novo código, sugere-se o estilo de Knuth.

[3]: The TeXBook, de Donald Knuth, páginas 195 e 196

O perigo de usar uma barra invertida para finalizar uma linha é que, se um espaço em branco for adicionado após a barra invertida (o que, é claro, é muito difícil de ver), a barra invertida não estará mais fazendo o que você pensava.

Consulte Expressões idiomáticas e anti-expressões do Python (para Python 2 ou Python 3 ) para obter mais.

Coloque um \no final da sua linha ou coloque a declaração em parênteses ( .. ). Da IBM :

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

ou

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

Você pode quebrar linhas entre parênteses e chaves. Além disso, você pode anexar o caractere de barra invertida \a uma linha para quebrá-lo explicitamente:

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

Da boca do cavalo: união explícita de linhas

Duas ou mais linhas físicas podem ser unidas em linhas lógicas usando caracteres de barra invertida ( \), da seguinte maneira: quando uma linha física termina em uma barra invertida que não faz parte de um literal ou comentário de string, ela é unida ao seguinte, formando uma única linha lógica , excluindo a barra invertida e o seguinte caractere de final de linha. Por exemplo:

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

Uma linha que termina em uma barra invertida não pode carregar um comentário. Uma barra invertida não continua um comentário. Uma barra invertida não continua um token, exceto os literais de string (ou seja, tokens que não sejam literais de string não podem ser divididos em linhas físicas usando uma barra invertida). Uma barra invertida é ilegal em outro lugar em uma linha fora de uma cadeia de caracteres literal.

Pode não ser o caminho Pythonic, mas geralmente uso uma lista com a função join para escrever uma cadeia longa, como consultas SQL:

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

Retirado do Guia do Mochileiro das Trevas ( continuação de linha ):

Quando uma linha lógica de código é maior que o limite aceito, é necessário dividi-la em várias linhas físicas. O intérprete Python juntará linhas consecutivas se o último caractere da linha for uma barra invertida. Isso é útil em alguns casos, mas geralmente deve ser evitado devido à sua fragilidade: um espaço em branco adicionado ao final da linha, após a barra invertida, quebrará o código e poderá ter resultados inesperados.

Uma solução melhor é usar parênteses em torno de seus elementos. Deixado com um parêntese não fechado em um final de linha, o interpretador Python se unirá à próxima linha até que os parênteses sejam fechados. O mesmo comportamento se aplica a chaves curvas e quadradas.

No entanto , na maioria das vezes, ter que dividir uma longa linha lógica é um sinal de que você está tentando fazer muitas coisas ao mesmo tempo, o que pode dificultar a legibilidade.

Dito isto, aqui está um exemplo considerando várias importações (quando exceder os limites de linha, definidos no PEP-8 ), também aplicados a cadeias de caracteres em geral:

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

Se você deseja quebrar sua linha por causa de uma longa cadeia literal, pode quebrá-la em pedaços:

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

será substituído por

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

Saída para ambas as instruções de impressão:

a very long string

Observe os parênteses na afetação.

Observe também que dividir cadeias literais em pedaços permite usar o prefixo literal apenas em partes da cadeia:

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

Use o operador de continuação de linha, ou seja, "\"

Exemplos:

# 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