Wie kann ich in Python einen Zeilenumbruch (Zeilenfortsetzung) durchführen?

Ich habe eine lange Codezeile, die ich in mehrere Zeilen aufteilen möchte. Was verwende ich und wie lautet die Syntax?

Zum Beispiel Hinzufügen einer Reihe von Zeichenfolgen,

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

und habe es in zwei Zeilen wie folgt:

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

Was ist die Linie? Sie können einfach ohne Probleme Argumente in der nächsten Zeile haben:

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

Ansonsten können Sie so etwas machen:

if a == True and \
   b == False

Weitere Informationen finden Sie im Styleguide .

Aus Ihrer Beispielzeile:

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

Oder:

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

Beachten Sie, dass der Styleguide besagt, dass die Verwendung der impliziten Fortsetzung mit Klammern bevorzugt wird. In diesem speziellen Fall ist es jedoch wahrscheinlich der falsche Weg, nur Klammern um Ihren Ausdruck hinzuzufügen.

Aus PEP 8 - Style Guide für Python-Code :

Die bevorzugte Methode zum Umschließen langer Zeilen ist die Verwendung der impliziten Zeilenfortsetzung von Python in Klammern, Klammern und Klammern. Lange Zeilen können über mehrere Zeilen unterbrochen werden, indem Ausdrücke in Klammern eingeschlossen werden. Diese sollten bevorzugt verwendet werden, anstatt einen Backslash für die Zeilenfortsetzung zu verwenden.

Backslashes können manchmal noch angebracht sein. Beispielsweise können lange, mehrere with-Anweisungen keine implizite Fortsetzung verwenden, sodass Backslashes akzeptabel sind:

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

Ein anderer solcher Fall betrifft Assert-Anweisungen.

Stellen Sie sicher, dass die fortgesetzte Zeile entsprechend eingerückt ist. Der bevorzugte Ort, um einen binären Operator zu umgehen, ist nach dem Operator, nicht davor. Einige Beispiele:

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 empfiehlt nun die entgegengesetzte Konvention (zum Brechen bei binären Operationen), die von Mathematikern und ihren Herausgebern verwendet wird, um die Lesbarkeit zu verbessern.

Donald Knuths Art zu brechen, bevor ein binärer Operator die Operatoren vertikal ausrichtet, wodurch die Arbeitsbelastung des Auges verringert wird, wenn bestimmt wird, welche Elemente addiert und subtrahiert werden.

Aus PEP8: Sollte eine Zeile vor oder nach einem binären Operator unterbrochen werden? ::

Donald Knuth erklärt die traditionelle Regel in seiner Reihe "Computer und Satz": "Obwohl Formeln innerhalb eines Absatzes immer nach binären Operationen und Beziehungen brechen, brechen angezeigte Formeln immer vor binären Operationen" [3].

Das Befolgen der Tradition aus der Mathematik führt normalerweise zu besser lesbarem Code:

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

In Python-Code ist es zulässig, vor oder nach einem Binäroperator zu brechen, solange die Konvention lokal konsistent ist. Für neuen Code wird Knuths Stil vorgeschlagen.

[3]: Donald Knuths The TeXBook, Seiten 195 und 196

Die Gefahr bei der Verwendung eines Backslashs zum Beenden einer Zeile besteht darin, dass der Backslash nicht mehr das tut, was Sie dachten, wenn nach dem Backslash Leerzeichen hinzugefügt werden (was natürlich sehr schwer zu erkennen ist).

Weitere Informationen finden Sie unter Python-Redewendungen und Anti-Redewendungen (für Python 2 oder Python 3 ).

Setzen Sie ein \am Ende Ihrer Zeile oder fügen Sie die Aussage in parens ein ( .. ). Von IBM :

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

oder

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

Sie können Linien zwischen Klammern und Klammern brechen. Darüber hinaus können Sie das Backslash-Zeichen \an eine Zeile anhängen , um es explizit zu unterbrechen:

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

Aus dem Maul des Pferdes: Explizite Linienverbindung

Zwei oder mehr physische Zeilen können \wie folgt mit Backslash-Zeichen ( ) zu logischen Zeilen verbunden werden : Wenn eine physische Zeile mit einem Backslash endet, der nicht Teil eines Zeichenfolgenliterals oder -kommentars ist, wird sie mit den folgenden Zeilen verbunden und bildet eine einzige logische Zeile Löschen des Backslashs und des folgenden Zeilenendezeichens. Zum Beispiel:

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

Eine Zeile, die mit einem Backslash endet, kann keinen Kommentar enthalten. Ein Backslash setzt einen Kommentar nicht fort. Ein Backslash setzt ein Token nur für String-Literale fort (dh andere Token als String-Literale können nicht mit einem Backslash auf physische Zeilen aufgeteilt werden). Ein Backslash ist an anderer Stelle in einer Zeile außerhalb eines String-Literal illegal.

Es ist vielleicht nicht die pythonische Methode, aber ich verwende im Allgemeinen eine Liste mit der Join-Funktion zum Schreiben einer langen Zeichenfolge, wie z. B. SQL-Abfragen:

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

Entnommen aus dem Per Anhalter durch Python ( Fortsetzung der Zeile ):

Wenn eine logische Codezeile länger als das akzeptierte Limit ist, müssen Sie sie auf mehrere physische Zeilen aufteilen. Der Python-Interpreter verbindet aufeinanderfolgende Zeilen, wenn das letzte Zeichen der Zeile ein Backslash ist. Dies ist in einigen Fällen hilfreich, sollte jedoch aufgrund seiner Fragilität normalerweise vermieden werden: Ein Leerzeichen am Ende der Zeile nach dem Backslash bricht den Code und kann zu unerwarteten Ergebnissen führen.

Eine bessere Lösung besteht darin, Klammern um Ihre Elemente zu verwenden. Der Python-Interpreter wird mit einer nicht geschlossenen Klammer am Zeilenende in die nächste Zeile eingefügt, bis die Klammern geschlossen sind. Das gleiche Verhalten gilt für geschweifte und eckige Klammern.

Meistens ist das Aufteilen einer langen logischen Zeile jedoch ein Zeichen dafür, dass Sie versuchen, zu viele Dinge gleichzeitig zu tun, was die Lesbarkeit beeinträchtigen kann.

Im Folgenden finden Sie ein Beispiel für mehrere Importe (bei Überschreitung der in PEP-8 definierten Zeilengrenzen ), die auch für Zeichenfolgen im Allgemeinen gelten:

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

Wenn Sie Ihre Zeile aufgrund einer langen Literalzeichenfolge unterbrechen möchten, können Sie diese Zeichenfolge in Teile aufteilen:

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

wird ersetzt durch

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

Ausgabe für beide print-Anweisungen:

a very long string

Beachten Sie die Klammern in der Beeinflussung.

Beachten Sie auch, dass beim Aufteilen von Literalzeichenfolgen in Teile das Literalpräfix nur für Teile der Zeichenfolge verwendet werden kann:

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

Verwenden Sie den Zeilenfortsetzungsoperator dh "\"

Beispiele:

# 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