web-dev-qa-db-fra.com

Envelopper les longues lignes dans Python

Comment insérer de longues lignes dans 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. La façon dont je l'ai lu, voici comment l'indenter:

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 de la fun(). Cela semble un peu moche. Si quelqu'un devait parcourir mon code, il serait mauvais d'avoir une indentation inégale à cause de cette instruction print.

Comment est-ce que j'indente efficacement de telles lignes sans sacrifier la lisibilité du code?

pythonstring
188
user225312
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 en savoir plus. Info.

253
pv2b

Il existe deux approches qui ne sont pas mentionnées ci-dessus, mais qui résolvent toutes les deux le problème d’une manière qui respecte 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 ajouter de signes plus entre des chaînes pures et de répartir le résultat sur plusieurs lignes sans qu'il soit nécessaire de poursuivre la ligne '\' (laide et encombrée). 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ù. Comparativement à l’alternative précédente, il est visuellement meilleur lors de l’inspection du code, car il indique clairement le début et la fin de msg (comparez avec msg += chaque ligne, ce qui nécessite une étape de réflexion supplémentaire les 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 devons souvent créer une chaîne à l'aide d'itérations et de contrôles dans le corps de l'itération. Par conséquent, 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 commence le message sur la ligne située au-dessous de print. La raison en est de gagner de la place à gauche, sinon le print( lui-même "vous pousse" vers la droite. Cette consommation d'indentation est héritée par le reste des lignes composant le message, car, conformément au PEP 8, elles doivent être alignées sur la parenthèse d'ouverture de print au-dessus d'eux. Donc, si votre message était déjà long, il sera forcément réparti sur encore plus de lignes.

Contraste:

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

avec ceci (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 à print, car il s'agit d'un appel court. Mais cela s'applique aux exceptions.

Une variation que vous pouvez avoir est la suivante:

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

Notez que vous n'avez pas besoin de signes plus entre les chaînes pures. En outre, l'indentation guide les yeux du lecteur, pas de parenthèses parasites qui pendent en bas à gauche. Les remplacements sont très lisibles. En particulier, une telle approche rend l’écriture de code générant du code ou des formules mathématiques très agréable.

72
Ioannis Filippidis

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.

22
SilentGhost

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)
19
Chris B.

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)
8
Mark Byers

Je suis surpris que personne n'ait mentionné le style implicite ci-dessus. Ma préférence est d'utiliser des parens pour envelopper la chaîne tout en alignant les lignes visuellement. 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 à onglets.

Notez que ces parenthèses ne font pas partie d'un appel de méthode - elles ne font que concaténation de chaînes de caractères implicites .

Python 2:

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

Python 3 (avec des parenthèses pour la fonction d'impression):

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

Personnellement, je pense que c’est plus propre de séparer concaténer le littéral de chaîne longue de l’imprimer:

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

S'il s'agit d'une longue chaîne (par exemple, pour une requête SQL), utilisez le code triple

'''
hello this is me 
'''
0
Nabin