Comment puis-je rompre cette longue ligne en Python?

Comment feriez-vous pour formater une longue ligne comme celle-ci? Je souhaite que la largeur ne dépasse pas 80 caractères:

logger.info("Skipping {0} because its thumbnail was already in our system as {1}.".format(line[indexes['url']], video.title))

Est-ce ma meilleure option?

url = "Skipping {0} because its thumbnail was already in our system as {1}."
logger.info(url.format(line[indexes['url']], video.title))

C'est un début. Ce n'est pas une mauvaise pratique de définir vos chaînes plus longues en dehors du code qui les utilise. C'est un moyen de séparer les données et le comportement. Votre première option est de joindre implicitement les littéraux de chaîne en les rendant adjacents les uns aux autres:

("This is the first line of my text, "
"which will be joined to a second.")

Ou avec des continuations de fin de ligne, ce qui est un peu plus fragile, car cela fonctionne:

"This is the first line of my text, " \
"which will be joined to a second."

Mais cela ne:

"This is the first line of my text, " \ 
"which will be joined to a second."

Regarde la différence? Non? Eh bien, vous ne le ferez pas non plus quand c'est votre code.

L'inconvénient de la jointure implicite est qu'elle ne fonctionne qu'avec des chaînes littérales, pas avec des chaînes extraites de variables, donc les choses peuvent devenir un peu plus velues lorsque vous refactorisez. En outre, vous ne pouvez interpoler la mise en forme que sur la chaîne combinée dans son ensemble.

Alternativement, vous pouvez rejoindre explicitement en utilisant l'opérateur de concaténation ( +):

("This is the first line of my text, " + 
"which will be joined to a second.")

Explicite vaut mieux qu'implicite, comme le dit le zen de python, mais cela crée trois chaînes au lieu d'une, et utilise deux fois plus de mémoire: il y a les deux que vous avez écrites, plus une qui est les deux réunies, donc vous faut savoir quand ignorer le zen. L'avantage est que vous pouvez appliquer la mise en forme à l'une des sous-chaînes séparément sur chaque ligne, ou à l'ensemble du lot en dehors des parenthèses.

Enfin, vous pouvez utiliser des chaînes entre guillemets triples:

"""This is the first line of my text
which will be joined to a second."""

C'est souvent mon préféré, bien que son comportement soit légèrement différent car la nouvelle ligne et tout espace blanc de début sur les lignes suivantes apparaîtront dans votre chaîne finale. Vous pouvez éliminer la nouvelle ligne avec une barre oblique inverse d'échappement.

"""This is the first line of my text \
which will be joined to a second."""

Cela pose le même problème que la même technique ci-dessus, en ce que le code correct ne diffère du code incorrect que par des espaces invisibles.

Laquelle est "la meilleure" dépend de votre situation particulière, mais la réponse n'est pas simplement esthétique, mais l'un des comportements subtilement différents.

Les littéraux de chaîne consécutifs sont joints par le compilateur et les expressions entre parenthèses sont considérées comme une seule ligne de code:

logger.info("Skipping {0} because it's thumbnail was "
  "already in our system as {1}.".format(line[indexes['url']],
  video.title))

Personnellement, je n'aime pas accrocher des blocs ouverts, alors je le formaterais comme suit:

logger.info(
    'Skipping {0} because its thumbnail was already in our system as {1}.'
    .format(line[indexes['url']], video.title)
)

En général, je ne me donnerais pas la peine de lutter trop dur pour que le code tienne exactement dans une ligne de 80 colonnes. Cela vaut la peine de maintenir la longueur de la ligne à des niveaux raisonnables, mais la limite de 80 durs appartient au passé.

Vous pouvez utiliser le module textwrap pour le diviser en plusieurs lignes

import textwrap
str="ABCDEFGHIJKLIMNO"
print("\n".join(textwrap.wrap(str,8)))

ABCDEFGH
IJKLIMNO

De la documentation :

habillage de texte. wrap (text [, width [, ...]])
Enveloppe le paragraphe unique dans le texte (une chaîne) de sorte que chaque ligne ne dépasse pas la largeur des caractères. Renvoie une liste de lignes de sortie, sans sauts de ligne finaux.

Les arguments de mot-clé facultatifs correspondent aux attributs d'instance de TextWrapper, documentés ci-dessous. la largeur par défaut est 70.

Voir la TextWrapper.wrap()méthode pour plus de détails sur le comportement de wrap ().

Pour quiconque essaie également d'appeler .format()une longue chaîne et ne peut pas utiliser certaines des techniques d'enroulement de chaîne les plus populaires sans interrompre l' .format(appel suivant, vous pouvez le faire à la str.format("", 1, 2)place de "".format(1, 2). Cela vous permet de casser la corde avec la technique de votre choix. Par exemple:

logger.info("Skipping {0} because its thumbnail was already in our system as {1}.".format(line[indexes['url']], video.title))

peut être

logger.info(str.format(("Skipping {0} because its thumbnail was already"
+ "in our system as {1}"), line[indexes['url']], video.title))

Sinon, la seule possibilité est d'utiliser des continuations de fin de ligne, dont je ne suis personnellement pas fan.