Come posso formattare una stringa usando un dizionario in python-3.x?

Sono un grande fan dell'uso dei dizionari per formattare le stringhe. Mi aiuta a leggere il formato di stringa che sto usando e mi permette di sfruttare i dizionari esistenti. Per esempio:

class MyClass:
    def __init__(self):
        self.title = 'Title'

a = MyClass()
print 'The title is %(title)s' % a.__dict__

path = '/path/to/a/file'
print 'You put your file here: %(path)s' % locals()

Tuttavia, non riesco a capire la sintassi di Python 3.x per fare lo stesso (o se ciò è persino possibile). Vorrei fare quanto segue

# Fails, KeyError 'latitude'
geopoint = {'latitude':41.123,'longitude':71.091}
print '{latitude} {longitude}'.format(geopoint)

# Succeeds
print '{latitude} {longitude}'.format(latitude=41.123,longitude=71.091)

Poiché la domanda è specifica di Python 3, ecco la nuova sintassi f-string , disponibile da Python 3.6:

>>> geopoint = {'latitude':41.123,'longitude':71.091}
>>> print(f'{geopoint["latitude"]} {geopoint["longitude"]}')
41.123 71.091

Nota le virgolette singole esterne e le doppie virgolette interne (puoi farlo anche al contrario).

Ti va bene?

geopoint = {'latitude':41.123,'longitude':71.091}
print('{latitude} {longitude}'.format(**geopoint))

Per decomprimere un dizionario in argomenti di parole chiave, utilizzare **. Inoltre, la formattazione di nuovo stile supporta il riferimento ad attributi di oggetti ed elementi di mappature:

'{0[latitude]} {0[longitude]}'.format(geopoint)
'The title is {0.title}s'.format(a) # the a from your first example

Dato che Python 3.0 e 3.1 sono EOL e nessuno li usa, puoi e dovresti usare str.format_map(mapping)(Python 3.2+):

Simile a str.format(**mapping), tranne per il fatto che la mappatura viene utilizzata direttamente e non copiata in adict . Ciò è utile se ad esempio il mapping è una dictsottoclasse.

Ciò significa che è possibile utilizzare ad esempio un defaultdictche imposta (e restituisce) un valore predefinito per le chiavi mancanti:

>>> from collections import defaultdict
>>> vals = defaultdict(lambda: '<unset>', {'bar': 'baz'})
>>> 'foo is {foo} and bar is {bar}'.format_map(vals)
'foo is <unset> and bar is baz'

Anche se la mappatura fornita è una dict, non una sottoclasse, probabilmente sarebbe comunque leggermente più veloce.

Tuttavia, la differenza non è grande

>>> d = dict(foo='x', bar='y', baz='z')

poi

>>> 'foo is {foo}, bar is {bar} and baz is {baz}'.format_map(d)

è circa 10 ns (2%) più veloce di

>>> 'foo is {foo}, bar is {bar} and baz is {baz}'.format(**d)

sul mio Python 3.4.3. La differenza sarebbe probabilmente maggiore poiché più chiavi sono nel dizionario e

Si noti che il linguaggio del formato è molto più flessibile di quello però; possono contenere espressioni indicizzate, accessi agli attributi e così via, in modo da poter formattare un intero oggetto o 2 di essi:

>>> p1 = {'latitude':41.123,'longitude':71.091}
>>> p2 = {'latitude':56.456,'longitude':23.456}
>>> '{0[latitude]} {0[longitude]} - {1[latitude]} {1[longitude]}'.format(p1, p2)
'41.123 71.091 - 56.456 23.456'

A partire dalla 3.6 puoi usare anche le stringhe interpolate:

>>> f'lat:{p1["latitude"]} lng:{p1["longitude"]}'
'lat:41.123 lng:71.091'

Devi solo ricordare di usare gli altri caratteri tra virgolette. Un altro aspetto positivo di questo approccio è che è molto più veloce di chiamare un metodo di formattazione.

print("{latitude} {longitude}".format(**geopoint))

La sintassi di Python 2 funziona anche in Python 3:

>>> class MyClass:
...     def __init__(self):
...         self.title = 'Title'
... 
>>> a = MyClass()
>>> print('The title is %(title)s' % a.__dict__)
The title is Title
>>> 
>>> path = '/path/to/a/file'
>>> print('You put your file here: %(path)s' % locals())
You put your file here: /path/to/a/file

geopoint = {'latitude':41.123,'longitude':71.091}

# working examples.
print(f'{geopoint["latitude"]} {geopoint["longitude"]}') # from above answer
print('{geopoint[latitude]} {geopoint[longitude]}'.format(geopoint=geopoint)) # alternate for format method  (including dict name in string).
print('%(latitude)s %(longitude)s'%geopoint) # thanks @tcll

La maggior parte delle risposte ha formattato solo i valori del dict.

Se vuoi formattare anche la chiave nella stringa puoi usare dict.items () :

geopoint = {'latitude':41.123,'longitude':71.091}
print("{} {}".format(*geopoint.items()))

Produzione:

('latitudine', 41.123) ('longitudine', 71.091)

Se vuoi formattare in modo arbitrario, cioè non mostrare i valori-chiave come le tuple:

from functools import reduce
print("{} is {} and {} is {}".format(*reduce((lambda x, y: x + y), [list(item) for item in geopoint.items()])))

Produzione:

la latitudine è 41.123 e la longitudine è 71.091