Maneira pitônica de criar uma longa cadeia de várias linhas

Eu tenho uma consulta muito longa. Eu gostaria de dividi-lo em várias linhas em Python. Uma maneira de fazer isso em JavaScript seria usar várias frases e juntá-las a um +operador (eu sei, talvez não seja a maneira mais eficiente de fazer isso, mas não estou realmente preocupado com o desempenho nesta fase, apenas com a legibilidade do código) . Exemplo:

var long_string = 'some text not important. just garbage to' +
                  'illustrate my example';

Eu tentei fazer algo semelhante em Python, mas não funcionou, então eu costumava \dividir a cadeia longa. No entanto, não tenho certeza se essa é a única / melhor / pitônica maneira de fazê-lo. Parece estranho. Código atual:

query = 'SELECT action.descr as "action", '\
    'role.id as role_id,'\
    'role.descr as role'\
    'FROM '\
    'public.role_action_def,'\
    'public.role,'\
    'public.record_def, '\
    'public.action'\
    'WHERE role.id = role_action_def.role_id AND'\
    'record_def.id = role_action_def.def_id AND'\
    'action.id = role_action_def.action_id AND'\
    'role_action_def.account_id = ' + account_id + ' AND'\
    'record_def.account_id=' + account_id + ' AND'\
    'def_id=' + def_id

Você está falando sobre cadeias de linhas múltiplas? Fácil, use aspas triplas para iniciá-las e finalizá-las.

s = """ this is a very
        long string if I had the
        energy to type more and more ..."""

Você também pode usar aspas simples (3 delas no início e no final) e tratar a sequência resultante scomo qualquer outra sequência.

NOTA : Assim como em qualquer string, qualquer coisa entre as aspas inicial e final torna-se parte da string, portanto, este exemplo tem um espaço em branco à esquerda (conforme indicado por @ root45). Essa sequência também conterá espaços em branco e novas linhas.

Ou seja:

' this is a very\n        long string if I had the\n        energy to type more and more ...'

Finalmente, também é possível construir longas filas em Python assim:

 s = ("this is a very"
      "long string too"
      "for sure ..."
     )

que não incluirá espaços em branco extras ou novas linhas (este é um exemplo deliberado que mostra em que resultado o efeito de pular espaços em branco):

'this is a verylong string toofor sure ...'

Não são necessárias vírgulas, basta colocar as cadeias a serem unidas entre parênteses e certifique-se de levar em conta quaisquer espaços em branco e novas linhas necessários.

Se você não deseja uma sequência de linhas múltiplas, mas apenas possui uma cadeia de linhas única longa, pode usar parênteses, mas não incluir vírgulas entre os segmentos da sequência, será uma tupla.

query = ('SELECT   action.descr as "action", '
         'role.id as role_id,'
         'role.descr as role'
         ' FROM '
         'public.role_action_def,'
         'public.role,'
         'public.record_def, '
         'public.action'
         ' WHERE role.id = role_action_def.role_id AND'
         ' record_def.id = role_action_def.def_id AND'
         ' action.id = role_action_def.action_id AND'
         ' role_action_def.account_id = '+account_id+' AND'
         ' record_def.account_id='+account_id+' AND'
         ' def_id='+def_id)

Em uma instrução SQL como a que você está construindo, cadeias de linhas múltiplas também seriam boas. Mas se o espaço em branco extra que uma sequência multilinha contiver seria um problema, seria uma boa maneira de conseguir o que você deseja.

Quebrar linhas por \obras para mim. Aqui está um exemplo:

longStr = "This is a very long string " \
        "that I wrote to help somebody " \
        "who had a question about " \
        "writing long strings in Python"

Fiquei feliz com este:

string = """This is a
very long string,
containing commas,
that I split up
for readability""".replace('\n',' ')

Descobri que, ao criar seqüências longas, você geralmente está fazendo algo como criar uma consulta SQL; nesse caso, é melhor:

query = ' '.join((  # note double parens, join() takes an iterable
    "SELECT foo",
    "FROM bar",
    "WHERE baz",
))

O que Levon sugeriu é bom, mas pode estar vulnerável a erros:

query = (
    "SELECT foo"
    "FROM bar"
    "WHERE baz"
)

query == "SELECT fooFROM barWHERE baz"  # probably not what you want

Você também pode concatenar variáveis ​​ao usar a notação "" ":

foo = '1234'

long_string = """fosdl a sdlfklaskdf as
as df ajsdfj asdfa sld
a sdf alsdfl alsdfl """ +  foo + """ aks
asdkfkasdk fak"""

EDIT: Encontrei uma maneira melhor, com parâmetros nomeados e .format ():

body = """
<html>
<head>
</head>
<body>
    <p>Lorem ipsum.</p>
    <dl>
        <dt>Asdf:</dt>     <dd><a href="{link}">{name}</a></dd>
    </dl>
    </body>
</html>
""".format(
    link='http://www.asdf.com',
    name='Asdf',
)

print(body)

Essa abordagem usa:

• apenas uma barra invertida para evitar um avanço de linha inicial
• quase nenhuma pontuação interna usando uma cadeia de caracteres tripla entre aspas
• retira o recuo local usando o módulo textwrap inspect
• usos Python 3.6 formatado interpolação string ( 'f') para o account_ide def_idvariáveis.

Este caminho me parece o mais pitônico.

# import textwrap  # See update to answer below
import inspect

# query = textwrap.dedent(f'''\
query = inspect.cleandoc(f'''
    SELECT action.descr as "action", 
    role.id as role_id,
    role.descr as role
    FROM 
    public.role_action_def,
    public.role,
    public.record_def, 
    public.action
    WHERE role.id = role_action_def.role_id AND
    record_def.id = role_action_def.def_id AND
    action.id = role_action_def.action_id AND
    role_action_def.account_id = {account_id} AND
    record_def.account_id={account_id} AND
    def_id={def_id}'''
)

Atualização : 29/01/2019 Incorpore a sugestão do @ ShadowRanger de usar em inspect.cleandocvez detextwrap.dedent

Em Python> = 3.6, você pode usar literais de string formatada (string f)

query= f'''SELECT   action.descr as "action"
    role.id as role_id,
    role.descr as role
    FROM
    public.role_action_def,
    public.role,
    public.record_def,
    public.action
    WHERE role.id = role_action_def.role_id AND
    record_def.id = role_action_def.def_id AND
    action.id = role_action_def.action_id AND
    role_action_def.account_id = {account_id} AND
    record_def.account_id = {account_id} AND
    def_id = {def_id}'''

Por exemplo:

sql = ("select field1, field2, field3, field4 "
       "from table "
       "where condition1={} "
       "and condition2={}").format(1, 2)

Output: 'select field1, field2, field3, field4 from table 
         where condition1=1 and condition2=2'

se o valor da condição deve ser uma sequência, você pode fazer o seguinte:

sql = ("select field1, field2, field3, field4 "
       "from table "
       "where condition1='{0}' "
       "and condition2='{1}'").format('2016-10-12', '2017-10-12')

Output: "select field1, field2, field3, field4 from table where
         condition1='2016-10-12' and condition2='2017-10-12'"

Acho textwrap.dedento melhor para seqüências longas, como descrito aqui :

def create_snippet():
    code_snippet = textwrap.dedent("""\
        int main(int argc, char* argv[]) {
            return 0;
        }
    """)
    do_something(code_snippet)

Outros já mencionaram o método entre parênteses, mas eu gostaria de acrescentar que, entre parênteses, comentários embutidos são permitidos.

Comente sobre cada fragmento:

nursery_rhyme = (
    'Mary had a little lamb,'          # Comments are great!
    'its fleece was white as snow.'
    'And everywhere that Mary went,'
    'her sheep would surely go.'       # What a pesky sheep.
)

Comentário não permitido após continuação:

Ao usar continuações de linha de barra invertida ( \), comentários não são permitidos. Você receberá um SyntaxError: unexpected character after line continuation charactererro.

nursery_rhyme = 'Mary had a little lamb,' \  # These comments
    'its fleece was white as snow.'       \  # are invalid!
    'And everywhere that Mary went,'      \
    'her sheep would surely go.'
# => SyntaxError: unexpected character after line continuation character

Melhores comentários para as seqüências de caracteres Regex:

Com base no exemplo de https://docs.python.org/3/library/re.html#re.VERBOSE ,

a = re.compile(
    r'\d+'  # the integral part
    r'\.'   # the decimal point
    r'\d*'  # some fractional digits
)

# Using VERBOSE flag, IDE usually can't syntax highight the string comment.
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)

Pessoalmente, acho a seguinte a melhor (simples, segura e Pythonic) maneira de escrever consultas SQL brutas em Python, especialmente ao usar o módulo sqlite3 do Python :

query = '''
    SELECT
        action.descr as action,
        role.id as role_id,
        role.descr as role
    FROM
        public.role_action_def,
        public.role,
        public.record_def,
        public.action
    WHERE
        role.id = role_action_def.role_id
        AND record_def.id = role_action_def.def_id
        AND action.id = role_action_def.action_id
        AND role_action_def.account_id = ?
        AND record_def.account_id = ?
        AND def_id = ?
'''
vars = (account_id, account_id, def_id)   # a tuple of query variables
cursor.execute(query, vars)   # using Python's sqlite3 module

Prós

• Código puro e simples (Pythonic!)
• Seguro contra injeção de SQL
• Compatível com o Python 2 e o Python 3 (afinal, é Pythonic)
• Nenhuma concatenação de string necessária
• Não é necessário garantir que o caractere mais à direita de cada linha seja um espaço

Contras

• Como as variáveis ​​na consulta são substituídas pelo ?espaço reservado, pode ser um pouco difícil controlar qual ?deve ser substituído por qual variável Python quando houver muitas na consulta.

Eu costumo usar algo como isto:

text = '''
    This string was typed to be a demo
    on how could we write a multi-line
    text in Python.
'''

Se você deseja remover espaços em branco irritantes em cada linha, faça o seguinte:

text = '\n'.join(line.lstrip() for line in text.splitlines())

Seu código real não deve funcionar, faltam espaços em branco no final de "linhas" (por exemplo role.descr as roleFROM...:)

Há citações triplas para sequência de várias linhas:

string = """line
  line2
  line3"""

Ele conterá as quebras de linha e espaços extras, mas para SQL isso não é um problema.

Você também pode colocar a instrução sql em um arquivo separado action.sqle carregá-la no arquivo py com

with open('action.sql') as f:
   query = f.read()

Portanto, as instruções sql serão separadas do código python. Se houver parâmetros na instrução sql que precisem ser preenchidos com python, você poderá usar a formatação de strings (como% s ou {field})

Maneira "à la" Scala (mas acho que é a maneira mais pitônica que o OQ exige):

description = """
            | The intention of this module is to provide a method to 
            | pass meta information in markdown_ header files for 
            | using it in jinja_ templates. 
            | 
            | Also, to provide a method to use markdown files as jinja 
            | templates. Maybe you prefer to see the code than 
            | to install it.""".replace('\n            | \n','\n').replace('            | ',' ')

Se você deseja str final sem linhas de salto, basta colocar \nno início do primeiro argumento do segundo substituir:

.replace('\n            | ',' ')`.

Nota: a linha branca entre "... modelos". e "Além disso, ..." requer um espaço em branco após o |.

tl; dr: use """\e """para quebrar a sequência , como em

string = """\
This is a long string
spanning multiple lines.
"""

Na documentação oficial do python :

Literais de string podem abranger várias linhas. Uma maneira é usar aspas triplas: "" "..." "" ou '' '...' ''. O fim das linhas é incluído automaticamente na string, mas é possível evitar isso adicionando um \ no final da linha. O exemplo a seguir:

print("""\
Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to
""")

produz a seguinte saída (observe que a nova linha inicial não está incluída):

Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to

Ei, tente algo como esta esperança que funcione, como neste formato, você retornará uma linha contínua, como você perguntou com sucesso sobre essa propriedade`

"message": f'you have successfully inquired about '
           f'{enquiring_property.title} Property owned by '
           f'{enquiring_property.client}'

Eu uso uma função recursiva para criar consultas SQL complexas. Essa técnica geralmente pode ser usada para criar cadeias grandes, mantendo a legibilidade do código.

# Utility function to recursively resolve SQL statements.
# CAUTION: Use this function carefully, Pass correct SQL parameters {},
# TODO: This should never happen but check for infinite loops
def resolveSQL(sql_seed, sqlparams):
    sql = sql_seed % (sqlparams)
    if sql == sql_seed:
        return ' '.join([x.strip() for x in sql.split()])
    else:
        return resolveSQL(sql, sqlparams)

PS: Dê uma olhada na incrível biblioteca python-sqlparse para imprimir consultas SQL, se necessário. http://sqlparse.readthedocs.org/en/latest/api/#sqlparse.format

Outra opção que eu acho que é mais legível quando o código (por exemplo, variável) é recuado e a string de saída deve ser um liner (sem novas linhas):

def some_method():

    long_string = """
a presumptuous long string 
which looks a bit nicer 
in a text editor when
written over multiple lines
""".strip('\n').replace('\n', ' ')

    return long_string 

Use aspas triplas. As pessoas costumam usá-las para criar documentos no início dos programas para explicar seus propósitos e outras informações relevantes para sua criação. As pessoas também as usam em funções para explicar o objetivo e a aplicação das funções. Exemplo:

'''
Filename: practice.py
File creator: me
File purpose: explain triple quotes
'''


def example():
    """This prints a string that occupies multiple lines!!"""
    print("""
    This
    is 
    a multi-line
    string!
    """)

Eu gosto dessa abordagem porque privilegia a leitura. Nos casos em que temos longas cordas, não há como! Dependendo do nível de indentação em que você se encontra e ainda limitado a 80 caracteres por linha ... Bem ... Não há necessidade de dizer mais nada. Na minha opinião, os guias de estilo python ainda são muito vagos. Adotei a abordagem @Eero Aaltonen, porque privilegia a leitura e o bom senso. Entendo que os guias de estilo devem nos ajudar e não tornar nossa vida uma bagunça. Obrigado!

class ClassName():
    def method_name():
        if condition_0:
            if condition_1:
                if condition_2:
                    some_variable_0 =\
"""
some_js_func_call(
    undefined, 
    {
        'some_attr_0': 'value_0', 
        'some_attr_1': 'value_1', 
        'some_attr_2': '""" + some_variable_1 + """'
    }, 
    undefined, 
    undefined, 
    true
)
"""

Na documentação oficial do python :

Literais de string podem abranger várias linhas. Uma maneira é usar aspas triplas: "" "..." "" ou '' '...' ''. O fim das linhas é incluído automaticamente na string, mas é possível evitar isso adicionando um \ no final da linha. O exemplo a seguir:

print("""\
Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to
""")

produz a seguinte saída (observe que a nova linha inicial não está incluída):

Para definir uma string longa dentro de um dict, mantendo as novas linhas, mas omitindo os espaços , acabei definindo a string em uma constante assim:

LONG_STRING = \
"""
This is a long sting
that contains newlines.
The newlines are important.
"""

my_dict = {
   'foo': 'bar',
   'string': LONG_STRING
}

Como uma abordagem geral para seqüências longas em Python, você pode usar aspas triplas splite join:

_str = ' '.join('''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.'''.split())

Resultado:

'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.'

Com relação à pergunta do OP relacionada a uma consulta SQL, a resposta abaixo desconsidera a correção dessa abordagem na criação de consultas SQL e se concentra apenas na criação de cadeias longas de maneira legível e estética, sem importações adicionais. Também desconsidera a carga computacional que isso implica.

Usando aspas triplas, construímos uma string longa e legível, que depois dividimos em uma lista split(), eliminando o espaço em branco e juntando-a novamente ' '.join(). Finalmente, inserimos as variáveis ​​usando o format()comando:

account_id = 123
def_id = 321

_str = '''
    SELECT action.descr AS "action", role.id AS role_id, role.descr AS role 
    FROM public.role_action_def, public.role, public.record_def, public.action
    WHERE role.id = role_action_def.role_id 
    AND record_def.id = role_action_def.def_id 
    AND' action.id = role_action_def.action_id 
    AND role_action_def.account_id = {} 
    AND record_def.account_id = {} 
    AND def_id = {}
    '''

query = ' '.join(_str.split()).format(account_id, account_id, def_id)

Produz:

SELECT action.descr AS "action", role.id AS role_id, role.descr AS role FROM public.role_action_def, public.role, public.record_def, public.action WHERE role.id = role_action_def.role_id AND record_def.id = role_action_def.def_id AND\' action.id = role_action_def.action_id AND role_action_def.account_id = 123 AND record_def.account_id=123 AND def_id=321

Edit: Esta abordagem não está de acordo com o PEP8, mas acho útil às vezes

Geralmente, eu uso liste joinpara comentários / linhas com várias linhas.

lines = list()
lines.append('SELECT action.enter code here descr as "action", ')
lines.append('role.id as role_id,')
lines.append('role.descr as role')
lines.append('FROM ')
lines.append('public.role_action_def,')
lines.append('public.role,')
lines.append('public.record_def, ')
lines.append('public.action')
query = " ".join(lines)

você pode usar qualquer sequência para juntar todo esse elemento da lista como ' \n' (nova linha) ou ' ,' (vírgula) ou ' ' (espaço)

Felicidades..!!