Jak zrobić podział linii (kontynuację linii) w Pythonie?

Od PEP 8 -- Style Guide for Python Code:

Preferowanym sposobem owijania długich linii jest użycie implikowanej linii Pythona wewnątrz nawiasów, nawiasów i nawiasów klamrowych. długie linie mogą być dzielone na wiele linii przez zawijanie wyrażeń w nawiasy. Powinny one być używane zamiast odwrotnego ukośnika dla kontynuacji linii.

Ukośniki mogą być czasami odpowiednie. Na przykład długie, wielokrotne with-statements nie może używać implicit continuity, więc dopuszczalne są odwrotne ukośniki:

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 jest twierdzenie assert.

Upewnij się, że kontynuowany wiersz jest odpowiednio wcięty. Preferowanym miejscem do przerwania wokół operatora binarnego jest po operatorze, Nie przed nim. Niektóre przykłady:

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ę (do łamania w operacjach binarnych) używaną przez matematyków i ich wydawców do popraw czytelność.

Styl łamaniaDonalda Knutha przed operator binarny wyrównuje operatory pionowo, zmniejszając w ten sposób obciążenie oka podczas określania, które elementy są dodawane i odejmowane.

From PEP8: czy linia powinna pękać przed czy po operatorze binarnym?:

Donald Knuth wyjaśnia tradycyjną zasadę w swoich komputerach i seriach składowych: "chociaż formuły w akapicie zawsze pękają po operacjach binarnych i relacje, wyświetlane formuły zawsze pękają przed operacjami binarnymi"[3].

Podążanie za tradycją z 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 Pythona dozwolone jest łamanie przed lub po operatorze binarnym, o ile konwencja jest spójna lokalnie. Dla nowego kodu sugerowany jest styl Knutha.

Niebezpieczeństwo związane z użyciem ukośnika wstecznego do zakończenia linii polega na tym, że jeśli białe znaki zostaną dodane po ukośniku wstecznym (co oczywiście jest bardzo trudne do zauważenia), ukośnik ten nie robi już tego, co myślałeś, że był.

Zobacz Idiomy Pythona i anty-Idiomy (dla Python 2 lub Python 3 ) po więcej.

Umieść \ na końcu wiersza lub załącz wypowiedź w nawiasie ( .. ). From :

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

Lub

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

Możesz łamać linie między nawiasami a klamrami. Dodatkowo, możesz dodać znak ukośnika wstecznego \ do linii, aby jawnie ją złamać:

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

Z paszczy konia: wyraźna linia łączenie

Dwie lub więcej linii fizycznych mogą być połączone w linie logiczne za pomocą znaki odwrotnego ukośnika (\), w następujący sposób: gdy linia fizyczna kończy się w odwrotny ukośnik, który nie jest częścią ciągu znaków dosłownym lub komentarzem, jest on połączony z następujące tworząc jeden logiczny linii, usuwanie ukośnika wstecznego i po znaku końca linii. 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ę ukośnikiem wstecznym nie można noś komentarz. Ukośnik wsteczny nie Kontynuuj komentarz. A backslash does nie kontynuuje tokena z wyjątkiem ciągu znaków literałów (tj. żetonów innych niż literały ciągów nie mogą być dzielone na linie fizyczne za pomocą odwrotnego ukośnika). A backslash jest nielegalny gdzie indziej na linia poza ciągiem literalnym.

Może nie jest to sposób Pythoniczny, ale generalnie używam listy z funkcją join do pisania długiego łańcucha, jak zapytania SQL:

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

Jeśli chcesz złamać linię z powodu długiego literalnego ciągu, możesz podzielić ten ciąg na kawałki:

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

Zostanie zastąpione przez

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

Wyjście dla obu instrukcji print:

a very long string

Zwróć uwagę na nawias w afektacji.

Zauważ również, że rozbijanie ciągów literalnych na kawałki pozwala używać przedrostka literalnego tylko na częściach łańcucha i mieszać ograniczniki:

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

Zaczerpnięte z przewodnika autostopowicza do Pythona ( kontynuacja linii):

Gdy logiczna linia kodu jest dłuższa niż akceptowany limit, musisz podzielić ją na wiele fizycznych linii. Interpreter Pythona dołączy kolejne linie, jeśli ostatni znak linii jest ukośnikiem wstecznym. 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 odwróconym ukośniku, złamie kod i może mieć nieoczekiwane rezultaty.

Lepszym rozwiązaniem jest użycie nawiasów wokół elementów. po lewej z nieujemnym nawiasem na końcu linii interpreter Pythona dołącza do następnej linii, dopóki nawiasy nie zostaną zamknięte. Takie samo zachowanie ma klamry kręcone i kwadratowe.

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

Mając to powiedziane, oto przykład uwzględniający wielokrotne importowanie (gdy przekracza limity linii, zdefiniowane na PEP-8), również stosowane do łańcuchów w ogóle:

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

Można również przerwać wywołanie metod (obj.method()) w wielu liniach.

Załącz polecenie w nawiasie " ()" i rozciągnij wiele linii:

> res = (some_object
         .apply(args)
         .filter()
         .values)

Na przykład, uważam, że jest to przydatne w łańcuchu wywołującym metody Pandas / Holoviews objects.