Как заставить Python изящно форматировать None и несуществующие поля [дубликаты]

В PEP 3101 рекомендуется создать подкласс Форматтер:

import string
class PartialFormatter(string.Formatter):
    def __init__(self, missing='~~', bad_fmt='!!'):
        self.missing, self.bad_fmt=missing, bad_fmt

    def get_field(self, field_name, args, kwargs):
        # Handle a key not found
        try:
            val=super(PartialFormatter, self).get_field(field_name, args, kwargs)
            # Python 3, 'super().get_field(field_name, args, kwargs)' works
        except (KeyError, AttributeError):
            val=None,field_name 
        return val 

    def format_field(self, value, spec):
        # handle an invalid format
        if value==None: return self.missing
        try:
            return super(PartialFormatter, self).format_field(value, spec)
        except ValueError:
            if self.bad_fmt is not None: return self.bad_fmt   
            else: raise

fmt=PartialFormatter()
data = {'n': 3, 'k': 3.141594, 'p': {'a': '7', 'b': 8}}
print(fmt.format('{n}, {k:.2f}, {p[a]}, {p[b]}', **data))
# 3, 3.14, 7, 8
del data['k']
data['p']['b'] = None
print(fmt.format('{n}, {k:.2f}, {p[a]:.2f}, {p[b]}', **data))
# 3, ~~, !!, ~~

В соответствии с настройками он будет печатать ~~, если поле или атрибут не найдены, и !!, если для значения поля используется недопустимый формат. (Просто используйте None для аргумента ключевого слова bad_fmt, если вы хотите, чтобы по умолчанию поднималась ошибка значения.)

Чтобы обработать отсутствующие ключи, вам нужно создать подкласс как get_field, чтобы поймать KeyError, так и AttributeError и format_field, чтобы вернуть значение по умолчанию для отсутствующего ключа.

Поскольку вы отлавливаете ошибки format_field, вы также можете отловить поле неправильного формата, перехватив ValueError из суперкласса.

Если вы можете выполнять форматирование отдельно, вы можете использовать Template.safe_substitute, который изящно обрабатывает отсутствующие значения:

>>> from string import Template
>>> t = Template("$a $b $c")
>>> t.safe_substitute(a=3)
'3 $b $c'

Метод str.format() не дает вам прямого метода для обработки отсутствующих ключей или замены значений.

Вы можете добавить уровень косвенности; передайте сопоставление, которое обрабатывает отсутствующие и None значения, и измените формат, чтобы использовать только этот аргумент:

class PlaceholderFormatValue():
    def __format__(self, spec):
        return '~'
    def __getitem__(self, name):
        # handle further nested item access
        return self

class formatting_dict(dict):
    def __getitem__(self, name):
        value = self.get(name)
        if isinstance(value, dict):
            # rewrap nested dictionaries to handle missing nested keys
            value = type(self)(value)
        return value if value is not None else PlaceholderFormatValue()

print('{0[n]}, {0[k]:.2f}, {0[p][a]}, {0[p][b]}'.format(formatting_dict(data)))

Теперь все слоты ссылаются на позиционный аргумент 0, который обрабатывается как словарь, но поиск по ключу всегда завершается успешно, а отсутствующие значения и None заменяются значением-заполнителем.

Здесь PlaceholderFormatValue() гарантирует, что независимо от того, что дает спецификация формата, значение может быть интерполировано в формат. Например, это заставляет работать {0[k]:.2f}.

Обертывая любые значения dict и имея доступ к элементу дескриптора PlaceholderFormatValue, вышеизложенное также может обрабатывать отказ от предоставления вложенных ключей или целых словарей:

>>> data = {'n': 3, 'k': 3.141594, 'p': {'a': 7, 'b': 8}}
>>> del data['k']
>>> data['p']['b'] = None
>>> print('{0[n]}, {0[k]:.2f}, {0[p][a]}, {0[p][b]}'.format(formatting_dict(data)))
3, ~, 7, ~
>>> del data['p']['a']
>>> print('{0[n]}, {0[k]:.2f}, {0[p][a]}, {0[p][b]}'.format(formatting_dict(data)))
3, ~, ~, ~
>>> del data['p']
>>> print('{0[n]}, {0[k]:.2f}, {0[p][a]}, {0[p][b]}'.format(formatting_dict(data)))
3, ~, ~, ~