Ik heb een lange regel code die ik over meerdere regels wil verdelen. Wat gebruik ik en wat is de syntaxis?
Bijvoorbeeld een aantal strings toevoegen,
e = 'a' + 'b' + 'c' + 'd'
en zet het in twee regels als volgt:
e = 'a' + 'b' +
'c' + 'd'
Antwoord 1, autoriteit 100%
Wat is de regel? Je kunt zonder problemen gewoon argumenten op de volgende regel hebben:
a = dostuff(blahblah1, blahblah2, blahblah3, blahblah4, blahblah5,
blahblah6, blahblah7)
Anders kun je zoiets als dit doen:
if (a == True and
b == False):
of met expliciete regeleinde:
if a == True and \
b == False:
Bekijk de stijlgidsvoor meer informatie.
Met haakjes kan uw voorbeeld over meerdere regels worden geschreven:
a = ('1' + '2' + '3' +
'4' + '5')
Hetzelfde effect kan worden verkregen door een expliciete regeleinde te gebruiken:
a = '1' + '2' + '3' + \
'4' + '5'
Houd er rekening mee dat de stijlgids zegt dat het gebruik van de impliciete voortzetting met haakjes de voorkeur heeft, maar in dit specifieke geval is het waarschijnlijk de verkeerde manier om alleen haakjes rond uw uitdrukking toe te voegen.
Antwoord 2, autoriteit 19%
Van PEP 8 — Stijlgids voor Python-code:
De voorkeursmanier om lange regels in te pakken is door Python’s impliciete voortzetting van regels tussen haakjes, haakjes en accolades te gebruiken.Lange regels kunnen over meerdere regels worden onderbroken door uitdrukkingen tussen haakjes te plaatsen. Deze moeten worden gebruikt in plaats van een backslash voor het voortzetten van de regel.
Backslashes kunnen soms nog steeds gepast zijn. Lange, meerdere with-statements kunnen bijvoorbeeld geen impliciete voortzetting gebruiken, dus backslashes zijn acceptabel:
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())Een ander dergelijk geval is met beweringen.
Zorg ervoor dat u de vervolgregel op de juiste manier laat inspringen. De voorkeursplaats om een binaire operator te omzeilen is nade operator, niet ervoor. Enkele voorbeelden:
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 beveelt nu de tegengestelde conventieaan (voor het breken bij binaire bewerkingen) die door wiskundigen en hun uitgevers wordt gebruikt om de leesbaarheid te verbeteren.
Donald Knuth’s stijl van breken voordateen binaire operator de operatoren verticaal uitlijnt, waardoor de werklast van het oog wordt verminderd bij het bepalen welke items worden opgeteld en afgetrokken.
Van PEP8: Moet een regel afbreken voor of na een binaire operator?:
Donald Knuth legt de traditionele regel uit in zijn Computers and Typesetting-serie: “Hoewel formules binnen een alinea altijd breken na binaire bewerkingen en relaties, breken weergegeven formules altijd vóór binaire bewerkingen”[3].
Het volgen van de traditie uit de wiskunde resulteert meestal in beter leesbare code:
# Yes: easy to match operators with operands income = (gross_wages + taxable_interest + (dividends - qualified_dividends) - ira_deduction - student_loan_interest)In Python-code is het toegestaan om voor of na een binaire operator te breken, zolang de conventie lokaal consistent is. Voor de nieuwe code wordt de stijl van Knuth voorgesteld.
[3]: The TeXBook van Donald Knuth, pagina’s 195 en 196
Antwoord 3, autoriteit 5%
Het gevaar bij het gebruik van een backslash om een regel te beëindigen is dat als er witruimte wordt toegevoegd na de backslash (wat natuurlijk heel moeilijk te zien is), de backslash niet meer doet wat je dacht dat het was.
Zie Python-idioom en anti-idioom (voor Python 2of Python 3) voor meer.
Antwoord 4, autoriteit 2%
Zet een \aan het einde van je regel of zet de instructie tussen haakjes ( .. ). Van IBM:
b = ((i1 < 20) and
(i2 < 30) and
(i3 < 40))
of
b = (i1 < 20) and \
(i2 < 30) and \
(i3 < 40)
Antwoord 5, autoriteit 2%
Je kunt regels afbreken tussen haakjes en accolades. Bovendien kunt u het backslash-teken \toevoegen aan een regel om deze expliciet te verbreken:
x = (tuples_first_value,
second_value)
y = 1 + \
2
Antwoord 6, autoriteit 2%
Uit de mond van het paard: Expliciete regel
meedoenEr kunnen twee of meer fysieke lijnen zijn
samengevoegd tot logische lijnen met behulp van
backslash-tekens (\), als volgt:
wanneer een fysieke regel eindigt op a
backslash die geen deel uitmaakt van een string
letterlijk of commentaar, het wordt samengevoegd met
de volgende vormen een enkele logische:
regel, het verwijderen van de backslash en de
volgend einde-lijnteken. Voor
voorbeeld: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 1Een regel die eindigt op een backslash kan niet
een opmerking dragen. Een backslash niet
vervolg een opmerking. Een backslash wel
niet doorgaan met een token behalve voor string
letterlijke (d.w.z. andere tokens dan
letterlijke tekenreeksen kunnen niet worden opgesplitst
fysieke lijnen met een backslash). EEN
backslash is elders illegaal op a
regel buiten een letterlijke tekenreeks.
Antwoord 7
Als je je regel wilt breken vanwege een lange letterlijke tekenreeks, kun je die tekenreeks in stukken breken:
long_string = "a very long string"
print("a very long string")
wordt vervangen door
long_string = (
"a "
"very "
"long "
"string"
)
print(
"a "
"very "
"long "
"string"
)
Uitvoer voor beide afdrukopdrachten:
a very long string
Let op de haakjes in de aanstellerij.
Merk ook op dat door letterlijke tekenreeksen in stukken te breken, het letterlijke voorvoegsel alleen op delen van de tekenreeks kan worden gebruikt en de scheidingstekens worden gemengd:
s = (
'''2+2='''
f"{2+2}"
)
Antwoord 8
Het is misschien niet de Python-manier, maar ik gebruik over het algemeen een lijst met de join-functie voor het schrijven van een lange reeks, zoals SQL-query’s:
query = " ".join([
'SELECT * FROM "TableName"',
'WHERE "SomeColumn1"=VALUE',
'ORDER BY "SomeColumn2"',
'LIMIT 5;'
])
Antwoord 9
Genomen uit The Hitchhiker’s Guide to Python (Line Continuation):
Als een logische regel code langer is dan de geaccepteerde limiet, moet u deze over meerdere fysieke regels verdelen. De Python-interpreter voegt opeenvolgende regels samen als het laatste teken van de regel een backslash is. Dit is in sommige gevallen handig, maar moet meestal worden vermeden vanwege de kwetsbaarheid: een witruimte die wordt toegevoegd aan het einde van de regel, na de backslash, zal de code breken en kan onverwachte resultaten hebben.
Een betere oplossing is om haakjes rond uw elementen te gebruiken.Links met een niet-gesloten haakje op een einde van de regel, voegt de Python-interpreter zich bij de volgende regel totdat de haakjes zijn gesloten. Hetzelfde gedrag geldt voor gekrulde en vierkante accolades.
Echter, vaker wel dan niet, is het moeten splitsen van een lange logische regel een teken dat je te veel dingen tegelijk probeert te doen, wat de leesbaarheid kan belemmeren.
Dat gezegd hebbende, hier is een voorbeeld van meerdere importen (bij overschrijding van regellimieten, gedefinieerd op PEP-8), ook toegepast op strings in het algemeen:
from app import (
app, abort, make_response, redirect, render_template, request, session
)
Antwoord 10
Je kunt de aanroep van methoden (obj.method()) ook in meerdere regels breken.
Sluit de opdracht tussen haakjes “()” en overspan meerdere regels:
> res = (some_object
.apply(args)
.filter()
.values)
Ik vind het bijvoorbeeld handig op keten bellen panda’s / holoveriews objecten voorwerpen.