Formattazione delle stringhe:% vs. .format

Python 2.6 ha introdotto il str.format()metodo con una sintassi leggermente diversa %dall'operatore esistente . Qual è la migliore e per quali situazioni?

1. Quanto segue utilizza ogni metodo e ha lo stesso risultato, quindi qual è la differenza?

   #!/usr/bin/python
   sub1 = "python string!"
   sub2 = "an arg"
   
   a = "i am a %s" % sub1
   b = "i am a {0}".format(sub1)
   
   c = "with %(kwarg)s!" % {'kwarg':sub2}
   d = "with {kwarg}!".format(kwarg=sub2)
   
   print a    # "i am a python string!"
   print b    # "i am a python string!"
   print c    # "with an arg!"
   print d    # "with an arg!"

2. Inoltre, quando si verifica la formattazione delle stringhe in Python? Ad esempio, se il mio livello di registrazione è impostato su ALTO, avrò comunque un colpo per eseguire la seguente %operazione? E se è così, c'è un modo per evitarlo?

   log.debug("some debug info: %s" % some_info)

Per rispondere alla tua prima domanda ... .formatsembra solo più sofisticato in molti modi. Una cosa fastidiosa %è anche come può prendere una variabile o una tupla. Penseresti che funzionerebbe sempre quanto segue:

"hi there %s" % name

eppure, se namesuccede (1, 2, 3), lancerà a TypeError. Per garantire che stampi sempre, dovresti farlo

"hi there %s" % (name,)   # supply the single argument as a single-item tuple

che è semplicemente brutto. .formatnon ha questi problemi. Anche nel secondo esempio che hai dato, l' .formatesempio è molto più pulito.

Perché non dovresti usarlo?

• non saperlo (io prima di leggere questo)
• dover essere compatibile con Python 2.5

Per rispondere alla tua seconda domanda, la formattazione della stringa viene eseguita contemporaneamente a qualsiasi altra operazione, quando viene valutata l'espressione della formattazione della stringa. E Python, non essendo un linguaggio pigro, valuta le espressioni prima di chiamare le funzioni, quindi nel tuo log.debugesempio, l'espressione "some debug info: %s"%some_infoverrà valutata prima, ad esempio "some debug info: roflcopters are active", poi quella stringa verrà passata a log.debug().

Qualcosa che l'operatore modulo (%) non può fare, afaik:

tu = (12,45,22222,103,6)
print '{0} {2} {1} {2} {3} {2} {4} {2}'.format(*tu)

risultato

12 22222 45 22222 103 22222 6 22222

Molto utile.

Un altro punto: format()essendo una funzione, può essere usato come argomento in altre funzioni:

li = [12,45,78,784,2,69,1254,4785,984]
print map('the number is {}'.format,li)   

print

from datetime import datetime,timedelta

once_upon_a_time = datetime(2010, 7, 1, 12, 0, 0)
delta = timedelta(days=13, hours=8,  minutes=20)

gen =(once_upon_a_time +x*delta for x in xrange(20))

print '\n'.join(map('{:%Y-%m-%d %H:%M:%S}'.format, gen))

Risultati in:

['the number is 12', 'the number is 45', 'the number is 78', 'the number is 784', 'the number is 2', 'the number is 69', 'the number is 1254', 'the number is 4785', 'the number is 984']

2010-07-01 12:00:00
2010-07-14 20:20:00
2010-07-28 04:40:00
2010-08-10 13:00:00
2010-08-23 21:20:00
2010-09-06 05:40:00
2010-09-19 14:00:00
2010-10-02 22:20:00
2010-10-16 06:40:00
2010-10-29 15:00:00
2010-11-11 23:20:00
2010-11-25 07:40:00
2010-12-08 16:00:00
2010-12-22 00:20:00
2011-01-04 08:40:00
2011-01-17 17:00:00
2011-01-31 01:20:00
2011-02-13 09:40:00
2011-02-26 18:00:00
2011-03-12 02:20:00

Supponendo che tu stia utilizzando il loggingmodulo di Python , puoi passare gli argomenti di formattazione delle stringhe come argomenti al .debug()metodo piuttosto che eseguire tu stesso la formattazione:

log.debug("some debug info: %s", some_info)

che evita di eseguire la formattazione a meno che il logger non registri effettivamente qualcosa.

A partire da Python 3.6 (2016) puoi usare f-string per sostituire le variabili:

>>> origin = "London"
>>> destination = "Paris"
>>> f"from {origin} to {destination}"
'from London to Paris'

Nota il f"prefisso. Se provi questo in Python 3.5 o precedente, otterrai un SyntaxError.

Vedi https://docs.python.org/3.6/reference/lexical_analysis.html#f-strings

PEP 3101 propone la sostituzione %dell'operatore con la nuova formattazione avanzata delle stringhe in Python 3, dove sarebbe l'impostazione predefinita.

Ma attenzione, ho appena scoperto un problema quando ho provato a sostituire tutto %con il .formatcodice esistente: '{}'.format(unicode_string)proverò a codificare unicode_string e probabilmente fallirà.

Guarda questo registro delle sessioni interattive di Python:

Python 2.7.2 (default, Aug 27 2012, 19:52:55) 
[GCC 4.1.2 20080704 (Red Hat 4.1.2-48)] on linux2
; s='й'
; u=u'й'
; s
'\xd0\xb9'
; u
u'\u0439'

sè solo una stringa (chiamata 'array di byte' in Python3) ed uè una stringa Unicode (chiamata 'stringa' in Python3):

; '%s' % s
'\xd0\xb9'
; '%s' % u
u'\u0439'

Quando si assegna un oggetto Unicode come parametro %all'operatore, verrà prodotta una stringa Unicode anche se la stringa originale non era Unicode:

; '{}'.format(s)
'\xd0\xb9'
; '{}'.format(u)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
UnicodeEncodeError: 'latin-1' codec can't encode character u'\u0439' in position 0: ordinal not in range(256)

ma la .formatfunzione genererà "UnicodeEncodeError":

; u'{}'.format(s)
u'\xd0\xb9'
; u'{}'.format(u)
u'\u0439'

e funzionerà bene con un argomento Unicode solo se la stringa originale era Unicode.

; '{}'.format(u'i')
'i'

o se la stringa dell'argomento può essere convertita in una stringa (il cosiddetto "array di byte")

Ancora un altro vantaggio di .format(che non vedo nelle risposte): può prendere le proprietà degli oggetti.

In [12]: class A(object):
   ....:     def __init__(self, x, y):
   ....:         self.x = x
   ....:         self.y = y
   ....:         

In [13]: a = A(2,3)

In [14]: 'x is {0.x}, y is {0.y}'.format(a)
Out[14]: 'x is 2, y is 3'

Oppure, come argomento per parole chiave:

In [15]: 'x is {a.x}, y is {a.y}'.format(a=a)
Out[15]: 'x is 2, y is 3'

Questo non è possibile %per quanto ne so.

%offre prestazioni migliori rispetto formatal mio test.

Codice di prova:

Python 2.7.2:

import timeit
print 'format:', timeit.timeit("'{}{}{}'.format(1, 1.23, 'hello')")
print '%:', timeit.timeit("'%s%s%s' % (1, 1.23, 'hello')")

Risultato:

> format: 0.470329046249
> %: 0.357107877731

Python 3.5.2

import timeit
print('format:', timeit.timeit("'{}{}{}'.format(1, 1.23, 'hello')"))
print('%:', timeit.timeit("'%s%s%s' % (1, 1.23, 'hello')"))

Risultato

> format: 0.5864730989560485
> %: 0.013593495357781649

Sembra in Python2, la differenza è piccola mentre in Python3 %è molto più veloce di format.

Grazie @ Chris Cogdon per il codice di esempio.

Modifica 1:

Testato di nuovo in Python 3.7.2 a luglio 2019.

Risultato:

> format: 0.86600608
> %: 0.630180146

Non c'è molta differenza. Immagino che Python stia migliorando gradualmente.

Modifica 2:

Dopo che qualcuno ha menzionato la stringa F di Python 3 nei commenti, ho fatto un test per il seguente codice in Python 3.7.2:

import timeit
print('format:', timeit.timeit("'{}{}{}'.format(1, 1.23, 'hello')"))
print('%:', timeit.timeit("'%s%s%s' % (1, 1.23, 'hello')"))
print('f-string:', timeit.timeit("f'{1}{1.23}{\"hello\"}'"))

Risultato:

format: 0.8331376779999999
%: 0.6314778750000001
f-string: 0.766649943

Sembra che f-string sia ancora più lento di %ma migliore di format.

Come ho scoperto oggi, il vecchio modo di formattare le stringhe tramite %non supporta Decimal, il modulo di Python per il punto decimale e l'aritmetica in virgola mobile, pronto all'uso.

Esempio (usando Python 3.3.5):

#!/usr/bin/env python3

from decimal import *

getcontext().prec = 50
d = Decimal('3.12375239e-24') # no magic number, I rather produced it by banging my head on my keyboard

print('%.50f' % d)
print('{0:.50f}'.format(d))

Produzione:

0,00000000000000000000000312375239000000009907464850 0.0000000000000000000000031237523900000000000000000000

Potrebbero esserci sicuramente delle soluzioni, ma potresti comunque considerare di usare subito il format()metodo.

Se il tuo python> = 3.6, letterale in formato F string è il tuo nuovo amico.

È più semplice, pulito e con prestazioni migliori.

In [1]: params=['Hello', 'adam', 42]

In [2]: %timeit "%s %s, the answer to everything is %d."%(params[0],params[1],params[2])
448 ns ± 1.48 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [3]: %timeit "{} {}, the answer to everything is {}.".format(*params)
449 ns ± 1.42 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [4]: %timeit f"{params[0]} {params[1]}, the answer to everything is {params[2]}."
12.7 ns ± 0.0129 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)

Come nota a margine, non è necessario subire un calo delle prestazioni per utilizzare la formattazione del nuovo stile con la registrazione. È possibile passare qualsiasi oggetto a logging.debug, logging.infoe così via che implementa il __str__metodo magico. Quando il modulo di registrazione ha deciso che deve emettere l'oggetto messaggio (qualunque esso sia), chiama str(message_object)prima di farlo. Quindi potresti fare qualcosa del genere:

import logging


class NewStyleLogMessage(object):
    def __init__(self, message, *args, **kwargs):
        self.message = message
        self.args = args
        self.kwargs = kwargs

    def __str__(self):
        args = (i() if callable(i) else i for i in self.args)
        kwargs = dict((k, v() if callable(v) else v) for k, v in self.kwargs.items())

        return self.message.format(*args, **kwargs)

N = NewStyleLogMessage

# Neither one of these messages are formatted (or calculated) until they're
# needed

# Emits "Lazily formatted log entry: 123 foo" in log
logging.debug(N('Lazily formatted log entry: {0} {keyword}', 123, keyword='foo'))


def expensive_func():
    # Do something that takes a long time...
    return 'foo'

# Emits "Expensive log entry: foo" in log
logging.debug(N('Expensive log entry: {keyword}', keyword=expensive_func))

Tutto ciò è descritto nella documentazione di Python 3 ( https://docs.python.org/3/howto/logging-cookbook.html#formatting-styles ). Tuttavia, funzionerà anche con Python 2.6 ( https://docs.python.org/2.6/library/logging.html#using-arbitrary-objects-as-messages ).

Uno dei vantaggi dell'utilizzo di questa tecnica, oltre al fatto che è agnostico in stile formattazione, è che consente valori pigri, ad esempio la funzione expensive_funcsopra. Ciò fornisce un'alternativa più elegante ai consigli forniti nei documenti Python qui: https://docs.python.org/2.6/library/logging.html#optimization .

Una situazione in cui %può essere d'aiuto è quando si formattano espressioni regex. Per esempio,

'{type_names} [a-z]{2}'.format(type_names='triangle|square')

solleva IndexError. In questa situazione, puoi usare:

'%(type_names)s [a-z]{2}' % {'type_names': 'triangle|square'}

Questo evita di scrivere regex come '{type_names} [a-z]{{2}}'. Questo può essere utile quando hai due regex, dove una viene usata da sola senza formattazione, ma la concatenazione di entrambe è formattata.

Vorrei aggiungere che dalla versione 3.6, possiamo usare fstrings come il seguente

foo = "john"
bar = "smith"
print(f"My name is {foo} {bar}")

Che danno

Mi chiamo John Smith

Tutto viene convertito in stringhe

mylist = ["foo", "bar"]
print(f"mylist = {mylist}")

Risultato:

mylist = ['foo', 'bar']

puoi passare la funzione, come nel metodo di altri formati

print(f'Hello, here is the date : {time.strftime("%d/%m/%Y")}')

Dare per esempio

Ciao, ecco la data: 16/04/2018

Per la versione python> = 3.6 (vedi PEP 498 )

s1='albha'
s2='beta'

f'{s1}{s2:>10}'

#output
'albha      beta'

Comparativo Python 3.6.7:

#!/usr/bin/env python
import timeit

def time_it(fn):
    """
    Measure time of execution of a function
    """
    def wrapper(*args, **kwargs):
        t0 = timeit.default_timer()
        fn(*args, **kwargs)
        t1 = timeit.default_timer()
        print("{0:.10f} seconds".format(t1 - t0))
    return wrapper


@time_it
def new_new_format(s):
    print("new_new_format:", f"{s[0]} {s[1]} {s[2]} {s[3]} {s[4]}")


@time_it
def new_format(s):
    print("new_format:", "{0} {1} {2} {3} {4}".format(*s))


@time_it
def old_format(s):
    print("old_format:", "%s %s %s %s %s" % s)


def main():
    samples = (("uno", "dos", "tres", "cuatro", "cinco"), (1,2,3,4,5), (1.1, 2.1, 3.1, 4.1, 5.1), ("uno", 2, 3.14, "cuatro", 5.5),) 
    for s in samples:
        new_new_format(s)
        new_format(s)
        old_format(s)
        print("-----")


if __name__ == '__main__':
    main()

Produzione:

new_new_format: uno dos tres cuatro cinco
0.0000170280 seconds
new_format: uno dos tres cuatro cinco
0.0000046750 seconds
old_format: uno dos tres cuatro cinco
0.0000034820 seconds
-----
new_new_format: 1 2 3 4 5
0.0000043980 seconds
new_format: 1 2 3 4 5
0.0000062590 seconds
old_format: 1 2 3 4 5
0.0000041730 seconds
-----
new_new_format: 1.1 2.1 3.1 4.1 5.1
0.0000092650 seconds
new_format: 1.1 2.1 3.1 4.1 5.1
0.0000055340 seconds
old_format: 1.1 2.1 3.1 4.1 5.1
0.0000052130 seconds
-----
new_new_format: uno 2 3.14 cuatro 5.5
0.0000053380 seconds
new_format: uno 2 3.14 cuatro 5.5
0.0000047570 seconds
old_format: uno 2 3.14 cuatro 5.5
0.0000045320 seconds
-----

Ma una cosa è che anche se hai parentesi graffe nidificate, non funzionerà per il formato ma %funzionerà.

Esempio:

>>> '{{0}, {1}}'.format(1,2)
Traceback (most recent call last):
  File "<pyshell#3>", line 1, in <module>
    '{{0}, {1}}'.format(1,2)
ValueError: Single '}' encountered in format string
>>> '{%s, %s}'%(1,2)
'{1, 2}'
>>>