Lasciando valori vuoti se non passato in str.format

Un modo per evitare l'errore chiave è quello di includere nel dict ma lasciarlo vuoto:

kwargs = {"name": "mark", "adjective": ""}
"My name is {name} and I'm really {adjective}.".format(**kwargs)

argomenti chiave si aspettano che il loro di essere una chiave in kwargs. Un altro modo per farlo sarebbe argomenti posizionali:

"My name is {0} and I'm really {1}.".format("mark")

Stampe "Mi chiamo Marco e sono davvero." Mentre

"My name is {0} and I'm really {1}.".format("mark","black")

Stampe "Mi chiamo Marco e sono davvero nero."

In alternativa, si può prendere il ValueError.

Qui è un'opzione che utilizza collections.defaultdict:

>>> from collections import defaultdict
>>> kwargs = {"name": "mark"}
>>> template = "My name is {0[name]} and I'm really {0[adjective]}."
>>> template.format(defaultdict(str, kwargs))
"My name is mark and I'm really ."

Si noti che non stiamo usando **per decomprimere il dizionario in argomenti a parola chiave più, e l'identificatore di formato utilizza {0[name]}e {0[adjective]}, il che indica che dovremmo eseguire una ricerca fondamentale sul primo argomento di format()utilizzare "name"e "adjective", rispettivamente. Usandodefaultdict una chiave mancante si tradurrà in una stringa vuota invece di sollevare KeyError.

Per il record:

s = "My name is {name} and I'm really {adjective}."
kwargs = dict((x[1], '') for x in s._formatter_parser())
# Now we have: `kwargs = {'name':'', 'adjective':''}`.
kwargs.update(name='mark')
print s.format(**kwargs)  # My name is mark and I'm really .

Volevo aggiungere una soluzione abbastanza semplice per la sostituzione di eventuali valori predefiniti necessari.

import string

class SafeDict(dict):
    def __init__(self, missing='#', empty='', *args, **kwargs):
        super(SafeDict, self).__init__(*args, **kwargs)
        self.missing = missing
        self.empty = empty
    def __getitem__(self, item):
        return super(SafeDict, self).__getitem__(item) or self.empty
    def __missing__(self, key):
        return self.missing

values = SafeDict(a=None, c=1})
string.Formatter().vformat('{a} {c} {d}', (), values)
# ' 1 #'

Mentre sottoclasse una Formatterè probabilmente la risposta "giusta", è anche possibile seguire forte vena chiedere-per-il perdono-non-permesso di Python catturando il KeyError. Il vantaggio di questo approccio è che è facilmente flessibile: In particolare, è facile avere valori di "default" che non sono statico (cioè, solo la costante eventualmente vuoto), ma può dipendere il nome della chiave, come qui :

def f(s, **kwargs):
    """Replaces missing keys with a pattern."""
    RET = "{{{}}}"
    try:
        return s.format(**kwargs)
    except KeyError as e:
        keyname = e.args[0]
        return f(s, **{ keyname: RET.format(keyname) }, **kwargs)

che funzionerà nel seguente modo:

In [1]: f("My name is {name} and I'm really {adjective}.", **{"name": "Mark"})
Out[1]: "My name is Mark and I'm really {adjective}."

Questo può essere facilmente specializzata a fare ciò che il PO voleva:

def f_blank(s, **kwargs):
    """Replaces missing keys with a blank."""
    try:
        return s.format(**kwargs)
    except KeyError as e:
        keyname = e.args[0]
        return f(s, **{ keyname: "" }, **kwargs)

Ho avuto un po 'più divertente con questa idea: https://gist.github.com/jlumbroso/57951c06a233c788e00d0fc309a93f91

# (not a real import! just saying importing the code from the Gist)
from gist.57951c06a233c788e00d0fc309a93f91 import _make_f

# Define replacement f"..." compatible with Python 2 and 3
_f = _make_f(globals=lambda: globals(), locals=lambda: locals())

# Use:
s = "Test"
var = 1
assert _f("{s} {var}") == "Test 1"

# Inside a non-global scope, you may have to provide locals
def test():
    l_s = "Test"
    l_var = 1
    assert _f("{l_s} {l_var} / {s} {var}") == "{l_s} {l_var} / Test 1"
    assert _f("{l_s} {l_var} / {s} {var}", **locals()) == "Test 1 / Test 1"

Se siete ancora su Python 2, è possibile utilizzare defaultdictcon string.Formatterper raggiungere questo obiettivo:

>>> format_string = '{foo:<2s}{bar:<3s}'
>>> data = {'bar': 'baz'}
>>> string.Formatter().vformat(format_string, (), defaultdict(str, data))
'  baz'