¿Cómo puedo hacer un salto de línea (continuación de línea) en Python?

Tengo una larga línea de código que quiero dividir entre varias líneas. ¿Qué uso y cuál es la sintaxis?

Por ejemplo, agregando un montón de cadenas,

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

y tenerlo en dos líneas como esta:

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

Cual es la linea Puede tener argumentos en la siguiente línea sin ningún problema:

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

De lo contrario, puede hacer algo como esto:

if a == True and \
   b == False

Consulte la guía de estilo para obtener más información.

Desde su línea de ejemplo:

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

O:

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

Tenga en cuenta que la guía de estilo dice que se prefiere usar la continuación implícita con paréntesis, pero en este caso particular, simplemente agregar paréntesis alrededor de su expresión es probablemente el camino equivocado.

De PEP 8 - Guía de estilo para código Python :

La forma preferida de ajustar líneas largas es mediante el uso de la continuación de línea implícita de Python dentro de paréntesis, corchetes y llaves. Las líneas largas se pueden dividir en varias líneas ajustando las expresiones entre paréntesis. Deben usarse con preferencia al uso de una barra diagonal inversa para la continuación de la línea.

Las barras invertidas pueden ser apropiadas en ocasiones. Por ejemplo, las declaraciones con múltiples no pueden usar la continuación implícita, por lo que las barras invertidas son aceptables:

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

Otro caso de este tipo es con declaraciones de afirmación.

Asegúrese de sangrar la línea continua adecuadamente. El lugar preferido para romper alrededor de un operador binario es después del operador, no antes. Algunos ejemplos:

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 ahora recomienda la convención opuesta (para romper en operaciones binarias) utilizada por los matemáticos y sus editores para mejorar la legibilidad.

El estilo de ruptura de Donald Knuth antes de que un operador binario alinee a los operadores verticalmente, reduciendo así la carga de trabajo del ojo al determinar qué elementos se suman y restan.

De PEP8: ¿Debería una línea saltarse antes o después de un operador binario? :

Donald Knuth explica la regla tradicional en su serie Computadoras y composición tipográfica: "Aunque las fórmulas dentro de un párrafo siempre se rompen después de las operaciones y relaciones binarias, las fórmulas mostradas siempre se rompen antes de las operaciones binarias" [3].

Seguir la tradición de las matemáticas generalmente da como resultado un código más legible:

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

En el código Python, está permitido romper antes o después de un operador binario, siempre que la convención sea coherente localmente. Para el nuevo código se sugiere el estilo de Knuth.

[3]: El TeXBook de Donald Knuth, páginas 195 y 196

El peligro de usar una barra invertida para finalizar una línea es que si se agrega un espacio en blanco después de la barra invertida (que, por supuesto, es muy difícil de ver), la barra invertida ya no está haciendo lo que pensaba que era.

Vea Python Idioms and Anti-Idioms (para Python 2 o Python 3 ) para más información.

Ponga un \al final de su línea o incluya la declaración en parens ( .. ). De IBM :

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

o

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

Puede romper líneas entre paréntesis y llaves. Además, puede agregar el carácter de barra diagonal inversa \a una línea para dividirlo explícitamente:

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

De la boca del caballo: unión explícita de líneas

Dos o más líneas físicas pueden unirse en líneas lógicas utilizando caracteres de barra diagonal inversa ( \), de la siguiente manera: cuando una línea física termina en una barra diagonal inversa que no es parte de un literal de cadena o comentario, se une con lo siguiente formando una sola línea lógica , eliminando la barra diagonal inversa y el siguiente carácter de fin de línea. Por ejemplo:

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

Una línea que termina en una barra invertida no puede llevar un comentario. Una barra invertida no continúa un comentario. Una barra invertida no continúa un token, excepto los literales de cadena (es decir, los tokens que no sean literales de cadena no se pueden dividir en líneas físicas usando una barra invertida). Una barra invertida es ilegal en otra parte de una línea fuera de un literal de cadena.

Puede que no sea la forma Pythonic, pero generalmente uso una lista con la función de unión para escribir una cadena larga, como consultas SQL:

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

Tomado de The Hitchhiker's Guide to Python ( Continuación de línea ):

Cuando una línea lógica de código es más larga que el límite aceptado, debe dividirla en varias líneas físicas. El intérprete de Python unirá líneas consecutivas si el último carácter de la línea es una barra invertida. Esto es útil en algunos casos, pero generalmente debe evitarse debido a su fragilidad: un espacio en blanco agregado al final de la línea, después de la barra diagonal inversa, romperá el código y puede tener resultados inesperados.

Una mejor solución es usar paréntesis alrededor de sus elementos. Dejado con un paréntesis sin cerrar en un final de línea, el intérprete de Python se unirá a la siguiente línea hasta que se cierren los paréntesis. El mismo comportamiento es válido para llaves y llaves.

Sin embargo , la mayoría de las veces, tener que dividir una larga línea lógica es una señal de que está tratando de hacer muchas cosas al mismo tiempo, lo que puede dificultar la legibilidad.

Dicho esto, aquí hay un ejemplo que considera múltiples importaciones (cuando excede los límites de línea, definidos en PEP-8 ), también aplicado a cadenas en general:

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

Si desea romper su línea debido a una cadena literal larga, puede dividir esa cadena en pedazos:

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

será reemplazado por

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

Salida para ambas declaraciones impresas:

a very long string

Observe el paréntesis en la afectación.

Tenga en cuenta también que dividir las cadenas literales en pedazos permite usar el prefijo literal solo en partes de la cadena:

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

Utilice el operador de continuación de línea, es decir, "\"

Ejemplos:

# 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