Comment faire un saut de ligne (continuation de ligne) en Python ?

Question

J'ai une longue ligne de code que je veux diviser en plusieurs lignes. Que dois-je utiliser et quelle est la syntaxe ?

Par exemple, en ajoutant un bouquet de chaînes de caractères,

e = 'a' + 'b' + 'c' + 'd'

et l'avoir en deux lignes comme ceci :

e = 'a' + 'b' +
    'c' + 'd'

Answer 1

Quelle est la ligne ? Vous pouvez avoir des arguments sur la ligne suivante sans aucun problème :

a = dostuff(blahblah1, blahblah2, blahblah3, blahblah4, blahblah5, 
            blahblah6, blahblah7)

Sinon, vous pouvez faire quelque chose comme ça :

if (a == True and
    b == False):

ou avec un saut de ligne explicite :

if a == True and \
   b == False:

Vérifiez le guide de style pour plus d'informations.

En utilisant les parenthèses, votre exemple peut être écrit sur plusieurs lignes :

a = ('1' + '2' + '3' +
    '4' + '5')

Le même effet peut être obtenu en utilisant un saut de ligne explicite :

a = '1' + '2' + '3' + \
    '4' + '5'

Notez que le guide de style indique qu'il est préférable d'utiliser la suite implicite avec des parenthèses, mais dans ce cas particulier, le simple fait d'ajouter des parenthèses autour de votre expression est probablement la mauvaise solution.

Answer 2

De PEP 8 -- Guide de style pour le code Python :

La meilleure façon d'envelopper les longues lignes est d'utiliser la continuation de ligne implicite de Python à l'intérieur des parenthèses, des crochets et des accolades. Les longues lignes peuvent être réparties sur plusieurs lignes en mettant les expressions entre parenthèses. Celles-ci doivent être utilisées de préférence à l'utilisation d'une barre oblique inverse pour la continuation de la ligne.

Les retours en arrière peuvent encore être appropriés à certains moments. Par exemple, les déclarations avec longues et multiples ne peuvent pas utiliser la continuation implicite, les barres obliques inversées sont donc acceptables :

with open('/path/to/some/file/you/want/to/read') as file_1, \
     open('/path/to/some/file/being/written', 'w') as file_2:
     file_2.write(file_1.read())

Un autre cas de figure est celui des déclarations d'assertion.

Veillez à mettre en retrait la ligne continue de manière appropriée. L'endroit préféré pour faire une pause autour d'un opérateur binaire est après l'opérateur, pas avant. Quelques exemples :

class Rectangle(Blob):

    def __init__(self, width, height,
                 color='black', emphasis=None, highlight=0):
        if (width == 0 and height == 0 and
            color == 'red' and emphasis == 'strong' or
            highlight > 100):
            raise ValueError("sorry, you lose")
        if width == 0 and height == 0 and (color == 'red' or
                                           emphasis is None):
            raise ValueError("I don't think so -- values are %s, %s" %
                             (width, height))
        Blob.__init__(self, width, height,
                      color, emphasis, highlight)file_2.write(file_1.read())

Le PEP8 recommande maintenant le convention contraire (pour briser les opérations binaires) utilisé par les mathématiciens et leurs éditeurs pour améliorer la lisibilité.

Le style de rupture de Donald Knuth avant un opérateur binaire aligne les opérateurs verticalement, ce qui réduit la charge de travail de l'œil lorsqu'il s'agit de déterminer les éléments à additionner et à soustraire.

De PEP8 : Une ligne doit-elle être coupée avant ou après un opérateur binaire ? :

Donald Knuth explique la règle traditionnelle dans sa série Computers and Typesetting : "Bien que les formules à l'intérieur d'un paragraphe s'interrompent toujours après les opérations binaires et les relations, les formules affichées s'interrompent toujours avant les opérations binaires" [3].

En suivant la tradition des mathématiques, on obtient généralement un code plus lisible :

# Yes: easy to match operators with operands

income = (gross_wages
          + taxable_interest
          + (dividends - qualified_dividends)
          - ira_deduction
          - student_loan_interest)

Dans le code Python, il est permis de casser avant ou après un opérateur binaire, tant que la convention est cohérente localement. Pour un nouveau code, le style de Knuth est suggéré.

[3] : Donald Knuth's The TeXBook, pages 195 et 196

Answer 3

Le danger d'utiliser une barre oblique inversée pour terminer une ligne est que si un espace blanc est ajouté après la barre oblique inversée (ce qui, bien sûr, est très difficile à voir), la barre oblique inversée ne fait plus ce que vous pensiez qu'elle faisait.

Voir les idiomes et anti-idiomes de Python (pour Python 2 o Python 3 ) pour en savoir plus.

Answer 4

Mettez un \ à la fin de la ligne ou entre parenthèses. ( .. ) . De IBM :

b = ((i1 < 20) and
     (i2 < 30) and
     (i3 < 40))

ou

b = (i1 < 20) and \
    (i2 < 30) and \
    (i3 < 40)

Answer 5

Vous pouvez interrompre les lignes entre les parenthèses et les accolades. De plus, vous pouvez ajouter le caractère backslash (barre oblique inversée) \ à une ligne pour la rompre explicitement :

x = (tuples_first_value,
     second_value)
y = 1 + \
    2