Mise à jour du 19 octobre 2020 : bien que ma réponse ici soit toujours perspicace, informative et digne d'être lue, j'ai a meilleure réponse ici maintenant qui s'appuie sur le très utile textwrap.dedent() fonction.
En @Chinmay Kanchi dit que vous pouvez faire :
'''line {0}
line {1}
line {2}'''.format(1,2,3)
Cependant, je pense que cela semble bizarre avec un alignement qui doit être aligné complètement à gauche sur les nouvelles lignes, en particulier lorsque vous le faites déjà avec plusieurs niveaux d'indentation, donc je préférerais que cela soit écrit plus comme ça :
'''line {0}
line {1}
line {2}'''.format(1,2,3)
Cela fonctionne, MAIS C'EST FAUX ! Il interprète tous les espaces à gauche de line {1} et line {2} comme des espaces réels, donc l'impression aura l'air bizarre :
1
2
3
Au lieu de
1
2
3
Une solution de contournement consiste donc à utiliser l'option + pour concaténer, et des parenthèses autour de la chaîne concaténée, ainsi que des nouvelles lignes explicites ( \n ), comme ceci :
('line {0}\n' +
'line {1}\n' +
'line {2}').format(1,2,3)
Parfait (à mon avis) ! Maintenant, il est beau et aligné à la fois dans le code source et dans la chaîne réelle si vous l'imprimez.
Exemple complet :
Code source dégoûtant !
num1 = 7
num2 = 100
num3 = 75.49
# Get some levels of indentation to really show the effect well.
# THIS IS *UGLY*! Notice the weird forced-left-align thing for the string I want to print!
if (True):
if (True):
if (True):
# AAAAAH! This is hard to look at!
print('''num1 = {}
num2 = {}
num3 = {}'''.format(num1, num2, num3))
# More lines of code go here
# etc
# etc
Sortie :
num1 = 7
num2 = 100
num3 = 75.49
Un bel exemple ! Ahh, si agréable à regarder dans le code source :)
C'est ce que je préfère.
# Get some levels of indentation to really show the effect well.
if (True):
if (True):
if (True):
# IMPORTANT: the extra set of parenthesis to tie all of the concatenated strings together here is *required*!
print(('num1 = {}\n' +
'num2 = {}\n' +
'num3 = {}')
.format(num1, num2, num3))
# More lines of code go here
# etc
# etc
Sortie :
num1 = 7
num2 = 100
num3 = 75.49
Mise à jour du 21 mai 2019 : Parfois, la chaîne de caractères multi-lignes "laide" est vraiment la meilleure solution !
Donc, j'ai utilisé Python pour générer automatiquement des fichiers d'en-tête et de source C (.h/.c) à partir de fichiers de configuration textuels Après en avoir fait un certain nombre, j'ai conclu que les avantages du simple copier-coller de gros morceaux de texte d'un fichier de configuration dans mon script Python l'emportent sur tout facteur de "laideur".
Par conséquent, j'ai déterminé que la méthode suivante est celle que je préfère lorsqu'il s'agit de copier-coller une grande chaîne de plusieurs lignes, par exemple :
Option 1 :
-
Utilisez des parenthèses autour de toute la longue chaîne pour permettre l'ouverture """ pour être sur une nouvelle ligne
Obtenez quelques niveaux d'indentation pour montrer encore l'effet de "laideur".
si (Vrai) : si (Vrai) : si (Vrai) : header = ( """ /* mes informations d'en-tête de fichier personnalisées ici */
pragma once
include "{}"
const {} {} ; """).format(include, struct_t, struct)
print("header =" + header)
Option 2 :
-
Pas de parenthèses, mais mettez quand même la fermeture """ sur sa propre ligne
Obtenez quelques niveaux d'indentation pour montrer encore l'effet de "laideur".
si (Vrai) : si (Vrai) : if (True) : header = """ /* mes informations d'en-tête de fichier personnalisées ici */
pragma once
include "{}"
const {} {} ; """.format(include, struct_t, struct)
print("header =" + header)
Option 3 :
-
Pas de parenthèses autour de la chaîne entière, et mettez la fermeture """ sur la même ligne que le contenu de la chaîne de caractères pour éviter d'ajouter un (potentiellement indésirable) \n à la fin.
-
Cependant, mettez le reste de format( sur une nouvelle ligne (ou sur plusieurs nouvelles lignes) au cas où elle serait longue.
Obtenez quelques niveaux d'indentation pour montrer encore l'effet de "laideur".
si (Vrai) : si (Vrai) : si (Vrai) : header = """ /* mes informations d'en-tête de fichier personnalisées ici */
pragma once
include "{}"
const {} {} ;"".format( include, struct_t, struct) # L'indentation ici peut littéralement être tout ce qui est mais j'aime bien faire un retrait d'un niveau ; comme c'est entre parenthèses, cela n'a pas d'importance.
print("header =" + header)
Sortie :
- Les options 1 et 2 produisent une sortie exactement identique, avec un supplément de
\n à la toute fin de la chaîne, ce qui est correct dans la plupart des cas.
- L'option 3 produit exactement le même résultat que les options 1 et 2. sauf qu'il ne no ont le supplément
\n à la toute fin de la chaîne, au cas où cela ne serait pas souhaitable dans votre cas.
- Que vous utilisiez l'option 1, 2 ou 3 n'a pas vraiment d'importance - il s'agit simplement d'une préférence de l'utilisateur à ce stade, en dehors de l'avantage supplémentaire que représente l'option 1.
\n comme indiqué juste au-dessus
C'est ce qui est imprimé par les options 1, 2 et 3 ci-dessus :
/*
my custom file header info here
*/
#pragma once
#include "<stdint.h>"
const my_struct_t my_struct;
ENSEMBLE : un mélange de méthodes "belles" et "moches" pour obtenir le meilleur résultat dans cette démo de impression docstring la documentation de votre module !
Voici un exemple de base de l'utilisation des deux méthodes de chaînes de caractères multi-lignes, la "jolie" et la "laide", présentées ci-dessus, afin d'obtenir les meilleurs avantages de chacune. Ceci montre également comment utiliser et imprimer les "docstrings" du module pour documenter votre module. Remarquez comment les """ La technique de multi-ligne basée sur l'anglais nous donne un grand espacement parce que de la façon dont je l'ai fait ci-dessous il y a une nouvelle ligne automatique ( \n ) après l'ouverture """ et avant la fermeture """ puisque c'est ainsi que la chaîne est écrite.
# PRETTY, AND GOOD.
print("\n\n" +
"########################\n" +
"PRINT DOCSTRING DEMO:\n" +
"########################")
import sys
def printDocstrings():
"""
Print all document strings for this module, then exit.
Params: NA
Returns: NA
"""
# A LITTLE BIT UGLY, BUT GOOD! THIS WORKS GREAT HERE!
print("""
---------------------
Module Documentation:
---------------------
printDocstrings:{}
myFunc1:{}
class Math:{}
__init__:{}
add:{}
subtract:{}""".format(
printDocstrings.__doc__,
myFunc1.__doc__,
Math.__doc__,
Math.__init__.__doc__,
Math.add.__doc__,
Math.subtract.__doc__))
sys.exit()
def myFunc1():
"""
Do something.
Params: NA
Returns: NA
"""
pass
class Math:
"""
A basic "math" class to add and subtract
"""
def __init__(self):
"""
New object initialization function.
Params: NA
Returns: NA
"""
pass
def add(a, b):
"""
Add a and b together.
Params: a 1st number to add
b 2nd number to add
Returns: the sum of a + b
"""
return a + b
def subtract(a, b):
"""
Subtract b from a.
Params: a number to subtract from
b number to subtract
Returns: the result of a - b
"""
return a - b
printDocstrings()
Sortie :
- Remarquez comme tout cela est joli et bien formaté automatiquement, car les tabulations, les nouvelles lignes et l'espacement de vos chaînes de documents sont tous automatiquement préservés lorsque vous les imprimez de cette façon !
########################
PRINT DOCSTRING DEMO:
########################
---------------------
Module Documentation:
---------------------
printDocstrings:
Print all document strings for this module, then exit.
Params: NA
Returns: NA
myFunc1:
Do something.
Params: NA
Returns: NA
class Math:
A basic "math" class to add and subtract
__init__:
New object initialization function.
Params: NA
Returns: NA
add:
Add a and b together.
Params: a 1st number to add
b 2nd number to add
Returns: the sum of a + b
subtract:
Subtract b from a.
Params: a number to subtract from
b number to subtract
Returns: the result of a - b
Références :
- Docstrings Python : https://www.geeksforgeeks.org/python-docstrings/
-
Remarque : vous pouvez également utiliser l'option help() pour accéder à la documentation d'un module ou d'une classe (mais de manière interactive ), comme indiqué dans le lien ci-dessus, comme ceci :
help(Math) # to interactively display Class docstring
help(Math.add) # to interactively display method's docstring
