Manera "À la" Scala (pero creo que es la forma más pitónica como exige el OP):

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

Si desea una cadena final sin líneas de salto, simplemente coloque \n al comienzo del primer argumento del segundo reemplazo:

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

Nota: la línea blanca entre "...templates". y "También, ..." requiere un espacio en blanco después de | .

En Python> = 3.6 puede usar literales de cadena con formato (cadena 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}'''

Me gusta este enfoque porque privilegia la lectura. En los casos en los que tenemos cadenas largas ¡no hay manera! Dependiendo del nivel de sangría en el que se encuentre y todavía limitado a 80 caracteres por línea... Bueno... No es necesario decir nada más

En mi opinión, las guías de estilo de Python siguen siendo muy vagas. Tomé el enfoque de Eero Aaltonen , porque privilegia la lectura y el sentido común. Entiendo que las guías de estilo deben ayudarnos y no hacernos la vida un lío.

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

Otra opción que creo que es más legible cuando el código (por ejemplo, una variable) está sangrado y la cadena de salida debe ser de una sola línea (sin saltos de línea):

 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

Personalmente, considero que la siguiente es la mejor manera (simple, segura y Pythonic) de escribir consultas SQL sin procesar en Python, especialmente cuando se usa el módulo sqlite3 de 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

ventajas

• Código limpio y simple (¡Pythonic!)
• A salvo de inyección SQL
• Compatible con Python 2 y Python 3 (después de todo, es Pythonic)
• No se requiere concatenación de cadenas
• No es necesario asegurarse de que el carácter más a la derecha de cada línea sea un espacio

Contras

• Dado que las variables en la consulta se reemplazan por el ? marcador de posición, puede ser un poco difícil hacer un seguimiento de cuál ? se sustituirá por qué variable de Python cuando haya muchas en la consulta.

Este enfoque utiliza:

• casi no hay puntuación interna al usar una cadena entre comillas triples
• elimina la sangría local usando el módulo de inspect
• utiliza la interpolación de cadenas con formato de Python 3.6 ('f') para las variables account_id y def_id .

De esta manera me parece la más pitónica.

 import inspect 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}''' )

Usualmente uso algo como esto:

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

Si desea eliminar los molestos espacios en blanco en cada línea, puede hacer lo siguiente:

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

Encuentro textwrap.dedent el mejor para cadenas largas como se describe aquí :

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

Me encontré feliz con este:

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

Uso una función recursiva para crear consultas SQL complejas. Esta técnica generalmente se puede usar para construir cadenas grandes mientras se mantiene la legibilidad del 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)

PD: Eche un vistazo a la increíble biblioteca python-sqlparse para imprimir consultas SQL si es necesario.

También puede incluir variables al usar la notación """:

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

Una mejor manera es, con parámetros con nombre y .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)

Por ejemplo:

 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'

Si el valor de la condición debe ser una cadena, puede hacerlo así:

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

¿Estás hablando de cadenas de varias líneas? Fácil, usa comillas triples para comenzar y terminar.

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

También puede usar comillas simples (3 de ellas, por supuesto, al principio y al final) y tratar s cadenas resultantes como cualquier otra cadena.

NOTA : Al igual que con cualquier cadena, todo lo que se encuentre entre las comillas iniciales y finales se convierte en parte de la cadena, por lo que este ejemplo tiene un espacio en blanco inicial (como lo señaló @root45). Esta cadena también contendrá tanto espacios en blanco como saltos de línea.

Es decir,:

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

Finalmente, también se pueden construir líneas largas en Python como esta:

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

que no incluirá espacios en blanco ni saltos de línea adicionales (este es un ejemplo deliberado que muestra el efecto de omitir espacios en blanco):

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

No se requieren comas, simplemente coloque las cadenas que se unirán en un par de paréntesis y asegúrese de tener en cuenta los espacios en blanco y las nuevas líneas necesarias.

Su código real no debería funcionar; le faltan espacios en blanco al final de las "líneas" (por ejemplo, role.descr as roleFROM... ).

Hay comillas triples para cadenas de varias líneas:

 string = """line line2 line3"""

Contendrá saltos de línea y espacios adicionales, pero para SQL eso no es un problema.

Si no desea una cadena de varias líneas, pero solo tiene una cadena larga de una sola línea, puede usar paréntesis. Solo asegúrese de no incluir comas entre los segmentos de cadena (entonces será 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)

En una instrucción SQL como la que está construyendo, las cadenas de varias líneas también estarían bien. Pero si el espacio en blanco adicional que contendría una cadena de varias líneas fuera un problema, entonces esta sería una buena manera de lograr lo que desea.

Como se señaló en los comentarios, la concatenación de consultas SQL de esta manera es un riesgo de seguridad de inyección SQL que está a punto de ocurrir , así que use la función de consultas parametrizadas de su base de datos para evitar esto. Sin embargo, dejo la respuesta como está, ya que responde directamente a la pregunta formulada.

También puede colocar la instrucción SQL en un archivo separado, action.sql , y cargarlo en el archivo .py con:

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

Entonces, las declaraciones de SQL se separarán del código de Python. Si hay parámetros en la instrucción SQL que deben completarse desde Python, puede usar el formato de cadena (como %s o {field}).

Me parece que al construir cadenas largas, por lo general estás haciendo algo como construir una consulta SQL, en cuyo caso esto es lo mejor:

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

Lo que sugirió Levon es bueno, pero podría ser vulnerable a errores:

 query = ( "SELECT foo" "FROM bar" "WHERE baz" ) query == "SELECT fooFROM barWHERE baz" # Probably not what you want

Romper líneas por \ funciona para mí. Aquí hay un ejemplo:

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

Para definir una cadena larga dentro de un dictado, manteniendo las líneas nuevas pero omitiendo los espacios , terminé definiendo la cadena en una constante como esta:

 LONG_STRING = \ """ This is a long sting that contains newlines. The newlines are important. """ my_dict = { 'foo': 'bar', 'string': LONG_STRING }

Como enfoque general para cadenas largas en Python, puede usar comillas triples, split y 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())

Producción:

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

Con respecto a la pregunta de OP relacionada con una consulta SQL, la respuesta a continuación ignora la corrección de este enfoque para crear consultas SQL y se enfoca solo en crear cadenas largas de una manera legible y estética sin importaciones adicionales. También ignora la carga computacional que esto implica.

Usando comillas triples, construimos una cadena larga y legible que luego dividimos en una lista usando split() , eliminando así el espacio en blanco y luego volviéndolo a unir con ' '.join() . Finalmente insertamos las variables usando el comando format() :

 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

Este enfoque no está en línea con PEP 8 , pero a veces lo encuentro útil.

Tenga en cuenta que los corchetes en la cadena original son utilizados por la función format().

tl; dr: Use """\ y """ para envolver la cadena , como en

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

De la documentación oficial de Python :

Los literales de cadena pueden abarcar varias líneas. Una forma es usar comillas triples: """...""" o '''...'''. El final de las líneas se incluye automáticamente en la cadena, pero es posible evitarlo agregando \ al final de la línea. El siguiente ejemplo:

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

produce el siguiente resultado (tenga en cuenta que la nueva línea inicial no está incluida):

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

De la documentación oficial de Python :

Los literales de cadena pueden abarcar varias líneas. Una forma es usar comillas triples: """...""" o '''...'''. El final de las líneas se incluye automáticamente en la cadena, pero es posible evitarlo agregando \ al final de la línea. El siguiente ejemplo:

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

produce el siguiente resultado (tenga en cuenta que la nueva línea inicial no está incluida):

En general, uso list y join para comentarios/cadenas de varias líneas.

 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)

Puede usar cualquier cadena para unir todos estos elementos de la lista, como ' \n '(nueva línea) o ' , '(coma) o ' '(espacio).

Otros ya han mencionado el método de paréntesis, pero me gustaría agregar que con paréntesis, se permiten comentarios en línea.

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

Comentario no permitido después de la continuación:

Cuando se usan continuaciones de línea de barra invertida ( \ ), no se permiten comentarios. Recibirá un SyntaxError: unexpected character after line continuation character .

 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

Mejores comentarios para cadenas Regex:

Basado en el ejemplo 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)

Prueba algo como esto. Al igual que en este formato, le devolverá una línea continua como si hubiera consultado con éxito sobre esta propiedad:

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

Para simplemente repetir la misma letra 10 veces:

valor_cadena = "x" * 10

Ummm.

Sé que ha pasado mucho tiempo desde que se publicó esta pregunta. Pero acabo de encontrar el estilo que me gustaría usar para asignar cadenas largas y de varias líneas a variables en mis proyectos. Esto requiere un poco de tiempo de ejecución adicional, pero aún conserva la belleza del código, incluso si la variable a la que estoy asignando mi cadena está muy sangrada.

 # Suppose the following code is heavily indented line3header = "Third" variable = fr""" First line. Second line. {line3header} line. {{}} line. ... The last line. """.strip() """A variable whose name is Variable. You can even add a docstring here. """ variable = variable.format("Fourth") print(variable) variable += "\n" print(variable, end="")

Allí va.

Sé que es una pregunta bastante antigua, pero Python ha cambiado mientras tanto y no veo esta respuesta, así que aquí vamos.

Otra forma es usar \ para cortar la línea actual y pasar a otra:

 print("This line will \ get carried over to\ the new line.\ Notice how this\ word will be together because \ of no space around it")

Crear cadena

Las cadenas de Python se crean asignando contenido de cadena a una variable que se escribe dentro de comillas dobles o simples

 Str1 ="Ramesh" Str2 ='Mahesh' print(Str1) #Ramesh print(Str2) #Mahesh

Cadena de indexación

Extraer el contenido de la cadena (carácter) es útil usando el método de indexación donde la indexación de cadenas de Python comienza desde el índice cero (las cadenas de Python están indexadas a cero)

 Example of extracting string using positive string indexing : Str1 = "Ramesh" Str1[0] = "R" Str1[1] = "a" Str1[2] = "m" Str1[3] = "e" Str1[4] = "s" Str1[5] = "h"

Ejemplo de extracción de cadena usando indexación de cadena negativa:

 Str1 = "Ramesh" Str1[-6] = "R" Str1[-5] = "a" Str1[-4] = "m" Str1[-3] = "e" Str1[-2] = "s" Str1[-1] = "h"

print(Str1[0]) #'R'

print(Str1[0:]) #'Ramesh'

print(Str1[2:]) #'mesh'

print(Str1[:6]) #'Ramesh'

print(Str1[-1:]) #'Ramesh'

Manera pitónica de crear una cadena larga de varias líneas

 """Creating Python Comments. Python provides a single option to create a comment, using the pound sign, sometimes called the hash symbol Python Multiline Comments with Consecutive Single-Line Comments Python Multiline Comments with Multiline Strings """

Agregando a la respuesta de @ Levon ...

1. Cree una cadena multilínea como esta:

 paragraph = """this is a very long string if I had the energy to type more and more ...""" print(paragraph)

Producción:

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

Esta cadena tendrá líneas nuevas y espacios en blanco. Así que quítalos.

2. Eliminar espacios adicionales usando expresiones regulares

 paragraph = re.sub('\s+', ' ', paragraph) print(paragraph)

Salida:

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