python - standard - ¿Cómo mantener limpiamente el ancho de 80 caracteres con cuerdas largas?

python pep

Question

Estoy intentando mantener mi código a 80 caracteres o menos en la actualidad, ya que creo que se ve más agradable estéticamente, en su mayor parte. A veces, sin embargo, el código se ve peor si tengo que colocar saltos de línea en lugares extraños.

Una cosa que no he descubierto cómo manejar muy bien todavía son las cuerdas largas. Por ejemplo:

#0.........1........2........3........4.........5.........6.........7.........8xxxxxxxxx9xxxxxx
def foo():
    if conditional():
        logger.info("<Conditional''s meaning> happened, so we''re not setting up the interface.")
        return

    #.....

¡Se acabó! Ponerlo en la siguiente línea tampoco ayudará:

#0.........1........2........3........4.........5.........6.........7.........8xxxxxxxxx9xxxxxx
def foo():
    if conditional():
        logger.info(
            "<Conditional''s meaning> happened, so we''re not setting up the interface.")
        return

    #.....

Podría usar saltos de línea, pero eso se ve horrible:

#0.........1........2........3........4.........5.........6.........7.........8
def foo():
    if conditional():
        logger.info(
            "<Conditional''s meaning> happened, so we''re not setting /
up the interface.")
        return

    #.....

¿Qué hacer? Acortar la cadena es una opción, pero no quiero que la legibilidad de mis mensajes se vea afectada por algo tan arbitrario como cuántos niveles de sangrado tiene el código en ese momento.

Answer 1

Puedes dividir la cadena en dos:

def foo():
    if conditional():
        logger.info("<Conditional''s meaning> happened, so we''re not "
                    "setting up the interface.")

Varias cadenas consecutivas dentro de la misma expresión se concatenan automáticamente en una sola, en el momento de la compilación :

>>> def foo():
...     if conditional():
...         logger.info("<Conditional''s meaning> happened, so we''re not "
...                     "setting up the interface.")
... 
>>> import dis
>>> dis.dis(foo)
  2           0 LOAD_GLOBAL              0 (conditional)
              3 CALL_FUNCTION            0
              6 POP_JUMP_IF_FALSE       25

  3           9 LOAD_GLOBAL              1 (logger)
             12 LOAD_ATTR                2 (info)
             15 LOAD_CONST               1 ("<Conditional''s meaning> happened, so we''re not setting up the interface.")
             18 CALL_FUNCTION            1
             21 POP_TOP             
             22 JUMP_FORWARD             0 (to 25)
        >>   25 LOAD_CONST               0 (None)
             28 RETURN_VALUE        

Tenga en cuenta que LOAD_CONST para la línea 3, el LOAD_CONST de LOAD_CONST para la función contiene una cadena, ya concatenada.

Si tuviera que agregar un + a la expresión, se crearán dos constantes separadas:

>>> def foo():
...     if conditional():
...         logger.info("<Conditional''s meaning> happened, so we''re not " + 
...                     "setting up the interface.")
... 
>>> dis.dis(foo)
  2           0 LOAD_GLOBAL              0 (conditional)
              3 CALL_FUNCTION            0
              6 POP_JUMP_IF_FALSE       29

  3           9 LOAD_GLOBAL              1 (logger)
             12 LOAD_ATTR                2 (info)
             15 LOAD_CONST               1 ("<Conditional''s meaning> happened, so we''re not ")

  4          18 LOAD_CONST               2 (''setting up the interface.'')
             21 BINARY_ADD          
             22 CALL_FUNCTION            1
             25 POP_TOP             
             26 JUMP_FORWARD             0 (to 29)
        >>   29 LOAD_CONST               0 (None)
             32 RETURN_VALUE        

Python dobla operaciones binarias en constantes en tiempo de compilación (por lo tanto, + , * , - etc.), en las optimizaciones de mirilla para el compilador de bytes. Por lo tanto, para ciertas concatenaciones de cadenas, el compilador también puede reemplazar + concatenación de cadenas de constantes con el resultado concatenado. Consulte peephole.c , para las secuencias (incluidas las cadenas), esta optimización solo se aplica si el resultado está limitado a 20 elementos (caracteres) o menos.