Come mantenere pulito sotto una larghezza di 80 caratteri con stringhe lunghe?

Question

Attualmente sto cercando di mantenere il mio codice a 80 caratteri o meno al giorno d'oggi, perché penso che sia più esteticamente gradevole, per la maggior parte. A volte, però, il codice finisce per peggiorare se devo inserire interruzioni di riga in luoghi strani.

Una cosa che non ho capito come gestire molto bene è ancora stringhe lunghe. Ad esempio:

#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 

    #..... 

È finita! Mettere sulla riga successiva non aiuterà né:

#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 

    #..... 

ho potuto usare interruzioni di riga, ma che sembra terribile:

#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 

    #..... 

Cosa fare? Accorciare la stringa è un'opzione ma non voglio che la leggibilità dei miei messaggi sia influenzata da qualcosa di arbitrario come quanti livelli di indentazione il codice abbia avuto a quel punto.

Answer 1

È possibile dividere la stringa in due:

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

più stringhe consecutivi, nella stessa espressione sono automaticamente concatenated into one, at compile time:

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

Annotare il LOAD_CONST per la linea 3, il bytecode per la funzione contiene una stringa, già concatenata. Se si dovesse aggiungere un + all'espressione, vengono creati

due costanti distinte:

>>> 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 fa piegare operazioni binarie su costanti al momento della compilazione (così +, *, - ecc), in le ottimizzazioni dello spioncino per il compilatore di byte. Quindi per alcune concatenazioni di stringhe il compilatore può sostituire anche la concatenazione di stringa + di costanti con il risultato concatenato. Vedi peephole.c, per le sequenze (incluse le stringhe) questa ottimizzazione viene applicata solo se il risultato è limitato a 20 elementi (caratteri) o meno.