Recuo adequado para cadeias de caracteres multilinha do Python

Qual é o recuo adequado para seqüências multilinhas Python dentro de uma função?

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

ou

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

ou alguma outra coisa?

Parece meio estranho ter a string pendurada fora da função no primeiro exemplo.

Você provavelmente deseja alinhar com o """

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

Como as novas linhas e os espaços estão incluídos na própria string, você deverá processá-la posteriormente. Se você não quiser fazer isso e tiver muito texto, pode armazená-lo separadamente em um arquivo de texto. Se um arquivo de texto não funcionar bem para o seu aplicativo e você não quiser pós-processamento, eu provavelmente usaria

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

Se você deseja pós-processar uma sequência de múltiplas linhas para aparar as partes desnecessárias, considere o textwrapmódulo ou a técnica para pós-processamento de documentos apresentados no 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)

A textwrap.dedentfunção permite que você comece com o recuo correto na fonte e, em seguida, retire-o do texto antes de usá-lo.

A desvantagem, como observado por alguns outros, é que essa é uma chamada de função extra no literal; leve isso em consideração ao decidir onde colocar esses literais no seu 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)

O final \do literal da mensagem de log é garantir que a quebra de linha não esteja no literal; dessa forma, o literal não começa com uma linha em branco e, em vez disso, começa com a próxima linha completa.

O valor de retorno de textwrap.dedenté a sequência de entrada com todo o recuo de espaço em branco inicial comum removido em cada linha da sequência. Portanto, o log_messagevalor acima será:

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

Use inspect.cleandocassim:

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

O recuo relativo será mantido conforme o esperado. Conforme comentado abaixo, se você deseja manter as linhas vazias anteriores, use textwrap.dedent. No entanto, isso também mantém a primeira quebra de linha.

Nota: É uma boa prática recuar blocos lógicos de código em seu contexto relacionado para esclarecer a estrutura. Por exemplo, a sequência de linhas múltiplas pertencente à variável string.

Uma opção que parece faltar nas outras respostas (mencionada apenas no fundo por um comentário de naxa) é a seguinte:

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

Isso permitirá o alinhamento adequado, unirá as linhas implicitamente e ainda manterá a mudança de linha, o que, para mim, é uma das razões pelas quais eu gostaria de usar seqüências de múltiplas linhas de qualquer maneira.

Não requer pós-processamento, mas você precisa adicionar manualmente o \nlocal em que deseja que a linha termine. Inline ou como uma sequência separada depois. O último é mais fácil de copiar e colar.

Mais algumas opções. No Ipython com o pylab ativado, dedent já está no espaço para nome. Eu verifiquei e é do matplotlib. Ou pode ser importado com:

from matplotlib.cbook import dedent

Na documentação, afirma que é mais rápido que o equivalente a textwrap e, nos meus testes no ipython, é de fato três vezes mais rápido, em média, nos meus testes rápidos. Ele também tem o benefício de descartar qualquer linha em branco inicial, permitindo que você seja flexível na maneira como constrói a string:

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

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

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

O uso da dedução do matplotlib nesses três exemplos fornecerá o mesmo resultado sensato. A função dedent de quebra de texto terá uma linha em branco à esquerda com o 1º exemplo.

A desvantagem óbvia é que o textwrap está na biblioteca padrão enquanto o matplotlib é um módulo externo.

Algumas desvantagens aqui ... as funções dedent tornam seu código mais legível onde as strings são definidas, mas requerem processamento posterior para obter a string no formato utilizável. Nas docstrings, é óbvio que você deve usar o recuo correto, pois a maioria dos usos da docstring fará o processamento necessário.

Quando eu preciso de uma sequência não longa no meu código, encontro o seguinte código confessamente feio, em que deixo a sequência longa sair do recuo anexo. Definitivamente falha em "Bonito é melhor que feio.", Mas alguém poderia argumentar que é mais simples e mais explícito do que a alternativa dedente.

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

Se você deseja uma solução rápida e fácil e evita digitar novas linhas, pode optar por uma lista, por exemplo:

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

eu prefiro

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

ou

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

Meus dois centavos, escapam do final da linha para obter os recuos:

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

Eu vim aqui procurando um liner simples para remover / corrigir o nível de identificação do docstring para impressão, sem torná-lo desarrumado , por exemplo, deixando-o "fora da função" dentro do script.

Aqui está o que eu acabei fazendo:

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, se você estiver recuando com espaços (por exemplo, 4) em vez da tecla tab, use algo como isto:

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

E você não precisa remover o primeiro caractere se quiser que seus documentos sejam assim:

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

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

A primeira opção é a boa - com recuo incluído. É no estilo python - fornece legibilidade para o código.

Para exibi-lo corretamente:

print string.lstrip()

Depende de como você deseja que o texto seja exibido. Se você quiser que tudo fique alinhado à esquerda, formate-o como no primeiro trecho ou faça uma iteração pelas linhas, aparando à esquerda todo o espaço.

Para seqüências de caracteres, você pode processar a sequência logo após. Para documentos, você precisa depois processar a função. Aqui está uma solução para ambos que ainda é legível.

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__

Estou tendo um problema semelhante, o código ficou realmente ilegível usando multilinhas, eu criei algo como

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

sim, no começo poderia parecer terrível, mas a sintaxe incorporada era bastante complexa e adicionar algo no final (como '\ n "') não era uma solução

Você pode usar esta função 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
"""