You can't do it within the format string itself, but using named placeholders, you can pass a dict-like thing to .format_map that contains a generic default value, or combine a dict of defaults for each value with the provided dict to override individually.

Examples:

1. With a defaulting dict-like thing:

   from collections import Counter
   
   fmt_str = "I have {spam} cans of spam and {eggs} eggs."
   
   print(fmt_str.format_map(Counter(eggs=2)))
   

   outputs I have 0 cans of spam and 2 eggs.

2. With combining dict of defaults:

   def format_groceries(**kwargs):
       defaults = {"spam": 0, "eggs": 0, **kwargs}  # Defaults are replaced if kwargs includes same key
       return "I have {spam} cans of spam and {eggs} eggs.".format(defaults)
   
   print(format_groceries(eggs=2))
   

   which behaves the same way.

With numbered placeholders, the solutions end up uglier and less intuitive, e.g.:

def format_up_to_two_things(*args)
    if len(args) < 2:
        args = ('default text', *args)
    return "Text {0} here, and text {1} there".format(*args)

The tutorial doesn't really go into this because 99% of the time, modern Python is using f-strings, and actual f-strings generally don't need to deal with this case, since they're working with arbitrary expressions that either work or don't work, there's no concept of passing an incomplete set of placeholders to them.

As PEP 3101, string.format(**other_dict) is not available.

If the index or keyword refers to an item that does not exist, then an IndexError/KeyError should be raised.

A hint for solving the problem is in Customizing Formatters, PEP 3101. That uses string.Formatter.

I improve the example in PEP 3101:

from string import Formatter

class UnseenFormatter(Formatter):
    def get_value(self, key, args, kwds):
        if isinstance(key, str):
            try:
                return kwds[key]
            except KeyError:
                return key
        else:
            return Formatter.get_value(key, args, kwds)

string = "{number_of_sheep} sheep {has} run away"
other_dict = {'number_of_sheep' : 1}

fmt = UnseenFormatter()
print fmt.format(string, **other_dict)

The output is

1 sheep has run away

You need to either reassign a to a = a.format(one=one, two=two) or simply return it.

return a.format(one=one, two=two)

a.format does not change the original string a, strings are immutable so all a.format does is create a new string. Any time you modify a string it creates a new object. Unless you are using concatenation then to change the value of a you need to reassign a to the new object.

str.replace is another example where people get caught:

In [4]: a = "foobar"

In [5]: id(a)
Out[5]: 140030900696000
In [6]: id(a.replace("f","")) # new object
Out[6]: 140030901037120
In [7]: a = "foobar"     
In [8]: a.replace("f","")
Out[8]: 'oobar'
In [9]: a  # a still the same
Out[9]: 'foobar'
In [10]: id(a)
Out[10]: 140030900696000
In [11]: a = a.replace("f","") # reassign a 
In [12]: id(a) 
Out[12]: 140030900732000    
In [13]: a 
Out[13]: 'oobar'

You are looking for partial:

from functools import partial

MY_STRING = '{name}{age}'
format_name = partial(MY_STRING.format, age=30)
print format_name(name='sameer')
#  sameer30

It is possible to use str.format instead of MY_STRING.format to make this a bit more generic:

format_name = partial(str.format, age=30)
print format_name(MY_STRING, name='sameer')
#  sameer30
print format_name('another string with {name} and {age}', name='sameer')
# another string with sameer and 30

The recommendation in PEP 3101 is to subclass Formatter:

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, ~~, !!, ~~

As set up, it will print ~~ if a field or attribute is not found and !! if an invalid format is used given the field value. (Just use None for the keyword argument bad_fmt if you want the default of a value error raised.)

To handle missing keys, you need to subclass both get_field to catch the KeyError or AttributeError and format_field to return a default value for the missing key.

Since you are catching format_field errors, you can catch a bad format field as well by catching the ValueError from the superclass.

Here is one option:

from collections import defaultdict

my_csv = '{d[first]},{d[middle]},{d[last]}'
print( my_csv.format( d=defaultdict(str, first='John', last='Doe') ) )

Use defaultdict, this will allow you to specify a default value for keys which don't exist in the dictionary. For example:

>>> from collections import defaultdict
>>> d = defaultdict(lambda: 'UNKNOWN')
>>> d.update({'greetings': 'hello'})
>>> '%(greetings)s  %(name)s !!!' % d
'hello  UNKNOWN !!!'
>>>