Come posso fare un'interruzione di linea (continuazione della linea) in Python?

Ho una lunga riga di codice che voglio suddividere tra più righe. Cosa uso e qual è la sintassi?

Ad esempio, aggiungendo un mucchio di stringhe,

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

e lo hanno in due righe come questa:

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

Qual è la linea? Puoi semplicemente avere argomenti sulla riga successiva senza problemi:

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

Altrimenti puoi fare qualcosa del genere:

if a == True and \
   b == False

Controlla la guida di stile per ulteriori informazioni.

Dalla tua riga di esempio:

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

O:

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

Nota che la guida di stile afferma che è preferibile usare la continuazione implicita con le parentesi, ma in questo caso particolare aggiungere semplicemente parentesi attorno alla tua espressione è probabilmente la strada sbagliata.

Da PEP 8 - Guida allo stile per Python Code :

Il modo preferito di avvolgere le linee lunghe è usare la continuazione di linea implicita di Python tra parentesi, parentesi e parentesi graffe. Le linee lunghe possono essere spezzate su più linee avvolgendo le espressioni tra parentesi. Questi dovrebbero essere usati preferibilmente all'utilizzo di una barra rovesciata per la continuazione della linea.

Le barre rovesciate possono ancora essere appropriate a volte. Ad esempio, lunghe dichiarazioni multiple con non possono utilizzare la continuazione implicita, quindi le barre rovesciate sono accettabili:

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

Un altro caso del genere è con affermazioni affermative.

Assicurati di indentare la linea continua in modo appropriato. Il posto preferito per rompere un operatore binario è dopo l'operatore, non prima di esso. Qualche esempio:

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 ora raccomanda la convenzione opposta (per interrompere le operazioni binarie) utilizzata dai matematici e dai loro editori per migliorare la leggibilità.

Lo stile di rottura di Donald Knuth prima che un operatore binario allinea gli operatori verticalmente, riducendo così il carico di lavoro dell'occhio nel determinare quali elementi vengono aggiunti e sottratti.

Da PEP8: una linea dovrebbe interrompersi prima o dopo un operatore binario? :

Donald Knuth spiega la regola tradizionale nelle sue serie Computer e composizione: "Sebbene le formule all'interno di un paragrafo si rompano sempre dopo operazioni e relazioni binarie, le formule visualizzate si rompono sempre prima delle operazioni binarie" [3].

Seguendo la tradizione della matematica di solito si ottiene un codice più leggibile:

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

Nel codice Python, è consentito interrompere prima o dopo un operatore binario, purché la convenzione sia coerente localmente. Per il nuovo codice viene suggerito lo stile di Knuth.

[3]: The TeXBook di Donald Knuth, pagine 195 e 196

Il pericolo nell'uso di una barra rovesciata per terminare una linea è che se lo spazio bianco viene aggiunto dopo la barra rovesciata (che, ovviamente, è molto difficile da vedere), la barra rovesciata non sta più facendo ciò che pensavi fosse.

Vedi Idiomi e anti-idiomi Python (per Python 2 o Python 3 ) per ulteriori informazioni.

Inserisci \a alla fine della riga o racchiudi la frase tra parentesi ( .. ). Da IBM :

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

o

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

È possibile interrompere le linee tra parentesi e parentesi graffe. Inoltre, puoi aggiungere il carattere barra rovesciata \a una riga per interromperlo esplicitamente:

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

Dalla bocca del cavallo: unione esplicita della linea

Due o più linee fisiche possono essere unite in linee logiche usando caratteri di barra rovesciata ( \), come segue: quando una linea fisica termina in una barra rovesciata che non fa parte di una stringa letterale o di un commento, viene unita alla seguente formando una singola linea logica , eliminando la barra rovesciata e il seguente carattere di fine riga. Per esempio:

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 riga che termina con una barra rovesciata non può contenere un commento. Una barra rovesciata non continua un commento. Una barra rovesciata non continua un token ad eccezione dei valori letterali di stringa (ovvero i token diversi dai valori letterali di stringa non possono essere suddivisi su linee fisiche utilizzando una barra rovesciata). Una barra rovesciata è illegale altrove su una linea esterna a una stringa letterale.

Potrebbe non essere il modo Pythonic, ma generalmente uso un elenco con la funzione join per scrivere una stringa lunga, come le query SQL:

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

Tratto da The Hitchhiker's Guide to Python ( Line Continuation ):

Quando una riga logica di codice è più lunga del limite accettato, è necessario dividerla su più righe fisiche. L'interprete Python si unirà a righe consecutive se l'ultimo carattere della riga è una barra rovesciata. Ciò è utile in alcuni casi, ma di solito dovrebbe essere evitato a causa della sua fragilità: uno spazio bianco aggiunto alla fine della riga, dopo la barra rovesciata, romperà il codice e potrebbe avere risultati imprevisti.

Una soluzione migliore è usare le parentesi attorno ai tuoi elementi. A sinistra con una parentesi chiusa su una fine riga l'interprete Python si unirà alla riga successiva fino alla chiusura delle parentesi. Lo stesso comportamento vale per le parentesi graffe e quadrate.

Tuttavia , il più delle volte, dover dividere una lunga linea logica è un segno che stai cercando di fare troppe cose contemporaneamente, il che potrebbe ostacolare la leggibilità.

Detto questo, ecco un esempio considerando le importazioni multiple (quando si superano i limiti di linea, definiti su PEP-8 ), applicati anche alle stringhe in generale:

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

Se vuoi spezzare la linea a causa di una lunga stringa letterale, puoi spezzarla in pezzi:

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

sarà sostituito da

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

Output per entrambe le istruzioni di stampa:

a very long string

Notare la parentesi nell'affetto.

Nota anche che spezzare le stringhe letterali in pezzi consente di usare il prefisso letterale solo su parti della stringa:

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

Utilizzare l' operatore di continuazione della linea, ad esempio "\"

Esempi:

# 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