If you are using Python 3.2+, use can use str.format_map().

For bond, bond:

from collections import defaultdict
'{bond}, {james} {bond}'.format_map(defaultdict(str, bond='bond'))

Result:

'bond,  bond'

For bond, {james} bond:

class SafeDict(dict):
    def __missing__(self, key):
        return '{' + key + '}'

'{bond}, {james} {bond}'.format_map(SafeDict(bond='bond'))

Result:

'bond, {james} bond'

In Python 2.6/2.7

For bond, bond:

from collections import defaultdict
import string
string.Formatter().vformat('{bond}, {james} {bond}', (), defaultdict(str, bond='bond'))

Result:

'bond,  bond'

For bond, {james} bond:

from collections import defaultdict
import string

class SafeDict(dict):
    def __missing__(self, key):
        return '{' + key + '}'

string.Formatter().vformat('{bond}, {james} {bond}', (), SafeDict(bond='bond'))

Result:

'bond, {james} bond'

If you are assigning None to your variable, you will have to set some kind of condition around controlling what output you want. Here is a simple example:

"{} {}".format(foo, "" if bar is None else bar)

Another way of looking at the above that behaves the same way, is writing it this way as well:

"{} {}".format(foo, bar if bar is not None else "")

Ignoring un-used arguments makes it possible to create arbitrary format strings for arbitrary-sized dictionaries or objects.

Say you wanted to give your program the feature to let the end-user change the output. You document what fields are available, and tell users to put those fields in {...} slots in a string. The end-user then can create templating strings with any number of those fields being used, including none at all, without error.

In other words, the choice is deliberate, because there are practical reasons for allowing more arguments than are converted. Note that the C# String.Formatter implementation that inspired the Python PEP does the same, for those same reasons.

Not that the discussion on this part of the PEP is that clear cut; Guido van Rossum at some point tries to address this issue:

The PEP appears silent on what happens if there are too few or too many positional arguments, or if there are missing or unused keywords. Missing ones should be errors; I'm not sure about redundant (unused) ones. On the one hand complaining about those gives us more certainty that the format string is correct. On the other hand there are some use cases for passing lots of keyword parameters (e.g. simple web templating could pass a fixed set of variables using **dict). Even in i18n (translation) apps I could see the usefulness of allowing unused parameters

to which the PEP author responded that they were still undecided on this point.

For use-cases where you must raise an exception for unused arguments you are expected to subclass the string.Formatter() class and provide an implementation for Formatter.check_unused_args(); the default implementation does nothing. This of course doesn't help your friend's case where you used str.format(*args, **kwargs) rather than Formatter().format(str, *args, **kwargs). I believe that at some point the idea was that you could replace the formatter used by str.format() with a custom implementation, but that never came to pass.

If you use the flake8 linter, then you can add the flake8-string-format plugin to detect the obvious cases, where you passed in an explicit keyword argument that is not being used by the format string.

This is exactly why %-formatting is old

%-formatting is well known for its inconsistencies about argument handling which result in exceptions or not depending on the type. There are only two ways to use % formatting and avoid inconsistencies:

1. Make sure the formatting string contains exactly one formatting field and pass the object to format as only right argument
2. Use a tuple or dict as right argument. Don't use lists, sets or Models. Only tuples and dicts.

These are taken from the documentation

If format requires a single argument, values may be a single non-tuple object. Otherwise, values must be a tuple with exactly the number of items specified by the format string, or a single mapping object (for example, a dictionary).

Your examples do not fall in these two cases because you have 0 formatting fields, which is different than 1 and thus the right argument must be a tuple or a mapping, but you are passing a string and a user defined object. As such you are under "undefined behaviour".

The inconsistencies on the error messages were already discussed in this question (in my answer).

If you want more consistent behaviour, use str.format.

You need to double the {{ and }}:

>>> x = " {{ Hello }} {0} "
>>> print(x.format(42))
' { Hello } 42 '

Here's the relevant part of the Python documentation for format string syntax:

Format strings contain “replacement fields” surrounded by curly braces {}. Anything that is not contained in braces is considered literal text, which is copied unchanged to the output. If you need to include a brace character in the literal text, it can be escaped by doubling: {{ and }}.

The official solution (Python 3 Docs) for strings in format mappings is to subclass the dict class and to define the magic-method __missing__(). This method is called whenever a key is missing, and what it returns is used for the string formatting instead:

class format_dict(dict):
    def __missing__(self, key):
        return "..."

d = format_dict({"foo": "name"})

print("My %(foo)s is %(bar)s" % d) # "My name is ..."

print("My {foo} is {bar}".format(**d)) # "My name is ..."

Edit: the second print() works in Python 3.5.3, but it does not in e.g. 3.7.2: KeyError: 'bar' is raised and I couldn't find a way to catch it.

After some experiments, I found a difference in Python's behavior. In v3.5.3, the calls are __getitem__(self, "foo") which succeeds and __getitem__(self, "bar") which can not find the key "bar", therefore it calls __missing__(self, "bar") to handle the missing key without throwing a KeyError. In v3.7.2, __getattribute__(self, "keys") is called internally. The built-in keys() method is used to return an iterator over the keys, which yields "foo", __getitem__("foo") succeeds, then the iterator is exhausted. For {bar} from the format string there is no key "bar". __getitem__() and hence __missing_() are not called to handle the situation. Instead, the KeyError is thrown. I don't know how one could catch it, if at all.

In Python 3.2+ you should use format_map() instead (also see Python Bug Tracker - Issue 6081):

from collections import defaultdict
    
d = defaultdict(lambda: "...")
d.update({"foo": "name"})

print("My {foo} is {bar}".format_map(d)) # "My name is ..."

If you want to keep the placeholders, you can do:

class Default(dict):
    def __missing__(self, key): 
        return key.join("{}")
    
d = Default({"foo": "name"})

print("My {foo} is {bar}".format_map(d)) # "My name is {bar}"

As you can see, format_map() does call __missing__().

The following appears to be the most compatible solution as it also works in older Python versions including 2.x (I tested v2.7.15):

class Default(dict):
    def __missing__(self, key):
        return key.join("{}")

d = Default({"foo": "name"})

import string
print(string.Formatter().vformat("My {foo} is {bar}", (), d)) # "My name is {bar}"

To keep placeholders as-is including the format spec (e.g. {bar:<15}) the Formatter needs to be subclassed:

import string

class Unformatted:
    def __init__(self, key):
        self.key = key
    def __format__(self, format_spec):
        return "{{{}{}}}".format(self.key, ":" + format_spec if format_spec else "")

class Formatter(string.Formatter):
    def get_value(self, key, args, kwargs):
        if isinstance(key, int):
            try:
                return args[key]
            except IndexError:
                return Unformatted(key)
        else:
            try:
                return kwargs[key]
            except KeyError:
                return Unformatted(key)


f = Formatter()
s1 = f.vformat("My {0} {1} {foo:<10} is {bar:<15}!", ["real"], {"foo": "name"})
s2 = f.vformat(s1, [None, "actual"], {"bar":"Geraldine"})
print(s1) # "My real {1} name       is {bar:<15}!"
print(s2) # "My real actual name       is Geraldine      !"

Note that the placeholder indices are not changed ({1} remains in the string without a {0}), and in order to substitute {1} you need to pass an array with any odd first element and what you want to substitute the remaining placeholder with as second element (e.g. [None, "actual"]).

You can also call the format() method with positional and named arguments:

s1 = f.format("My {0} {1} {foo:<10} is {bar:<15}!", "real", foo="name")
s2 = f.format(s1, None, "actual", bar="Geraldine")

Literally speaking, yes, it's possible to use str.format without arguments:

>>> 'asdf'.format()
'asdf'

No replacement fields, no arguments necessary. That's not what you're looking for, though.

If you want to pass empty strings for everything, that's not possible with positional replacement fields. It's possible with named replacement fields and format_map:

>>> class Defaults(object):
...     def __getitem__(self, key):
...         return ''
... 
>>> 'asdf {a} fdsa {b}'.format_map(Defaults())
'asdf  fdsa '

We also could have used collections.defaultdict(str) instead of writing our own class, but for this use case, I don't like how defaultdict would unnecessarily populate a (default)dict.

If you really want to do it with positional replacement fields, the best you can do is pass a ton of arguments and hope you have enough for every field. str.format will ignore extra arguments:

>>> 'asdf {} fdsa {}'.format(*['']*100)
'asdf  fdsa '

If you're okay with using a slightly different formatting API, string.Formatter lets subclasses customize value retrieval:

import string
class MyFormatter(string.Formatter):
    def get_value(self, key, args, kwargs):
        # Yes, no * or ** on args or kwargs. That's what the signature looks like.
        try:
            return super(MyFormatter, self).get_value(key, args, kwargs)
        except (IndexError, KeyError):
            return ''

Demo:

>>> MyFormatter().format('asdf {} fdsa {}')
'asdf  fdsa '

Double %% the single % to escape it:

SELECT_CLAUSE += ", IF(%s IS NULL, -1, %s=%%s) AS %s_score" % (
    field, field, field
)

Where is the StringBorg that we direly need? That would make this safe.

You could (and should) use the new string .format() method (if you have Python 2.6 or higher) instead:

"Day old bread, 50% sale {0}".format("today")

The manual can be found here.

The docs also say that the old % formatting will eventually be removed from the language, although that will surely take some time. The new formatting methods are way more powerful, so that's a Good Thing.

There are a few minor issues with most of your lines ignoring specific patterns.

1. %-G%Oh no!\ %m : You have an extra % there, turning the first character into a %O (a command to overread the matched part) rather than a literal O. You also have a trailing space there, so it would only match a line with a space at the end! You can fix that to %-GOh no!\ %m. Note that you don't actually need the \ to escape the space in this format, you only need it when using the :set command, since it breaks on whitespace. You can also just use %.%# at the end of the line, since you're ignoring this pattern anyways.

2. %-G%*\\d\ files%.%#: Here you need a single backslash in %*\d to match a number. Note that this is using a scanf()-style pattern, you can also use a Vim regular expression here to match a sequence of digits, with %\d\+. You have one more issue on your playground for this one, you have no space before files, you have just \files over there, so that needs to be corrected too. Same as above, you don't need to backslash-escape the spaces here, only for a :set command.

3. %-Q: This is a command to pop the last file from stack, but this only makes sense when using a corresponding %P to match a file name relevant for a block of messages. It doesn't look like that's the case here.

Here's the playground with minimal fixes to make it work, and here's a playground with more cleanup (removing the spurious %Q, the backslash escapes spaces, using regex for the digit match and a %.%# to match the end of the "Oh no!" line.)