Richtige Einrückung für mehrzeilige Python-Zeichenfolgen

Was ist der richtige Einzug für mehrzeilige Python-Zeichenfolgen innerhalb einer Funktion?

    def method():
        string = """line one
line two
line three"""

oder

    def method():
        string = """line one
        line two
        line three"""

oder etwas anderes?

Es sieht irgendwie komisch aus, wenn die Zeichenfolge im ersten Beispiel außerhalb der Funktion hängt.

Sie möchten sich wahrscheinlich mit dem ausrichten """

def foo():
    string = """line one
             line two
             line three"""

Da die Zeilenumbrüche und Leerzeichen in der Zeichenfolge selbst enthalten sind, müssen Sie sie nachbearbeiten. Wenn Sie dies nicht möchten und viel Text haben, können Sie ihn separat in einer Textdatei speichern. Wenn eine Textdatei für Ihre Anwendung nicht gut funktioniert und Sie nicht nachbearbeiten möchten, würde ich wahrscheinlich mitmachen

def foo():
    string = ("this is an "
              "implicitly joined "
              "string")

Wenn Sie eine mehrzeilige Zeichenfolge nachbearbeiten möchten, um die nicht benötigten Teile zu textwrapentfernen, sollten Sie das in PEP 257 vorgestellte Modul oder die Technik für die Nachbearbeitung von Dokumentzeichenfolgen berücksichtigen :

def trim(docstring):
    if not docstring:
        return ''
    # Convert tabs to spaces (following the normal Python rules)
    # and split into a list of lines:
    lines = docstring.expandtabs().splitlines()
    # Determine minimum indentation (first line doesn't count):
    indent = sys.maxint
    for line in lines[1:]:
        stripped = line.lstrip()
        if stripped:
            indent = min(indent, len(line) - len(stripped))
    # Remove indentation (first line is special):
    trimmed = [lines[0].strip()]
    if indent < sys.maxint:
        for line in lines[1:]:
            trimmed.append(line[indent:].rstrip())
    # Strip off trailing and leading blank lines:
    while trimmed and not trimmed[-1]:
        trimmed.pop()
    while trimmed and not trimmed[0]:
        trimmed.pop(0)
    # Return a single string:
    return '\n'.join(trimmed)

Die textwrap.dedentFunktion ermöglicht es, mit der korrekten Einrückung in der Quelle zu beginnen und diese dann vor der Verwendung aus dem Text zu entfernen.

Der Kompromiss besteht, wie einige andere bemerkten, darin, dass dies ein zusätzlicher Funktionsaufruf für das Literal ist; Berücksichtigen Sie dies, wenn Sie entscheiden, wo diese Literale in Ihrem Code platziert werden sollen.

import textwrap

def frobnicate(param):
    """ Frobnicate the scrognate param.

        The Weebly-Ruckford algorithm is employed to frobnicate
        the scrognate to within an inch of its life.

        """
    prepare_the_comfy_chair(param)
    log_message = textwrap.dedent("""\
            Prepare to frobnicate:
            Here it comes...
                Any moment now.
            And: Frobnicate!""")
    weebly(param, log_message)
    ruckford(param)

Das Nachlaufen \im Protokollnachrichtenliteral soll sicherstellen, dass der Zeilenumbruch nicht im Literal enthalten ist. Auf diese Weise beginnt das Literal nicht mit einer Leerzeile, sondern mit der nächsten vollständigen Zeile.

Der Rückgabewert von textwrap.dedentist die Eingabezeichenfolge, bei der alle gemeinsamen führenden Leerzeicheneinrückungen in jeder Zeile der Zeichenfolge entfernt werden. Der obige log_messageWert lautet also:

Prepare to frobnicate:
Here it comes...
    Any moment now.
And: Frobnicate!

Verwenden Sie inspect.cleandocwie folgt:

def method():
    string = inspect.cleandoc("""
        line one
        line two
        line three""")

Die relative Einrückung wird wie erwartet beibehalten. Verwenden Sie, wie unten kommentiert , wenn Sie vorhergehende Leerzeilen beibehalten möchten textwrap.dedent. Damit bleibt aber auch der erste Zeilenumbruch erhalten.

Hinweis: Es wird empfohlen, logische Codeblöcke im zugehörigen Kontext einzurücken, um die Struktur zu verdeutlichen. ZB die mehrzeilige Zeichenfolge, die zur Variablen gehört string.

Eine Option, die in den anderen Antworten zu fehlen scheint (nur tief unten in einem Kommentar von naxa erwähnt), ist die folgende:

def foo():
    string = ("line one\n"          # Add \n in the string
              "line two"  "\n"      # Add "\n" after the string
              "line three\n")

Dies ermöglicht eine korrekte Ausrichtung, verbindet die Linien implizit und behält dennoch die Linienverschiebung bei, was für mich einer der Gründe ist, warum ich sowieso mehrzeilige Zeichenfolgen verwenden möchte.

Es ist keine Nachbearbeitung erforderlich, aber Sie müssen die \nan einer bestimmten Stelle, an der die Zeile enden soll , manuell hinzufügen . Entweder inline oder als separater String danach. Letzteres lässt sich leichter kopieren und einfügen.

Einige weitere Optionen. In Ipython mit aktiviertem Pylab befindet sich dedent bereits im Namespace. Ich habe nachgesehen und es ist von matplotlib. Oder es kann importiert werden mit:

from matplotlib.cbook import dedent

In der Dokumentation heißt es, dass es schneller ist als das Textwrap-Äquivalent und in meinen Tests in Ipython ist es mit meinen Schnelltests im Durchschnitt dreimal schneller. Es hat auch den Vorteil, dass alle führenden Leerzeilen verworfen werden, sodass Sie beim Erstellen der Zeichenfolge flexibel sein können:

"""
line 1 of string
line 2 of string
"""

"""\
line 1 of string
line 2 of string
"""

"""line 1 of string
line 2 of string
"""

Die Verwendung der Matplotlib für diese drei Beispiele führt zu demselben vernünftigen Ergebnis. Die Textwrap-Dedent-Funktion hat eine führende Leerzeile mit dem ersten Beispiel.

Offensichtlicher Nachteil ist, dass sich Textwrap in der Standardbibliothek befindet, während matplotlib ein externes Modul ist.

Einige Kompromisse hier ... Die dedent-Funktionen machen Ihren Code besser lesbar, wenn die Zeichenfolgen definiert werden, müssen jedoch später verarbeitet werden, um die Zeichenfolge in einem verwendbaren Format zu erhalten. In Docstrings ist es offensichtlich, dass Sie den richtigen Einzug verwenden sollten, da die meisten Verwendungen des Docstrings die erforderliche Verarbeitung ausführen.

Wenn ich eine nicht lange Zeichenfolge in meinem Code benötige, finde ich den folgenden zugegebenermaßen hässlichen Code, in dem ich die lange Zeichenfolge aus dem einschließenden Einzug herausfallen lasse. Scheitert definitiv an "Schön ist besser als hässlich", aber man könnte argumentieren, dass es einfacher und expliziter ist als die dedizierte Alternative.

def example():
    long_string = '''\
Lorem ipsum dolor sit amet, consectetur adipisicing
elit, sed do eiusmod tempor incididunt ut labore et
dolore magna aliqua. Ut enim ad minim veniam, quis
nostrud exercitation ullamco laboris nisi ut aliquip.\
'''
    return long_string

print example()

Wenn Sie eine schnelle und einfache Lösung wünschen und sich das Eingeben von Zeilenumbrüchen ersparen möchten, können Sie sich stattdessen für eine Liste entscheiden, z.

def func(*args, **kwargs):
    string = '\n'.join([
        'first line of very long string and',
        'second line of the same long thing and',
        'third line of ...',
        'and so on...',
        ])
    print(string)
    return

ich bevorzuge

    def method():
        string = \
"""\
line one
line two
line three\
"""

oder

    def method():
        string = """\
line one
line two
line three\
"""

Meine zwei Cent entkommen dem Zeilenende, um die Einrückungen zu erhalten:

def foo():
    return "{}\n"\
           "freq: {}\n"\
           "temp: {}\n".format( time, freq, temp )

Ich bin hierher gekommen, um nach einem einfachen 1-Liner zu suchen, mit dem die Identifikationsstufe des Dokumentstrings zum Drucken entfernt / korrigiert werden kann , ohne dass er unordentlich aussieht , indem er beispielsweise im Skript "außerhalb der Funktion hängt".

Folgendes habe ich getan:

import string
def myfunction():

    """
    line 1 of docstring
    line 2 of docstring
    line 3 of docstring"""

print str(string.replace(myfunction.__doc__,'\n\t','\n'))[1:] 

Wenn Sie anstelle der Tabulatortaste Leerzeichen (z. B. 4) einrücken, verwenden Sie stattdessen Folgendes:

print str(string.replace(myfunction.__doc__,'\n    ','\n'))[1:]

Und Sie müssen das erste Zeichen nicht entfernen, wenn Ihre Dokumentzeichenfolgen stattdessen so aussehen sollen:

    """line 1 of docstring
    line 2 of docstring
    line 3 of docstring"""

print string.replace(myfunction.__doc__,'\n\t','\n') 

Die erste Option ist die gute - mit Einrückung. Es ist im Python-Stil - bietet Lesbarkeit für den Code.

So zeigen Sie es richtig an:

print string.lstrip()

Dies hängt davon ab, wie der Text angezeigt werden soll. Wenn Sie möchten, dass alles linksbündig ausgerichtet ist, formatieren Sie es entweder wie im ersten Snippet oder durchlaufen Sie die Zeilen, die den gesamten Raum nach links kürzen.

Für Zeichenfolgen können Sie die Zeichenfolge direkt nach der Verarbeitung verarbeiten. Für Docstrings müssen Sie stattdessen die Funktion nachbearbeiten. Hier ist eine Lösung für beide, die noch lesbar ist.

class Lstrip(object):
    def __rsub__(self, other):
        import re
        return re.sub('^\n', '', re.sub('\n$', '', re.sub('\n\s+', '\n', other)))

msg = '''
      Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod
      tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim
      veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea
      commodo consequat. Duis aute irure dolor in reprehenderit in voluptate
      velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat
      cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id
      est laborum.
      ''' - Lstrip()

print msg

def lstrip_docstring(func):
    func.__doc__ = func.__doc__ - Lstrip()
    return func

@lstrip_docstring
def foo():
    '''
    Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod
    tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim
    veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea
    commodo consequat. Duis aute irure dolor in reprehenderit in voluptate
    velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat
    cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id
    est laborum.
    '''
    pass


print foo.__doc__

Ich habe ein ähnliches Problem, Code wurde mit Multilines wirklich unlesbar, ich kam mit so etwas heraus

print("""aaaa
"""   """bbb
""")

Ja, am Anfang könnte es schrecklich aussehen, aber die eingebettete Syntax war ziemlich komplex und das Hinzufügen von etwas am Ende (wie '\ n "') war keine Lösung

Sie können diese Funktion trim_indent verwenden .

import re


def trim_indent(s: str):
    s = re.sub(r'^\n+', '', s)
    s = re.sub(r'\n+$', '', s)
    spaces = re.findall(r'^ +', s, flags=re.MULTILINE)
    if len(spaces) > 0 and len(re.findall(r'^[^\s]', s, flags=re.MULTILINE)) == 0:
        s = re.sub(r'^%s' % (min(spaces)), '', s, flags=re.MULTILINE)
    return s


print(trim_indent("""


        line one
            line two
                line three
            line two
        line one


"""))

Ergebnis:

"""
line one
    line two
        line three
    line two
line one
"""