Comment garder proprement moins de 80-char largeur avec de longues chaînes?

Question

Je tente de garder mon code à 80 caractères ou moins de nos jours car je pense que cela semble plus esthétique, pour la plupart. Parfois, cependant, le code finit par avoir l'air pire si je dois mettre des sauts de ligne dans des endroits étranges.

Une chose que je n'ai pas encore compris, c'est comment gérer très bien les longues chaînes. Par exemple:

#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 

    #..... 

C'est fini! Mettre sur la ligne suivante ne sera pas aider non plus:

#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 

    #..... 

je pouvais utiliser les sauts de ligne, mais qui est affreux:

#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 

    #..... 

Que faire? Raccourcir la chaîne est une option mais je ne veux pas que la lisibilité de mes messages soit affectée par quelque chose d'aussi arbitraire que le nombre de niveaux d'indentation que le code a eu à ce moment-là.

Answer 1

Vous pouvez diviser la chaîne en deux:

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

plusieurs chaînes consécutifs dans la même expression sont automatiquement 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   

Notez la LOAD_CONST pour la ligne 3, le bytecode de la fonction contient une chaîne, déjà concaténée.

Si vous deviez ajouter un + à l'expression, deux constantes distinctes sont créées:

>>> 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 ne se replie sur les opérations binaires constantes au moment de la compilation (si +, *, - etc.), les optimisations peephole pour le compilateur d'octets. Ainsi, pour certaines concaténations de chaînes, le compilateur peut remplacer également + concaténation de chaînes de constantes avec le résultat concaténé. Voir peephole.c, pour les séquences (y compris les chaînes), cette optimisation est uniquement appliquée si le résultat est limité à 20 éléments (caractères) ou moins.