Jak zrobić podział linii (kontynuacja linii) w Pythonie?

Mam długi wiersz kodu, który chcę podzielić na wiele wierszy. Z czego korzystam i jaka jest składnia?

Na przykład dodając kilka ciągów znaków,

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

i mieć go w dwóch liniach:

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

Jaka jest linia Możesz mieć argumenty w następnym wierszu bez żadnych problemów:

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

W przeciwnym razie możesz zrobić coś takiego:

if a == True and \
   b == False

Więcej informacji znajdziesz w przewodniku po stylach .

Z twojej przykładowej linii:

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

Lub:

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

Zauważ, że przewodnik po stylu mówi, że preferowane jest stosowanie niejawnej kontynuacji z nawiasami, ale w tym konkretnym przypadku po prostu dodanie nawiasów wokół wyrażenia jest prawdopodobnie niewłaściwą drogą.

Z PEP 8 - Przewodnik po stylu dla kodu Python :

Preferowanym sposobem owijania długich linii jest użycie implikowanej kontynuacji linii w Pythonie w nawiasach, nawiasach i nawiasach klamrowych. Długie linie można podzielić na wiele linii, zawijając wyrażenia w nawiasach. Powinny być używane zamiast używania odwrotnego ukośnika do kontynuacji linii.

Odwrotne ukośniki mogą być czasami odpowiednie. Na przykład długie, wielokrotne instrukcje z nie mogą używać niejawnej kontynuacji, więc dopuszczalne są ukośniki odwrotne:

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

Innym takim przypadkiem są stwierdzenia stwierdzające.

Upewnij się, że odpowiednio wcięto ciąg dalszy. Preferowanym miejscem na obejście operatora binarnego jest po nim, a nie przed nim. Kilka przykładów:

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 zaleca teraz odwrotną konwencję (dotyczącą łamania operacji binarnych) używaną przez matematyków i ich wydawców w celu poprawy czytelności.

Styl łamania przez Donalda Knutha przed operatorem binarnym wyrównuje operatory w pionie, zmniejszając w ten sposób obciążenie oka podczas określania, które elementy są dodawane i odejmowane.

Z PEP8: Czy linia powinna się przełamać przed operatorem binarnym lub po nim? :

Donald Knuth wyjaśnia tradycyjną zasadę w serii Komputery i skład: „Chociaż formuły w akapicie zawsze łamią się po operacjach binarnych i relacjach, wyświetlane formuły zawsze psują się przed operacjami binarnymi” [3].

Postępowanie zgodnie z tradycją matematyki zwykle skutkuje bardziej czytelnym kodem:

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

W kodzie Python dozwolone jest przerywanie przed operatorem binarnym lub po nim, o ile konwencja jest lokalnie spójna. W przypadku nowego kodu sugerowany jest styl Knutha.

[3]: TeXBook Donalda Knutha, strony 195 i 196

Niebezpieczeństwo podczas używania odwrotnego ukośnika do zakończenia linii polega na tym, że jeśli po odwrotnym odwróceniu zostanie dodana spacja (co oczywiście jest bardzo trudne do zobaczenia), odwrotny ukośnik nie robi już tego, co myślałeś.

Zobacz Idiomy i anty-idiomy Pythona (dla Python 2 lub Python 3 ), aby uzyskać więcej.

Umieść \na końcu linii lub umieść instrukcję w parens ( .. ). Z IBM :

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

lub

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

Możesz przerywać linie między nawiasami i nawiasami klamrowymi. Dodatkowo możesz dołączyć znak odwrotnego ukośnika \do linii, aby jawnie go przerwać:

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

Z pyska konia: wyraźne połączenie linii

Dwie lub więcej linii fizycznych można połączyć w linie logiczne przy użyciu znaków odwrotnego ukośnika ( \), w następujący sposób: gdy linia fizyczna kończy się odwrotnym ukośnikiem, który nie jest częścią literału lub komentarza, łączy się z następującymi, tworząc jedną linię logiczną , usuwając ukośnik odwrotny i następujący znak końca wiersza. Na przykład:

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

Linia kończąca się odwrotnym ukośnikiem nie może zawierać komentarza. Ukośnik odwrotny nie kontynuuje komentarza. Ukośnik odwrotny nie kontynuuje tokena, z wyjątkiem literałów łańcuchowych (tzn. Tokenów innych niż literały łańcuchowe nie można podzielić na fizyczne linie za pomocą odwrotnego ukośnika). Odwrotny ukośnik jest nielegalny w innym miejscu w wierszu poza literałem ciągowym.

Może nie jest to metoda Pythona, ale generalnie używam listy z funkcją łączenia do pisania długich ciągów, takich jak zapytania SQL:

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

Zaczerpnięte z Przewodnika autostopowicza po Pythonie ( kontynuacja linii ):

Gdy logiczny wiersz kodu jest dłuższy niż zaakceptowany limit, musisz go podzielić na wiele fizycznych wierszy. Interpreter Pythona połączy kolejne linie, jeśli ostatnim znakiem linii jest odwrotny ukośnik. Jest to pomocne w niektórych przypadkach, ale zwykle należy tego unikać ze względu na jego kruchość: biała spacja dodana na końcu linii, po odwrotnym ukośniku, złamie kod i może mieć nieoczekiwane wyniki.

Lepszym rozwiązaniem jest użycie nawiasów wokół elementów. Po pozostawieniu niezamkniętego nawiasu na końcu linii interpreter języka Python dołączy do następnego wiersza, dopóki nawiasy nie zostaną zamknięte. To samo zachowanie dotyczy nawiasów klamrowych i kwadratowych.

Jednak często konieczność podziału długiej linii logicznej jest znakiem, że próbujesz zrobić zbyt wiele rzeczy w tym samym czasie, co może utrudnić czytelność.

Powiedziawszy to, oto przykład rozważania wielokrotnego importu (gdy przekroczenie limitów linii określonych w PEP-8 ) ma również zastosowanie do ciągów w ogóle:

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

Jeśli chcesz przerwać linię ze względu na długi ciąg literału, możesz podzielić ten ciąg na części:

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

zostanie zastąpiony przez

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

Dane wyjściowe dla obu instrukcji drukowania:

a very long string

Zwróć uwagę na nawias w afekcie.

Zauważ też, że dzielenie literalnych ciągów na części pozwala na użycie dosłownego przedrostka tylko na częściach ciągu:

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

Użyj operatora kontynuacji linii, tj. „\”

Przykłady:

# 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