python - instalar - Opciones de formato de cadena: pros y contras

instalar tabulate en python

Question

Estas son dos formas muy populares de formatear una cadena en Python. Uno está usando un dict :

>>> ''I will be %(years)i on %(month)s %(day)i'' % {''years'': 21, ''month'': ''January'', ''day'': 23}
''I will be 21 on January 23''

Y el otro utilizando una simple tuple :

>>> ''I will be %i on %s %i'' % (21, ''January'', 23)
''I will be 21 on January 23''

La primera es mucho más legible, pero la segunda es más rápida de escribir. En realidad los uso indistintamente.

¿Cuáles son los pros y los contras de cada uno? en relación con el rendimiento, la legibilidad, la optimización del código (¿uno de ellos se transforma al otro?) y cualquier otra cosa que piense que es útil compartir.

Answer 1

¿Por qué format() es más flexible que el % las operaciones de cadena?

Creo que realmente debería seguir el método format() de str , porque es la forma preferida de formatear cadenas y probablemente reemplazará la operación de formateo de cadenas en el futuro.

Además, tiene algunas características realmente buenas, que también pueden combinar el formato basado en la posición con el basado en palabras clave :

>>> string = ''I will be {} years and {} months on {month} {day}''
>>> some_date = {''month'': ''January'', ''day'': ''1st''}
>>> diff = [3, 11] # years, months
>>> string.format(*diff, **some_date)
''I will be 3 years and 11 months on January 1st''

incluso lo siguiente funcionará:

>>> string = ''On {month} {day} it will be {1} months, {0} years''
>>> string.format(*diff, **some_date)
''On January 1st it will be 11 months, 3 years''

También hay otra razón a favor del format() . Debido a que es un método, se puede pasar como devolución de llamada como en el siguiente ejemplo:

>>> data = [(1, 2), (''a'', ''b''), (5, ''ABC'')]
>>> formatter = ''First is "{0[0]}", then comes "{0[1]}"''.format
>>> for item in map(formatter, data):
print item
First is "1", then comes "2"
First is "a", then comes "b"
First is "5", then comes "ABC"

¿No es mucho más flexible que la operación de formato de cadena?

Vea más ejemplos en la página de documentación para comparar entre % operaciones y el método .format() .

Comparación del formato de % cadena basado en tuple con el diccionario

En general, existen tres formas de invocar % operaciones de cadena (sí, tres , no dos ), de la siguiente manera:

base_string % values

y difieren según el tipo de values (que es una consecuencia de lo que es el contenido de base_string ):

• puede ser una tuple , luego se reemplazan una por una, en el orden en que aparecen en tupla,

  >>> ''Three first values are: %f, %f and %f'' % (3.14, 2.71, 1)
  ''Three first values are: 3.140000, 2.710000 and 1.000000''

• puede ser un dict (diccionario), luego se reemplazan según las palabras clave,

  >>> ''My name is %(name)s, I am %(age)s years old'' % {''name'':''John'',''age'':98}
  ''My name is John, I am 98 years old''

• puede ser un solo valor, si la base_string contiene un solo lugar donde se debe insertar el valor:

  >>> ''This is a string: %s'' % ''abc''
  ''This is a string: abc''

Existen diferencias obvias entre ellos y estas formas no se pueden combinar (a diferencia del método format() que puede combinar algunas características, como se mencionó anteriormente).

Pero hay algo que es específico solo para las operaciones de formateo de cadenas basadas en diccionarios y que no está disponible en los tres tipos restantes de operaciones de formateo. Esta es la capacidad de reemplazar a los especificadores con nombres de variables reales de una manera simple :

>>> name = ''John''
>>> surname = ''Smith''
>>> age = 87
# some code goes here
>>> ''My name is %(surname)s, %(name)s %(surname)s. I am %(age)i.'' % locals()
''My name is Smith, John Smith. I am 87.''

Solo para el registro: por supuesto, lo anterior podría reemplazarse fácilmente usando format() desempaquetando el diccionario de esa manera:

>>> ''My name is {surname}, {name} {surname}. I am {age}.''.format(**locals())
''My name is Smith, John Smith. I am 87.''

¿Alguien más tiene una idea de lo que podría ser una característica específica para un tipo de operación de formato de cadena, pero no para el otro? Podría ser bastante interesante escuchar sobre eso.

Answer 2

No estoy respondiendo exactamente a tu pregunta, pero pensé que sería bueno incluir el format en tu mezcla.

Personalmente prefiero la sintaxis de format a ambos:

''I will be {years} on {month} {day}''.format(years=19, month=''January'', day=23)

Si quiero algo compacto, solo escribo:

''I will be {} on {} {}''.format(19, ''January'', 23)

Y el format juega muy bien con los objetos:

class Birthday:
def __init__(self, age, month, day):
self.age = age
self.month = month
self.day = day
print ''I will be {b.age} on {b.month} {b.day}''.format(b = Birthday(19, ''January'', 23))

Answer 3

No estoy respondiendo la pregunta, solo estoy explicando la idea que se me ocurrió en mi TIScript .

He introducido las llamadas funciones de "stringizador": cualquier función cuyo nombre comience por ''$'' es un stringizador. El compilador trata ''$ nombre ('' y '')'' como citas de cadena literal combinada con la llamada de función.

Ejemplo, esto:

$print(I will be {b.age} on {b.month} {b.day});

en realidad se compila en

$print("I will be ", b.age, " on ",b.month," ",b.day);

donde incluso los argumentos son siempre cadenas literales y los impares son expresiones. De esta manera, es posible definir estilizadores personalizados que utilizan diferentes formatos / procesamiento de argumentos.

Por ejemplo, Element.$html(Hello <b>{who}</b>); Se aplicará el escape HTML en las expresiones. Y este Element.$(option[value={12}]); Lo haremos seleccionar en estilo jQuery.

Bastante conveniente y flexible.

No estoy seguro de que sea posible hacer algo como esto en Python sin cambiar su compilador. Considera solo como una idea.