Envelopper les longues lignes en Python

Question

Comment puis-je enveloppez les longues lignes en Python, sans sacrifier sur la mise en retrait de la partie?

Par exemple, considérez ceci:

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

Supposons que cela dépasse la 79 caractère limite recommandée. La façon dont je l'ai lu, ici, est de savoir comment indenter:

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

Cependant, avec cette approche, il y a un problème que j'ai. L'indentation de la ligne continue correspond à la mise en retrait de l' fun(). Cela ressemble un peu laid. Personnellement, je pense que si quelqu'un était de passer par mon code, il serait mauvais d'avoir inégale indentation cause de cette print déclaration.

Ma question est: comment puis-je tiret, des lignes comme ci-dessus de manière efficace, sans pour autant sacrifier la lisibilité du code?

Answer 1

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

Les littéraux de chaîne adjacents sont concaténés au moment de la compilation, comme en C. http://docs.python.org/reference/lexical_analysis.html#string-literal-concatenation est un bon point de départ pour obtenir plus d'informations.

Answer 2

Il existe deux approches qui ne sont pas mentionnés ci-dessus, mais qui résoudre le problème d'une manière qui est conforme à la PEP 8 et vous permettent de faire un meilleur usage de votre espace. Ils sont les suivants:

msg = (
    'This message is so long, that it requires '
    'more than ' + str(x) + 'lines.' + 2*'\n'
    'and you may want to add more.'
)
print(msg)

Remarquez comment les parenthèses sont utilisées pour nous permettre de ne pas ajouter plus de signes entre la pure chaînes, et de diffuser le résultat sur plusieurs lignes sans le besoin explicite de continuation de ligne '\' (laid et lourd). Les avantages sont les mêmes avec ce qui est décrit ci-dessous, la différence est que vous pouvez le faire n'importe où. Par rapport à la précédente alternative, c'est mieux visuellement lors de l'inspection du code, car il décrit le début et la fin de l' msg clairement (à comparer avec msg += une à chaque ligne, ce qui nécessite une réflexion complémentaire étape de déduire que ces lignes à ajouter à la même chaîne - et que si vous faites une faute de frappe, en oubliant un + sur une ligne aléatoire ?).

Au sujet de cette approche, de nombreuses fois nous avons à construire une chaîne de caractères à l'aide d'itérations et des contrôles au sein de l'itération corps, de sorte que l'ajout de ses pièces à l'intérieur de l'appel de la fonction, comme indiqué plus loin, n'est pas une option.

Un proche alternative est la suivante:

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)

Si la première est préférable.

L'autre approche est, comme les précédents, si elle commence le message sur la ligne en dessous de la print. La raison pour cela est de gagner de l'espace sur la gauche, sinon l' print( "pousse" vous vers la droite. Cette consommation de l'indentation est hérité par le reste des lignes comprenant le message, parce que, selon la PEP 8 ils doivent s'aligner avec l'ouverture de la parenthèse de l' print - dessus d'eux. Donc, si votre message est déjà longue, de cette façon, il est forcé de s'étaler sur encore plus de lignes.

Contraste:

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

avec cette (suggéré ici):

raise TypeError(
    'aaaaaaaaaaaaaaaaaaaaaaaa' +
    'aaaaaaaaaaaaaaaaaaaaaaaa'
)

La ligne de propagation a été réduite. Bien sûr, cette dernière approche ne s'applique pas tellement d' print, parce que c'est un court appel. Mais il s'applique à des exceptions.

Une variation, vous pouvez avoir est la suivante:

raise TypeError(
    'aaaaaaaaaaaaaaaaaaaaaaaa'
    'aaaaaaaaaaaaaaaaaaaaaaaa'
    'aaaaa' + str(x) + 'aaaaa'
)

Remarquez comment vous vous n'avez pas besoin d'avoir des signes plus pure entre les chaînes.

Answer 3

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

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

Vous avez juste besoin de mettre une chaîne entre parenthèses.

Answer 4

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

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

Answer 5

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

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

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

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