Formatage de chaîne en Python 3

Je fais cela en Python 2:

"(%d goals, $%d)" % (self.goals, self.penalties)

Quelle est la version Python 3 de ceci?

J'ai essayé de rechercher des exemples en ligne mais j'ai continué à obtenir des versions de Python 2.

Voici la documentation sur la «nouvelle» syntaxe de format. Un exemple serait:

"({:d} goals, ${:d})".format(self.goals, self.penalties)

Si les deux goalset penaltiessont des entiers (c'est-à-dire que leur format par défaut est correct), il peut être raccourci à:

"({} goals, ${})".format(self.goals, self.penalties)

Et comme les paramètres sont des champs de self, il existe également un moyen de le faire en utilisant un seul argument deux fois (comme @Burhan Khalid l'a noté dans les commentaires):

"({0.goals} goals, ${0.penalties})".format(self)

Expliquer:

• {} signifie juste le prochain argument de position, avec le format par défaut;
• {0}signifie l'argument avec index 0, avec le format par défaut;
• {:d} est le prochain argument de position, au format entier décimal;
• {0:d}est l'argument avec index 0, au format entier décimal.

Il y a beaucoup d'autres choses que vous pouvez faire lors de la sélection d'un argument (en utilisant des arguments nommés au lieu d'arguments positionnels, en accédant aux champs, etc.) et de nombreuses options de format également (remplir le nombre, utiliser des séparateurs de milliers, afficher le signe ou non, etc.). Quelques autres exemples:

"({goals} goals, ${penalties})".format(goals=2, penalties=4)
"({goals} goals, ${penalties})".format(**self.__dict__)

"first goal: {0.goal_list[0]}".format(self)
"second goal: {.goal_list[1]}".format(self)

"conversion rate: {:.2f}".format(self.goals / self.shots) # '0.20'
"conversion rate: {:.2%}".format(self.goals / self.shots) # '20.45%'
"conversion rate: {:.0%}".format(self.goals / self.shots) # '20%'

"self: {!s}".format(self) # 'Player: Bob'
"self: {!r}".format(self) # '<__main__.Player instance at 0x00BF7260>'

"games: {:>3}".format(player1.games)  # 'games: 123'
"games: {:>3}".format(player2.games)  # 'games:   4'
"games: {:0>3}".format(player2.games) # 'games: 004'

Remarque: comme d'autres l'ont souligné, le nouveau format ne remplace pas l'ancien, les deux sont également disponibles à la fois dans Python 3 et dans les versions plus récentes de Python 2. Certains peuvent dire que c'est une question de préférence, mais à mon humble avis, le plus récent est beaucoup plus expressif que l'ancien et devrait être utilisé chaque fois que vous écrivez un nouveau code (à moins qu'il ne cible des environnements plus anciens, bien sûr).

Python 3.6 prend désormais en charge l'interpolation de chaîne littérale abrégée avec PEP 498 . Pour votre cas d'utilisation, la nouvelle syntaxe est simplement:

f"({self.goals} goals, ${self.penalties})"

Ceci est similaire à la .formatnorme précédente , mais permet de faire facilement des choses comme :

>>> width = 10
>>> precision = 4
>>> value = decimal.Decimal('12.34567')
>>> f'result: {value:{width}.{precision}}'
'result:      12.35'

Cette ligne fonctionne telle quelle dans Python 3.

>>> sys.version
'3.2 (r32:88445, Oct 20 2012, 14:09:29) \n[GCC 4.5.2]'
>>> "(%d goals, $%d)" % (self.goals, self.penalties)
'(1 goals, $2)'

J'aime cette approche

my_hash = {}
my_hash["goals"] = 3 #to show number
my_hash["penalties"] = "5" #to show string
print("I scored %(goals)d goals and took %(penalties)s penalties" % my_hash)

Notez le d et le s annexés aux crochets respectivement.

la sortie sera:

I scored 3 goals and took 5 penalties