Python Language
Formattazione di stringhe

introduzione

Sintassi

• "{}". format (42) ==> "42"
• "{0}". Format (42) ==> "42"
• "{0: .2f}". Format (42) ==> "42.00"
• "{0: .0f}". Format (42.1234) ==> "42"
• "{answer}". format (no_answer = 41, answer = 42) ==> "42"
• "{answer: .2f}". format (no_answer = 41, answer = 42) ==> "42.00"
• "{[chiave]}". format ({'chiave': 'valore'}) ==> "valore"
• "{[1]}". Format (['zero', 'one', 'two']) ==> "one"
• "{answer} = {answer}". format (answer = 42) ==> "42 = 42"
• '' .join (['stack', 'overflow']) ==> "stack overflow"

Osservazioni

Nozioni di base sulla formattazione delle stringhe

foo = 1
bar = 'bar'
baz = 3.14

È possibile utilizzare str.format per formattare l'output. Le coppie di parentesi vengono sostituite con argomenti nell'ordine in cui vengono passati gli argomenti:

print('{}, {} and {}'.format(foo, bar, baz))
# Out: "1, bar and 3.14"

Gli indici possono anche essere specificati all'interno delle parentesi. I numeri corrispondono agli indici degli argomenti passati alla funzione str.format (basata su 0).

print('{0}, {1}, {2}, and {1}'.format(foo, bar, baz))
# Out: "1, bar, 3.14, and bar"
print('{0}, {1}, {2}, and {3}'.format(foo, bar, baz))
# Out: index out of range error

Gli argomenti con nome possono essere utilizzati anche:

print("X value is: {x_val}. Y value is: {y_val}.".format(x_val=2, y_val=3))
# Out: "X value is: 2. Y value is: 3."

Gli attributi degli oggetti possono essere referenziati quando vengono passati in str.format :

class AssignValue(object):
    def __init__(self, value):
        self.value = value
my_value = AssignValue(6)
print('My value is: {0.value}'.format(my_value))  # "0" is optional
# Out: "My value is: 6"

Le chiavi del dizionario possono essere utilizzate anche:

my_dict = {'key': 6, 'other_key': 7}
print("My other key is: {0[other_key]}".format(my_dict))  # "0" is optional
# Out: "My other key is: 7"

Lo stesso vale per gli indici list e tuple:

my_list = ['zero', 'one', 'two']
print("2nd element is: {0[2]}".format(my_list))  # "0" is optional
# Out: "2nd element is: two"

Nota: oltre a str.format , Python fornisce anche l'operatore modulo % - noto anche come operatore di formattazione o interpolazione della stringa (consultare PEP 3101 ) - per la formattazione delle stringhe. str.format è un successore di % e offre una maggiore flessibilità, ad esempio facilitando l'esecuzione di più sostituzioni.

Oltre agli indici argomento, puoi anche includere una specifica di formato all'interno delle parentesi graffe. Questa è un'espressione che segue regole particolari e deve essere preceduto da due punti ( : ). Vedi i documenti per una descrizione completa delle specifiche di formato. Un esempio di specifica di formato è la direttiva di allineamento :~^20 ( ^ indica allineamento centrale, larghezza totale 20, riempimento con carattere ~):

'{:~^20}'.format('centered')
# Out: '~~~~~~centered~~~~~~'

format consente un comportamento non possibile con % , ad esempio la ripetizione di argomenti:

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

Poiché il format è una funzione, può essere utilizzato come argomento in altre funzioni:

number_list = [12,45,78]
print map('the number is {}'.format, number_list)
# Out: ['the number is 12', 'the number is 45', 'the number is 78']   
    

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(5))
    
print '\n'.join(map('{:%Y-%m-%d %H:%M:%S}'.format, gen))
#Out: 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

Allineamento e imbottitura

'{:~<9s}, World'.format('Hello')
# 'Hello~~~~, World'

'{:~>9s}, World'.format('Hello')
# '~~~~Hello, World'

'{:~^9s}'.format('Hello')
# '~~Hello~~'

'{:0=6d}'.format(-123)
# '-00123'

Nota: è possibile ottenere gli stessi risultati usando le funzioni stringa ljust() , rjust() , center() , zfill() , tuttavia queste funzioni sono deprecate dalla versione 2.5.

Formato letterale (stringa-f)

Le stringhe in formato letterale sono state introdotte in PEP 498 (Python3.6 e versioni successive), consentendo di anteporre f all'inizio di una stringa letterale per applicare efficacemente .format su di esso con tutte le variabili nell'ambito corrente.

>>> foo = 'bar'
>>> f'Foo is {foo}'
'Foo is bar'

Funziona anche con stringhe di formato più avanzate, tra cui l'allineamento e la notazione dei punti.

>>> f'{foo:^7s}'
'  bar  '

Nota: il f'' non denota un tipo particolare come b'' per bytes o u'' per unicode in python2. La formatura viene immediatamente applicata, risultante in un normale stirng.

Le stringhe di formato possono anche essere annidate :

>>> price = 478.23
>>> f"{f'${price:0.2f}':*>20s}"
'*************$478.23'

Le espressioni in una stringa di stringa vengono valutate nell'ordine da sinistra a destra. Questo è rilevabile solo se le espressioni hanno effetti collaterali:

>>> def fn(l, incr):
...    result = l[0]
...    l[0] += incr
...    return result
...
>>> lst = [0]
>>> f'{fn(lst,2)} {fn(lst,3)}'
'0 2'
>>> f'{fn(lst,2)} {fn(lst,3)}'
'5 7'
>>> lst
[10]

Formattazione delle stringhe con datetime

Qualsiasi classe può configurare la propria sintassi di formattazione delle stringhe tramite il metodo __format__ . Un tipo nella libreria Python standard che ne fa un pratico uso è il tipo datetime , dove si possono usare i codici di formattazione strftime direttamente all'interno di str.format :

>>> from datetime import datetime
>>> 'North America: {dt:%m/%d/%Y}.  ISO: {dt:%Y-%m-%d}.'.format(dt=datetime.now())
'North America: 07/21/2016.  ISO: 2016-07-21.'

Un elenco completo di elenchi di formattatori datetime è disponibile nella documentazione ufficiale .

Formato utilizzando Getitem e Getattr

Qualsiasi struttura dati che supporta __getitem__ può avere la sua struttura nidificata formattata:

person = {'first': 'Arthur', 'last': 'Dent'} 
'{p[first]} {p[last]}'.format(p=person) 
# 'Arthur Dent'

È possibile accedere agli attributi degli oggetti utilizzando getattr() :

class Person(object):
    first = 'Zaphod'
    last = 'Beeblebrox'

'{p.first} {p.last}'.format(p=Person())
# 'Zaphod Beeblebrox'

Formattazione mobile

>>> '{0:.0f}'.format(42.12345)
'42'

>>> '{0:.1f}'.format(42.12345)
'42.1'

>>> '{0:.3f}'.format(42.12345)
'42.123'

>>> '{0:.5f}'.format(42.12345)
'42.12345'

>>> '{0:.7f}'.format(42.12345)
'42.1234500'

Stessa attesa per un altro modo di referenziare:

>>> '{:.3f}'.format(42.12345)
'42.123'

>>> '{answer:.3f}'.format(answer=42.12345)
'42.123'

I numeri in virgola mobile possono anche essere formattati in notazione scientifica o in percentuali:

>>> '{0:.3e}'.format(42.12345)
'4.212e+01'

>>> '{0:.0%}'.format(42.12345)
'4212%'

Puoi anche combinare le notazioni {0} e {name} . Ciò è particolarmente utile quando si desidera arrotondare tutte le variabili a un numero predefinito di decimali con 1 dichiarazione :

>>> s = 'Hello'
>>> a, b, c = 1.12345, 2.34567, 34.5678
>>> digits = 2

>>> '{0}! {1:.{n}f}, {2:.{n}f}, {3:.{n}f}'.format(s, a, b, c, n=digits)
'Hello! 1.12, 2.35, 34.57'

Formattazione dei valori numerici

Il metodo .format() può interpretare un numero in diversi formati, come ad esempio:

>>> '{:c}'.format(65)    # Unicode character
'A'

>>> '{:d}'.format(0x0a)  # base 10
'10'

>>> '{:n}'.format(0x0a)  # base 10 using current locale for separators
'10'

Formatta interi in basi diverse (esadecimale, ottale, binario)

>>> '{0:x}'.format(10) # base 16, lowercase - Hexadecimal
'a'

>>> '{0:X}'.format(10) # base 16, uppercase - Hexadecimal
'A'

>>> '{:o}'.format(10) # base 8 - Octal
'12'

>>> '{:b}'.format(10) # base 2 - Binary
'1010'

>>> '{0:#b}, {0:#o}, {0:#x}'.format(42) # With prefix
'0b101010, 0o52, 0x2a'

>>> '8 bit: {0:08b}; Three bytes: {0:06x}'.format(42) # Add zero padding
'8 bit: 00101010; Three bytes: 00002a'

Usa la formattazione per convertire una tupla fluttuante RGB in una stringa esadecimale a colori:

>>> r, g, b = (1.0, 0.4, 0.0)
>>> '#{:02X}{:02X}{:02X}'.format(int(255 * r), int(255 * g), int(255 * b))
'#FF6600'

Solo i numeri interi possono essere convertiti:

>>> '{:x}'.format(42.0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: Unknown format code 'x' for object of type 'float'

Formattazione personalizzata per una classe

Nota:

Tutto quanto segue si applica al metodo str.format e alla funzione di format . Nel testo qui sotto, i due sono intercambiabili.

Per ogni valore passato alla funzione format , Python cerca un metodo __format__ per quell'argomento. La tua classe personalizzata può quindi avere il proprio metodo __format__ per determinare in che modo la funzione di format visualizzerà e formatterà la tua classe e i suoi attributi.

Questo è diverso dal metodo __str__ , poiché nel metodo __format__ è possibile tenere conto del linguaggio di formattazione, inclusi allineamento, larghezza del campo ecc. E anche (se lo si desidera) implementare i propri specificatori di formato e le proprie estensioni della lingua di formattazione. 1

object.__format__(self, format_spec)

Per esempio :

# Example in Python 2 - but can be easily applied to Python 3

class Example(object):
    def __init__(self,a,b,c):
        self.a, self.b, self.c = a,b,c

    def __format__(self, format_spec):
        """ Implement special semantics for the 's' format specifier """
        # Reject anything that isn't an s
        if format_spec[-1] != 's':
            raise ValueError('{} format specifier not understood for this object', format_spec[:-1])

        # Output in this example will be (<a>,<b>,<c>)
        raw = "(" + ",".join([str(self.a), str(self.b), str(self.c)]) + ")"
        # Honor the format language by using the inbuilt string format
        # Since we know the original format_spec ends in an 's' 
        # we can take advantage of the str.format method with a 
        # string argument we constructed above
        return "{r:{f}}".format( r=raw, f=format_spec )

inst = Example(1,2,3)
print "{0:>20s}".format( inst )
# out :              (1,2,3)
# Note how the right align and field width of 20 has been honored.

Nota:

Se la tua classe personalizzata non ha un metodo __format__ personalizzato e un'istanza della classe viene passata alla funzione di format , Python2 utilizzerà sempre il valore di ritorno del metodo __str__ o il metodo __repr__ per determinare cosa stampare (e se nessuno dei due esiste allora il verrà usato default repr ) e sarà necessario utilizzare l' s formato s per formattarlo. Con Python3 , per passare la tua classe personalizzata alla funzione di format , dovrai definire il metodo __format__ sulla tua classe personalizzata.

Formattazione nidificata

Alcuni formati possono assumere parametri aggiuntivi, come la larghezza della stringa formattata o l'allineamento:

>>> '{:.>10}'.format('foo')
'.......foo'

Questi possono anche essere forniti come parametri da format nidificando di più {} all'interno di {} :

>>> '{:.>{}}'.format('foo', 10)
'.......foo'
'{:{}{}{}}'.format('foo', '*', '^', 15)
'******foo******'

Nell'ultimo esempio, la stringa di formato '{:{}{}{}}' viene modificata in '{:*^15}' (cioè "centro e pad con * fino a una lunghezza totale di 15") prima di applicarlo al stringa vera 'foo' da formattare in questo modo.

Questo può essere utile nei casi in cui i parametri non sono noti in anticipo, per esempio quando si allineano i dati tabulari:

>>> data = ["a", "bbbbbbb", "ccc"]
>>> m = max(map(len, data))
>>> for d in data:
...     print('{:>{}}'.format(d, m))
      a
bbbbbbb
    ccc

Stringhe di imbottitura e troncatura, combinate

Supponi di voler stampare le variabili in una colonna di 3 caratteri.

Nota: il raddoppio { e } li sfugge.

s = """

pad
{{:3}}             :{a:3}:

truncate
{{:.3}}            :{e:.3}:

combined
{{:>3.3}}          :{a:>3.3}:
{{:3.3}}           :{a:3.3}:
{{:3.3}}           :{c:3.3}:
{{:3.3}}           :{e:3.3}:
"""

print (s.format(a="1"*1, c="3"*3, e="5"*5))

Produzione:

pad
{:3}             :1  :

truncate
{:.3}            :555:

combined
{:>3.3}          :  1:
{:3.3}           :1  :
{:3.3}           :333:
{:3.3}           :555:

Segnaposto nominati

Le stringhe di formato possono contenere segnaposti denominati che vengono interpolati utilizzando gli argomenti delle parole chiave per format .

Usare un dizionario (Python 2.x)

>>> data = {'first': 'Hodor', 'last': 'Hodor!'}
>>> '{first} {last}'.format(**data)
'Hodor Hodor!'

Usare un dizionario (Python 3.2+)

>>> '{first} {last}'.format_map(data)
'Hodor Hodor!'

str.format_map consente di utilizzare i dizionari senza doverli prima decomprimere. Anche la classe di data (che potrebbe essere un tipo personalizzato) viene utilizzata al posto di un dict appena riempito.

Senza un dizionario:

>>> '{first} {last}'.format(first='Hodor', last='Hodor!')
'Hodor Hodor!'