texto - salto de linea python

Ajustar las líneas largas en Python

Question

Esta pregunta ya tiene una respuesta aquí:

• Cómo escribir una cadena muy larga que cumpla con PEP8 y evite E501 6 respuestas

¿Cómo envuelvo las líneas largas en Python sin sacrificar la sangría?

Por ejemplo:

def fun():
    print ''{0} Here is a really long sentence with {1}''.format(3, 5)

Supongamos que esto supera el límite recomendado de 79 caracteres. La forma en que lo leo, aquí es cómo sangrarlo:

def fun():
    print ''{0} Here is a really long /
sentence with {1}''.format(3, 5)

Sin embargo, con este enfoque, la sangría de la línea continua coincide con la sangría de la fun() . Esto se ve feo. Si alguien revisara mi código, se vería mal tener una sangría desigual debido a esta declaración print .

¿Cómo sangrado las líneas de esta manera de manera efectiva sin sacrificar la legibilidad del código?

Answer 1

Hay dos enfoques que no se mencionaron anteriormente, pero que resuelven el problema de una manera que cumple con PEP 8 y le permiten hacer un mejor uso de su espacio. Son:

msg = (
    ''This message is so long, that it requires ''
    ''more than {x} lines.{sep}''
    ''and you may want to add more.'').format(
        x=x, sep=2*''/n'')
print(msg)

Observe cómo se usan los paréntesis para permitir que no agreguemos signos más entre cadenas puras, y distribuya el resultado en varias líneas sin la necesidad de continuar la línea explícitamente '''' (feo y abarrotado). Las ventajas son las mismas que se describen a continuación, la diferencia es que puede hacerlo en cualquier lugar. En comparación con la alternativa anterior, es visualmente mejor cuando se inspecciona el código, ya que describe claramente el inicio y el final del msg (compare con msg += uno en cada línea, que necesita un paso de pensamiento adicional para deducir que esas líneas se agregan a la misma cadena - ¿Y si haces un error tipográfico, olvidando un + en una línea al azar?).

Con respecto a este enfoque, muchas veces tenemos que construir una cadena usando iteraciones y verificaciones dentro del cuerpo de la iteración, por lo que agregar sus piezas dentro de la llamada a la función, como se muestra más adelante, no es una opción.

Una alternativa cercana es:

msg = ''This message is so long, that it requires ''
msg += ''many lines to write, one reason for that/n''
msg += ''is that it contains numbers, like this ''
msg += ''one: '' + str(x) +'', which take up more space/n''
msg += ''to insert. Note how newlines are also included ''
msg += ''and can be better presented in the code itself.''
print(msg)

Aunque el primero es preferible.

El otro enfoque es como los anteriores, aunque comienza el mensaje en la línea debajo de la print . La razón para esto es ganar espacio a la izquierda, de lo contrario, la print( sí misma "lo empuja" hacia la derecha. Este consumo de sangría es heredado por el resto de las líneas que componen el mensaje, porque según PEP 8 deben alinearse con el paréntesis de apertura de la print encima de ellos. Por lo tanto, si su mensaje ya era largo, de esta manera se lo forzaría a extenderse en más líneas.

Contraste:

raise TypeError(''aaaaaaaaaaaaaaaa'' +
                ''aaaaaaaaaaaaaaaa'' +
                ''aaaaaaaaaaaaaaaa'')

con esto (sugerido aquí):

raise TypeError(
    ''aaaaaaaaaaaaaaaaaaaaaaaa'' +
    ''aaaaaaaaaaaaaaaaaaaaaaaa'')

La extensión de línea se redujo. Por supuesto, este último enfoque no se aplica tanto a la print , porque es una llamada corta. Pero se aplica a las excepciones.

Una variación que puede tener es:

raise TypeError((
    ''aaaaaaaaaaaaaaaaaaaaaaaa''
    ''aaaaaaaaaaaaaaaaaaaaaaaa''
    ''aaaaa {x} aaaaa'').format(x=x))

Observe cómo no necesita tener signos más entre cadenas puras. Además, la sangría guía los ojos del lector, sin paréntesis parásitos que cuelgan debajo a la izquierda. Los reemplazos son muy legibles. En particular, tal enfoque hace que escribir código que genere código o fórmulas matemáticas sea una tarea muy agradable.

Answer 2

Me sorprende que nadie haya mencionado el estilo implícito anterior. Mi preferencia es utilizar parens para envolver la cadena mientras alinea visualmente las líneas de cadena. Personalmente, creo que se ve más limpio y más compacto que comenzar el hilo en una nueva línea con pestañas.

Tenga en cuenta que estos paréntesis no son parte de una llamada al método; solo son concatenación literal de cadena implícita .

Python 2:

def fun():
    print (''{0} Here is a really ''
           ''long sentence with {1}'').format(3, 5)

Python 3 (con parens para la función de impresión):

def fun():
    print((''{0} Here is a really ''
           ''long sentence with {1}'').format(3, 5))

Personalmente creo que es más limpio separar la concatenación de la larga cadena literal de la impresión:

def fun():
    s = (''{0} Here is a really ''
         ''long sentence with {1}'').format(3, 5)
    print(s)

Answer 3

Probablemente dividiría la declaración larga en múltiples declaraciones más cortas para que la lógica del programa esté separada de la definición de la cadena larga:

>>> def fun():
...     format_string = ''{0} Here is a really long '' /
...                     ''sentence with {1}''
...     print format_string.format(3, 5)

Si la cadena es solo demasiado larga y eliges un nombre de variable corto, al hacerlo podrías evitar tener que dividir la cadena:

>>> def fun():
...     s = ''{0} Here is a really long sentence with {1}''
...     print s.format(3, 5)

Answer 4

Puede usar el siguiente código donde la sangría no importa:

>>> def fun():
        return (''{0} Here is a really long''
        '' sentence with {1}'').format(3, 5)

Solo necesita encerrar la cadena entre paréntesis.

Answer 5

Puede utilizar el hecho de que Python concatena literales de cadena que aparecen adyacentes entre sí:

>>> def fun():
...     print ''{0} Here is a really long '' /
...           ''sentence with {1}''.format(3, 5)

Answer 6

Si es para cadena larga (por ejemplo, para consulta SQL), use código triple

''''''
hello
this 
is me 
''''''

Answer 7

def fun():
    print((''{0} Here is a really long ''
           ''sentence with {1}'').format(3, 5))

Los literales de cadena Adjecent se concatenan en tiempo de compilación, al igual que en C. http://docs.python.org/reference/lexical_analysis.html#string-literal-concatenation es un buen lugar para comenzar para obtener más información.