Sangría adecuada para cadenas multilínea de Python

¿Cuál es la sangría adecuada para las cadenas multilínea de Python dentro de una función?

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

o

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

¿o algo mas?

Parece un poco extraño tener la cadena colgando fuera de la función en el primer ejemplo.

Probablemente quieras alinearte con el """

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

Dado que las líneas nuevas y los espacios se incluyen en la cadena en sí, tendrá que procesarla posteriormente. Si no desea hacer eso y tiene una gran cantidad de texto, es posible que desee almacenarlo por separado en un archivo de texto. Si un archivo de texto no funciona bien para su aplicación y no desea realizar un postproceso, probablemente iría con

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

Si desea postprocesar una cadena multilínea para recortar las partes que no necesita, debe considerar el textwrapmódulo o la técnica para las cadenas de documentos de posprocesamiento presentadas en PEP 257 :

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)

La textwrap.dedentfunción permite comenzar con una sangría correcta en la fuente y luego quitarla del texto antes de usarla.

La compensación, como han señalado algunos otros, es que esta es una llamada de función adicional en el literal; tenga esto en cuenta al decidir dónde colocar estos literales en su código.

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)

Lo que \sigue en el mensaje de registro literal es asegurar que el salto de línea no esté en el literal; de esa manera, el literal no comienza con una línea en blanco, sino que comienza con la siguiente línea completa.

El valor de retorno de textwrap.dedentes la cadena de entrada con todas las sangrías de espacios en blanco iniciales comunes eliminadas en cada línea de la cadena. Entonces el log_messagevalor anterior será:

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

Use inspect.cleandocasí:

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

La sangría relativa se mantendrá como se esperaba. Como se comenta a continuación, si desea mantener las líneas vacías anteriores, use textwrap.dedent. Sin embargo, eso también mantiene el salto de primera línea.

Nota: Es una buena práctica sangrar bloques lógicos de código en su contexto relacionado para aclarar la estructura. Por ejemplo, la cadena de varias líneas que pertenece a la variable string.

Una opción que parece faltar en las otras respuestas (solo mencionada en un comentario de naxa) es la siguiente:

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

Esto permitirá una alineación adecuada, unirá las líneas implícitamente y aún mantendrá el desplazamiento de línea, lo cual, para mí, es una de las razones por las que me gustaría usar cadenas multilínea de todos modos.

No requiere ningún procesamiento posterior, pero debe agregar manualmente \nen cualquier lugar donde desea que finalice la línea. Ya sea en línea o como una cadena separada después. Este último es más fácil de copiar y pegar.

Algunas opciones mas. En Ipython con pylab habilitado, dedent ya está en el espacio de nombres. Lo comprobé y es de matplotlib. O se puede importar con:

from matplotlib.cbook import dedent

En la documentación dice que es más rápido que el equivalente de textwrap y en mis pruebas en ipython es de hecho 3 veces más rápido en promedio con mis pruebas rápidas. También tiene la ventaja de que descarta las líneas en blanco iniciales, esto le permite ser flexible en la forma de construir la cadena:

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

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

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

Usar el dedent matplotlib en estos tres ejemplos dará el mismo resultado sensible. La función de sangría textwrap tendrá una línea en blanco con el primer ejemplo.

La desventaja obvia es que textwrap está en la biblioteca estándar mientras que matplotlib es un módulo externo.

Algunas compensaciones aquí ... las funciones dedent hacen que su código sea más legible donde se definen las cadenas, pero requieren un procesamiento posterior para obtener la cadena en formato utilizable. En las cadenas de documentos es obvio que debe usar la sangría correcta ya que la mayoría de los usos de la cadena de documentos harán el procesamiento requerido.

Cuando necesito una cadena no larga en mi código, encuentro el siguiente código ciertamente feo donde dejo que la cadena larga salga de la sangría adjunta. Definitivamente falla en "Hermoso es mejor que feo", pero se podría argumentar que es más simple y más explícito que la alternativa dedent.

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

Si desea una solución rápida y fácil y se ahorra escribir nuevas líneas, puede optar por una lista, por ejemplo:

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

yo prefiero

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

o

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

Mis dos centavos, escapar del final de la línea para obtener las sangrías:

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

Vine aquí buscando un simple 1-liner para eliminar / corregir el nivel de ideación de la cadena de documentos para imprimir, sin hacer que se vea desordenado , por ejemplo, haciéndolo "colgar fuera de la función" dentro del script.

Esto es lo que terminé haciendo:

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:] 

Obviamente, si está sangrando con espacios (por ejemplo, 4) en lugar de la tecla de tabulación, use algo como esto en su lugar:

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

Y no es necesario que elimine el primer carácter si desea que sus cadenas de documentos se vean así:

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

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

La primera opción es la buena, con sangría incluida. Está en estilo python: proporciona legibilidad para el código.

Para mostrarlo correctamente:

print string.lstrip()

Depende de cómo desea que se muestre el texto. Si desea que todo esté alineado a la izquierda, formatee como en el primer fragmento o itere a través de las líneas que recortan a la izquierda todo el espacio.

Para cadenas, puede justo después de procesar la cadena. Para las cadenas de documentos, debe procesar después la función en su lugar. Aquí hay una solución para ambos que todavía es legible.

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__

Tengo un problema similar, el código se volvió realmente ilegible usando multilíneas, salí con algo como

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

sí, al principio podría parecer terrible, pero la sintaxis incorporada era bastante compleja y agregar algo al final (como '\ n "') no era una solución

Puede usar esta función trim_indent .

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


"""))

Resultado:

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