Da PEP8 vorschlägt, die 80-Spalten-Regel für Ihr Python-Programm zu unterschreiten, wie kann ich mich mit langen Zeichenfolgen daran halten, d. H.

s = "this is my really, really, really, really, really, really, really long string that I'd like to shorten."

Wie würde ich vorgehen, um dies auf die folgende Zeile zu erweitern, dh

s = "this is my really, really, really, really, really, really" + 
    "really long string that I'd like to shorten."

Implizite Verkettung könnte die sauberste Lösung sein:

s = "this is my really, really, really, really, really, really," \
    " really long string that I'd like to shorten."

Bearbeiten Auf Reflexion Ich bin damit einverstanden , dass Todd Vorschlag zur Verwendung Klammern eher als Linienfortsetzungs ist besser für alle die Gründe , die er gibt. Das einzige Zögern, das ich habe, ist, dass es relativ einfach ist, in Klammern gesetzte Zeichenfolgen mit Tupeln zu verwechseln.

Da benachbarte Zeichenfolgenkonstanten automatisch verkettet werden, können Sie sie auch folgendermaßen codieren:

s = ("this is my really, really, really, really, really, really, "  
     "really long string that I'd like to shorten.")

Beachten Sie kein Pluszeichen, und ich habe das zusätzliche Komma und Leerzeichen hinzugefügt, die der Formatierung Ihres Beispiels folgen.

Persönlich mag ich die Backslashes nicht, und ich erinnere mich, dass ich irgendwo gelesen habe, dass ihre Verwendung zugunsten dieser expliziteren Form tatsächlich veraltet ist. Denken Sie daran: "Explizit ist besser als implizit."

Ich halte den Backslash für weniger klar und weniger nützlich, da dies tatsächlich dem Newline-Zeichen entgeht. Es ist nicht möglich, einen Zeilenende-Kommentar danach zu setzen, falls dies erforderlich sein sollte. Dies ist mit verketteten Zeichenfolgenkonstanten möglich:

s = ("this is my really, really, really, really, really, really, " # comments ok
     "really long string that I'd like to shorten.")

Ich habe eine Google-Suche nach "Python-Zeilenlänge" verwendet, die den PEP8-Link als erstes Ergebnis zurückgibt, aber auch Links zu einem anderen guten StackOverflow-Beitrag zu diesem Thema: " Warum sollte Python PEP-8 eine maximale Zeilenlänge von 79 Zeichen angeben? "

Ein weiterer guter Suchbegriff wäre "Python Line Continuation".

Ich denke, das wichtigste Wort in Ihrer Frage war "schlägt vor".

Codierungsstandards sind lustige Dinge. Oft haben die von ihnen bereitgestellten Anleitungen eine wirklich gute Grundlage, als sie geschrieben wurden (z. B. können die meisten Terminals nicht mehr als 80 Zeichen in einer Zeile anzeigen), aber im Laufe der Zeit werden sie funktional veraltet, werden aber immer noch strikt eingehalten. Ich denke, was Sie hier tun müssen, ist, die relativen Vorzüge des "Brechens" dieses bestimmten Vorschlags gegen die Lesbarkeit und Wartbarkeit Ihres Codes abzuwägen.

Entschuldigung, dies beantwortet Ihre Frage nicht direkt.

Sie haben ein Leerzeichen verloren und benötigen wahrscheinlich ein Zeilenfortsetzungszeichen, d. H. a \.

s = "this is my really, really, really, really, really, really" +  \
    " really long string that I'd like to shorten."

oder auch:

s = "this is my really, really, really, really, really, really"  \
    " really long string that I'd like to shorten."

Parens würde auch anstelle der Zeilenfortsetzung funktionieren, aber Sie riskieren jemanden, der denkt, Sie wollten ein Tupel haben und haben gerade ein Komma vergessen. Nimm zum Beispiel:

s = ("this is my really, really, really, really, really, really"
    " really long string that I'd like to shorten.")

gegen:

s = ("this is my really, really, really, really, really, really",
    " really long string that I'd like to shorten.")

Bei der dynamischen Typisierung von Python kann der Code in beide Richtungen ausgeführt werden, führt jedoch zu falschen Ergebnissen mit dem von Ihnen nicht beabsichtigten.

Backslash:

s = "this is my really, really, really, really, really, really" +  \
    "really long string that I'd like to shorten."

oder in Parens einwickeln:

s = ("this is my really, really, really, really, really, really" + 
    "really long string that I'd like to shorten.")

Dies sind alles gute Antworten, aber ich konnte kein Editor-Plugin finden, das mir beim Bearbeiten von "implizit verketteten" Zeichenfolgen helfen würde. Deshalb habe ich ein Paket geschrieben, um es mir leichter zu machen.

Auf pip (Absätze installieren), wenn jemand, der diesen alten Thread durchwandert, ihn überprüfen möchte. Formatiert mehrzeilige Zeichenfolgen wie HTML (komprimiert Leerzeichen, zwei neue Zeilen für einen neuen Absatz, keine Sorge um Leerzeichen zwischen Zeilen).

from paragraphs import par


class SuddenDeathError(Exception):
    def __init__(self, cause: str) -> None:
        self.cause = cause

    def __str__(self):
        return par(
            f""" Y - e - e - e - es, Lord love you! Why should she die of
            {self.cause}? She come through diphtheria right enough the year
            before. I saw her with my own eyes. Fairly blue with it, she
            was. They all thought she was dead; but my father he kept ladling
            gin down her throat till she came to so sudden that she bit the bowl
            off the spoon. 

            What call would a woman with that strength in her have to die of
            {self.cause}? What become of her new straw hat that should have
            come to me? Somebody pinched it; and what I say is, them as pinched
            it done her in."""
        )


raise SuddenDeathError("influenza")

wird ...

__main__.SuddenDeathError: Y - e - e - e - es, Lord love you! Why should she die of influenza? She come through diphtheria right enough the year before. I saw her with my own eyes. Fairly blue with it, she was. They all thought she was dead; but my father he kept ladling gin down her throat till she came to so sudden that she bit the bowl off the spoon.

What call would a woman with that strength in her have to die of influenza? What become of her new straw hat that should have come to me? Somebody pinched it; and what I say is, them as pinched it done her in.

Alles passt leicht zu (Vim) 'gq'

Mit a können \Sie Anweisungen auf mehrere Zeilen erweitern:

s = "this is my really, really, really, really, really, really" + \
"really long string that I'd like to shorten."

sollte arbeiten.

Ich neige dazu, einige Methoden zu verwenden, die hier nicht erwähnt werden, um große Zeichenfolgen anzugeben, aber diese sind für sehr spezifische Szenarien. YMMV ...

• Mehrzeilige Textblobs, oft mit formatierten Token (nicht ganz das, was Sie gefragt haben, aber dennoch nützlich):

  error_message = '''
  I generally like to see how my helpful, sometimes multi-line error
  messages will look against the left border.
  '''.strip()

• Erweitern Sie die Variable Stück für Stück durch eine beliebige String-Interpolationsmethode, die Sie bevorzugen:

  var = 'This is the start of a very,'
  var = f'{var} very long string which could'
  var = f'{var} contain a ridiculous number'
  var = f'{var} of words.'

• Lesen Sie es aus einer Datei. PEP-8 begrenzt die Länge der Zeichenfolgen in einer Datei nicht. nur die Zeilen Ihres Codes. :) :)

• Verwenden Sie Brute-Force oder Ihren Editor, um die Zeichenfolge mithilfe von Zeilenumbrüchen in verwaltbare Zeilen aufzuteilen, und entfernen Sie dann alle Zeilenumbrüche. (Ähnlich wie bei der ersten Technik, die ich aufgelistet habe):

  foo = '''
  agreatbigstringthatyoudonotwanttohaveanyne
  wlinesinbutforsomereasonyouneedtospecifyit
  verbatimintheactualcodejustlikethis
  '''.replace('\n', '')

Verfügbare Optionen:

• Backslash :"foo" \ "bar"
• Pluszeichen gefolgt von Backslash :"foo" + \ "bar"
• Klammern :
  • ("foo" "bar")
  • Klammern mit Pluszeichen :("foo" + "bar")
  • PEP8, E502: Der Backslash zwischen Klammern ist redundant

Vermeiden

Vermeiden Sie Klammern mit Komma: ("foo", "bar")Dies definiert ein Tupel.

>>> s = "a" \
... "b"
>>> s
'ab'
>>> type(s)
<class 'str'>

>>> s = "a" + \
... "b"
>>> s
'ab'
>>> type(s)
<class 'str'>

>>> s = ("a"
... "b")
>>> type(s)
<class 'str'>
>>> print(s)
ab

>>> s = ("a",
... "b")
>>> type(s)
<class 'tuple'>

>>> s = ("a" + 
... "b")
>>> type(s)
<class 'str'>
>>> print(s)
ab
>>> 

Wenn Sie ein langes String-Literal einfügen müssen und flake8 herunterfahren soll, können Sie die Anweisungen zum Herunterfahren verwenden . Zum Beispiel habe ich in einer Testroutine eine gefälschte CSV-Eingabe definiert. Ich fand, dass das Aufteilen auf mehr Zeilen mit Zeilen sehr verwirrend wäre, und entschied mich daher, # noqa: E501Folgendes wie folgt hinzuzufügen :

csv_test_content = """"STATION","DATE","SOURCE","LATITUDE","LONGITUDE","ELEVATION","NAME","REPORT_TYPE","CALL_SIGN","QUALITY_CONTROL","WND","CIG","VIS","TMP","DEW","SLP","AA1","AA2","AY1","AY2","GF1","MW1","REM"
"94733099999","2019-01-03T22:00:00","4","-32.5833333","151.1666666","45.0","SINGLETON STP, AS","FM-12","99999","V020","050,1,N,0010,1","22000,1,9,N","025000,1,9,9","+0260,1","+0210,1","99999,9","24,0000,9,1",,"0,1,02,1","0,1,02,1","01,99,1,99,9,99,9,99999,9,99,9,99,9","01,1","SYN05294733 11/75 10502 10260 20210 60004 70100 333 70000="
"94733099999","2019-01-04T04:00:00","4","-32.5833333","151.1666666","45.0","SINGLETON STP, AS","FM-12","99999","V020","090,1,N,0021,1","22000,1,9,N","025000,1,9,9","+0378,1","+0172,1","99999,9","06,0000,9,1",,"0,1,02,1","0,1,02,1","03,99,1,99,9,99,9,99999,9,99,9,99,9","03,1","SYN04294733 11/75 30904 10378 20172 60001 70300="
"94733099999","2019-01-04T22:00:00","4","-32.5833333","151.1666666","45.0","SINGLETON STP, AS","FM-12","99999","V020","290,1,N,0057,1","99999,9,9,N","020000,1,9,9","+0339,1","+0201,1","99999,9","24,0000,9,1",,"0,1,02,1","0,1,02,1",,"02,1","SYN05294733 11970 02911 10339 20201 60004 70200 333 70000="
"94733099999","2019-01-05T22:00:00","4","-32.5833333","151.1666666","45.0","SINGLETON STP, AS","FM-12","99999","V020","200,1,N,0026,1","99999,9,9,N","000100,1,9,9","+0209,1","+0193,1","99999,9","24,0004,3,1",,"1,1,02,1","1,1,02,1","08,99,1,99,9,99,9,99999,9,99,9,99,9","51,1","SYN05294733 11/01 82005 10209 20193 69944 75111 333 70004="
"94733099999","2019-01-08T04:00:00","4","-32.5833333","151.1666666","45.0","SINGLETON STP, AS","FM-12","99999","V020","070,1,N,0026,1","22000,1,9,N","025000,1,9,9","+0344,1","+0213,1","99999,9","06,0000,9,1",,"2,1,02,1","2,1,02,1","04,99,1,99,9,99,9,99999,9,99,9,99,9","02,1","SYN04294733 11/75 40705 10344 20213 60001 70222="
"""  # noqa: E501

Ich habe in der Vergangenheit textwrap.dedent verwendet. Es ist etwas umständlich, deshalb bevorzuge ich jetzt Zeilenfortsetzungen, aber wenn Sie wirklich den Blockeinzug wollen, finde ich das großartig.

Beispielcode (wobei der Zuschnitt darin besteht, das erste '\ n' mit einem Slice zu entfernen):

import textwrap as tw
x = """\
       This is a yet another test.
       This is only a test"""
print(tw.dedent(x))

Erläuterung:

dedent berechnet den Einzug basierend auf dem Leerraum in der ersten Textzeile vor einer neuen Zeile. Wenn Sie es optimieren möchten, können Sie es mithilfe des reModuls problemlos erneut implementieren .

Diese Methode hat Einschränkungen, da sehr lange Zeilen möglicherweise noch länger sind als gewünscht. In diesem Fall sind andere Methoden, die Zeichenfolgen verketten, besser geeignet.