Formateo de cadenas en Python 3

Hago esto en Python 2:

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

¿Cuál es la versión Python 3 de esto?

Intenté buscar ejemplos en línea, pero seguí obteniendo versiones de Python 2.

Aquí están los documentos sobre la sintaxis de formato "nuevo". Un ejemplo sería:

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

Si ambos goalsy penaltiesson números enteros (es decir, su formato predeterminado es correcto), podría abreviarse a:

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

Y dado que los parámetros son campos de self, también hay una forma de hacerlo usando un solo argumento dos veces (como @Burhan Khalid señaló en los comentarios):

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

Explicando:

• {} significa solo el siguiente argumento posicional, con formato predeterminado;
• {0}significa el argumento con índice 0, con formato predeterminado;
• {:d} es el siguiente argumento posicional, con formato de entero decimal;
• {0:d}es el argumento con índice 0, con formato de entero decimal.

Hay muchas otras cosas que puede hacer al seleccionar un argumento (usar argumentos con nombre en lugar de posicionales, acceder a campos, etc.) y también muchas opciones de formato (rellenar el número, usar separadores de miles, mostrar signo o no, etc.). Algunos otros ejemplos:

"({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'

Nota: Como señalaron otros, el nuevo formato no reemplaza al anterior, ambos están disponibles tanto en Python 3 como en las versiones más recientes de Python 2. Algunos pueden decir que es una cuestión de preferencia, pero en mi humilde opinión, el más nuevo es mucho más expresivo que el anterior, y debe usarse siempre que se escriba un código nuevo (a menos que se dirija a entornos más antiguos, por supuesto).

Python 3.6 ahora admite la interpolación de cadenas literales abreviadas con PEP 498 . Para su caso de uso, la nueva sintaxis es simplemente:

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

Esto es similar al .formatestándar anterior , pero permite hacer cosas como :

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

Esa línea funciona como está en 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)'

Me gusta este enfoque

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)

Tenga en cuenta las dys adjuntas a los corchetes respectivamente.

la salida será:

I scored 3 goals and took 5 penalties