Modo Pythonic per creare una lunga stringa multilinea

Ho una domanda molto lunga. Vorrei dividerlo in più righe in Python. Un modo per farlo in JavaScript sarebbe usare diverse frasi e unirle a un +operatore (lo so, forse non è il modo più efficiente per farlo, ma non sono davvero preoccupato per le prestazioni in questa fase, solo la leggibilità del codice) . Esempio:

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

Ho provato a fare qualcosa di simile in Python, ma non ha funzionato, quindi \dividevo la lunga stringa. Tuttavia, non sono sicuro che questo sia l'unico / migliore / più pitone metodo per farlo. Sembra imbarazzante. Codice reale:

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

Stai parlando di stringhe multilinea? Facile, usa le virgolette triple per iniziare e terminarle.

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

Puoi usare anche virgolette singole (3 ovviamente all'inizio e alla fine) e trattare la stringa risultante scome qualsiasi altra stringa.

NOTA : Proprio come con qualsiasi stringa, qualsiasi cosa tra le virgolette iniziale e finale diventa parte della stringa, quindi questo esempio ha uno spazio vuoto iniziale (come sottolineato da @ root45). Questa stringa conterrà anche spazi vuoti e righe.

Vale a dire ,:

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

Infine, si possono anche costruire linee lunghe in Python in questo modo:

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

che non includerà ulteriori spazi vuoti o nuove righe (questo è un esempio deliberato che mostra quale sarà l'effetto di saltare gli spazi vuoti):

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

Non sono necessarie virgole, è sufficiente posizionare le stringhe da unire in una coppia di parentesi e assicurarsi di tenere conto di eventuali spazi vuoti e newline necessari.

Se non vuoi una stringa multilinea ma hai solo una lunga stringa a linea singola, puoi usare le parentesi, assicurati di non includere le virgole tra i segmenti di stringa, quindi sarà una 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)

In un'istruzione SQL come quella che stai costruendo, anche le stringhe multilinea andrebbero bene. Ma se lo spazio extra in una stringa multilinea contenesse sarebbe un problema, questo sarebbe un buon modo per ottenere ciò che desideri.

Rompere le linee \funziona per me. Ecco un esempio:

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

Mi sono trovato felice con questo:

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

Trovo che quando crei stringhe lunghe, di solito stai facendo qualcosa di simile alla creazione di una query SQL, nel qual caso è meglio:

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

Ciò che Levon ha suggerito è buono, ma potrebbe essere vulnerabile agli errori:

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

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

Puoi anche concatenare le variabili quando usi la notazione "" ":

foo = '1234'

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

EDIT: trovato un modo migliore, con nomi params 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)

Questo approccio utilizza:

• solo una barra rovesciata per evitare un avanzamento riga iniziale
• quasi nessuna punteggiatura interna usando una stringa a tre virgolette
• elimina il rientro locale usando il modulo textwrap inspect
• usa l'interpolazione di stringhe in formato Python 3.6 ('f') per le variabili account_ide def_id.

In questo modo sembra il più pitonico per me.

# 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}'''
)

Aggiornamento : 29/01/2019 Incorporare il suggerimento di @ ShadowRanger da utilizzare inspect.cleandocanzichétextwrap.dedent

In Python> = 3.6 puoi usare letterali stringa formattati (f string)

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

Per esempio:

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 il valore di condition dovrebbe essere una stringa, puoi fare così:

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

Trovo textwrap.dedentil meglio per stringhe lunghe come descritto qui :

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

Altri hanno già menzionato il metodo tra parentesi, ma vorrei aggiungere che con le parentesi sono consentiti commenti in linea.

Commenta su ogni frammento:

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

Commento non consentito dopo la continuazione:

Quando si utilizzano le continuazioni di riga rovesciata ( \), i commenti non sono consentiti. Riceverai un SyntaxError: unexpected character after line continuation charactererrore.

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

Commenti migliori per le stringhe Regex:

Sulla base dell'esempio di 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)

Personalmente trovo che quanto segue sia il modo migliore (semplice, sicuro e Pythonic) per scrivere query SQL non elaborate in Python, soprattutto quando si utilizza il modulo sqlite3 di 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

Professionisti

• Codice pulito e semplice (Pythonic!)
• Sicuro dall'iniezione SQL
• Compatibile con Python 2 e Python 3 (dopo tutto è Pythonic)
• Nessuna concatenazione di stringhe richiesta
• Non è necessario garantire che il carattere più giusto di ogni riga sia uno spazio

Contro

• Poiché le variabili nella query vengono sostituite dal ?segnaposto, potrebbe essere un po 'difficile tenere traccia di quale ?deve essere sostituita da quale variabile Python quando ce ne sono molte nella query.

Di solito uso qualcosa del genere:

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

Se vuoi rimuovere fastidiosi spazi vuoti in ogni riga, puoi fare come segue:

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

Il tuo codice attuale non dovrebbe funzionare, ti mancano gli spazi bianchi alla fine delle "righe" (ad esempio role.descr as roleFROM...:)

Esistono triplequote per la stringa multilinea:

string = """line
  line2
  line3"""

Conterrà le interruzioni di riga e gli spazi extra, ma per SQL non è un problema.

È inoltre possibile posizionare l'istruzione sql in un file separato action.sqle caricarlo nel file py con

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

Quindi le istruzioni sql saranno separate dal codice Python. Se nell'istruzione sql sono presenti parametri che devono essere compilati da Python, è possibile utilizzare la formattazione di stringhe (come% s o {field})

"A la Scala " (ma penso che sia il modo più pitonico come OQ richiede):

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 si desidera la str finale senza le linee di salto, basta inserire \nall'inizio del primo argomento del secondo sostituto:

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

Nota: la linea bianca tra "... modelli". e "Inoltre, ..." richiede uno spazio dopo il |.

tl; dr: usa """\e """per avvolgere la stringa , come in

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

Dalla documentazione ufficiale di Python :

I letterali stringa possono estendersi su più righe. Un modo è usare le virgolette: "" "..." "" o '' '...' ''. La fine delle righe viene automaticamente inclusa nella stringa, ma è possibile evitarlo aggiungendo un \ alla fine della riga. Il seguente esempio:

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

produce il seguente output (si noti che la nuova riga iniziale non è inclusa):

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

Ehi prova qualcosa come questa speranza che funzioni, come in questo formato ti restituirà una linea continua come se avessi indagato con successo su questa proprietà`

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

Uso una funzione ricorsiva per creare query SQL complesse. Questa tecnica può essere generalmente utilizzata per creare stringhe di grandi dimensioni mantenendo la leggibilità del codice.

# 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: dai un'occhiata alla fantastica libreria python-sqlparse per stampare graziose query SQL, se necessario. http://sqlparse.readthedocs.org/en/latest/api/#sqlparse.format

Un'altra opzione che ritengo più leggibile quando il codice (ad es. Variabile) è rientrato e la stringa di output dovrebbe essere una riga (senza righe):

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 

Usa le virgolette triple. Le persone spesso li usano per creare dotstring all'inizio dei programmi per spiegare il loro scopo e altre informazioni rilevanti per la sua creazione. Le persone li usano anche nelle funzioni per spiegare lo scopo e l'applicazione delle funzioni. Esempio:

'''
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!
    """)

Mi piace questo approccio perché privilegia la lettura. Nei casi in cui abbiamo stringhe lunghe non c'è modo! A seconda del livello di rientro in cui ti trovi e ancora limitato a 80 caratteri per riga ... Beh ... Non c'è bisogno di dire altro. A mio avviso, le guide di stile in pitone sono ancora molto vaghe. Ho adottato l'approccio @Eero Aaltonen perché privilegia la lettura e il buon senso. Capisco che le guide di stile dovrebbero aiutarci e non rendere la nostra vita un casino. Grazie!

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

Dalla documentazione ufficiale di Python :

I letterali stringa possono estendersi su più righe. Un modo è usare le virgolette: "" "..." "" o '' '...' ''. La fine delle righe viene automaticamente inclusa nella stringa, ma è possibile evitarlo aggiungendo un \ alla fine della riga. Il seguente esempio:

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

produce il seguente output (si noti che la nuova riga iniziale non è inclusa):

Per definire una stringa lunga all'interno di un dict, mantenendo le nuove righe ma omettendo gli spazi , ho finito per definire la stringa in una costante come questa:

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

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

Come approccio generale alle stringhe lunghe in Python puoi usare le virgolette triple 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())

Produzione:

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

Per quanto riguarda la domanda di OP relativa a una query SQL, la risposta che segue ignora la correttezza di questo approccio alla costruzione di query SQL e si concentra solo sulla costruzione di stringhe lunghe in modo leggibile ed estetico senza ulteriori importazioni. Ignora anche il carico computazionale che comporta.

Usando le virgolette triple costruiamo una stringa lunga e leggibile che poi suddividiamo in un elenco usando split()quindi lo spazio bianco e poi lo ricolleghiamo ' '.join(). Infine inseriamo le variabili usando il 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)

produce:

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

Modifica: questo approccio non è in linea con PEP8 ma lo trovo utile a volte

In genere, utilizzo liste joinper commenti / stringhe su più righe.

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)

puoi usare qualsiasi stringa per unire tutto questo elemento dell'elenco come ' \n' (newline) o ' ,' (virgola) o ' ' (spazio)

Saluti..!!