Enveloppez les longues lignes en Python

Comment envelopper les longues lignes en Python sans sacrifier l’indentation?

Par exemple:

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

Supposons que cela dépasse la limite recommandée de 79 caractères. Comme je le lis, voici comment le mettre en retrait:

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

Cependant, avec cette approche, l’indentation de la ligne continue correspond à l’indentation du fun() . Cela semble un peu moche. Si quelqu’un devait parcourir mon code, il serait malencontreux d’avoir une indentation inégale à cause de cette instruction d’ print .

Comment puis-je indenter des lignes de cette manière efficacement sans sacrifier la lisibilité du code?

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

Les chaînes littérales Adjecent sont concaténées au moment de la compilation, tout comme dans C. http://docs.python.org/reference/lexical_analysis.html#ssortingng-literal-concatenation est un bon sharepoint départ pour plus d’informations.

Deux approches ne sont pas mentionnées ci-dessus, mais les deux résolvent le problème d’une manière conforme à PEP 8 et vous permettent de mieux utiliser votre espace. Elles sont:

 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) 

Remarquez comment les parenthèses sont utilisées pour nous permettre de ne pas append de signes plus entre des chaînes pures, et répartissez le résultat sur plusieurs lignes sans avoir besoin d’une continuation de ligne explicite ‘\’ (laide et encombrée). Les avantages sont les mêmes que ceux décrits ci-dessous, la différence est que vous pouvez le faire n’importe où. Comparé à la précédente, il est visuellement meilleur lors de l’inspection du code, car il décrit clairement le début et la fin de msg (comparez avec msg += one à chaque ligne, ce qui nécessite une étape supplémentaire pour en déduire que ces lignes s’ajoutent à la même chaîne) – et si vous faites une faute de frappe, en oubliant un + sur une ligne aléatoire?).

En ce qui concerne cette approche, nous avons souvent besoin de construire une chaîne en utilisant des itérations et des vérifications dans le corps de l’itération. L’ajout de ses éléments dans l’appel de fonction, comme indiqué plus loin, n’est pas une option.

Une alternative proche est:

 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) 

Bien que le premier soit préférable.

L’autre approche est semblable aux précédentes, bien qu’elle lance le message sur la ligne sous l’ print . La raison en est de gagner de la place sur la gauche, sinon l’ print( elle-même “vous pousse” à droite. Cette consommation d’indentation est héritée par le rest des lignes composant le message, car selon PEP 8 elles doivent être alignées avec la parenthèse d’ouverture de l’ print au-dessus d’eux, donc si votre message était déjà long, de cette façon il est obligé de se répandre sur encore plus de lignes.

Contraste:

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

avec ceci (suggéré ici):

 raise TypeError( 'aaaaaaaaaaaaaaaaaaaaaaaa' + 'aaaaaaaaaaaaaaaaaaaaaaaa') 

La propagation de la ligne a été réduite. Bien entendu, cette dernière approche ne s’applique pas autant à l’ print , car il s’agit d’un appel de courte durée. Mais cela s’applique aux exceptions.

Une variante que vous pouvez avoir est:

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

Remarquez comment vous n’avez pas besoin d’avoir des signes plus entre les chaînes pures. En outre, l’indentation guide les yeux du lecteur, pas de parenthèses égarées suspendues en bas à gauche. Les remplacements sont très lisibles. En particulier, une telle approche rend très agréable l’écriture de code qui génère du code ou des formules mathématiques.

Vous pouvez utiliser le code suivant où l’indentation n’a pas d’importance:

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

Il suffit de joindre la chaîne entre parenthèses.

Vous pouvez utiliser le fait que Python concatène des littéraux de chaîne qui apparaissent adjacents les uns aux autres:

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

Je diviserais probablement la longue instruction en plusieurs instructions plus courtes afin que la logique du programme soit séparée de la définition de la chaîne longue:

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

Si la chaîne est juste trop longue et que vous choisissez un nom de variable court, vous éviterez peut-être même de diviser la chaîne:

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

S’il s’agit d’une chaîne longue (par exemple pour une requête SQL), utilisez un code sortingple

 ''' hello this is me ''' 

Je suis surpris que personne n’ait mentionné le style implicite ci-dessus. Je préfère utiliser parens pour envelopper la chaîne tout en alignant visuellement les lignes de la chaîne. Personnellement, je pense que cela semble plus propre et plus compact que de commencer le début de la chaîne sur une nouvelle ligne à tabs.

Notez que ces parens ne font pas partie d’un appel de méthode – ils ne sont qu’une concaténation littérale de chaîne implicite .

Python 2:

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

Python 3 (avec parens pour la fonction d’impression):

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

Personnellement, je pense qu’il est plus propre de séparer la chaîne littérale de la chaîne longue en l’imprimant:

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