Why format()
is more flexible than %
string operations
I think you should really stick to format()
method of str
, because it is the preferred way to format strings and will probably replace string formatting operation in the future.
Furthermore, it has some really good features, that can also combine position-based formatting with keyword-based one:
>>> string = 'I will be {} years and {} months on {month} {day}'
>>> some_date = {'month': 'January', 'day': '1st'}
>>> diff = [3, 11] # years, months
>>> string.format(*diff, **some_date)
'I will be 3 years and 11 months on January 1st'
even the following will work:
>>> string = 'On {month} {day} it will be {1} months, {0} years'
>>> string.format(*diff, **some_date)
'On January 1st it will be 11 months, 3 years'
There is also one other reason in favor of format()
. Because it is a method, it can be passed as a callback like in the following example:
>>> data = [(1, 2), ('a', 'b'), (5, 'ABC')]
>>> formatter = 'First is "{0[0]}", then comes "{0[1]}"'.format
>>> for item in map(formatter, data):
print item
First is "1", then comes "2"
First is "a", then comes "b"
First is "5", then comes "ABC"
Isn't it a lot more flexible than string formatting operation?
See more examples on documentation page for comparison between %
operations and .format()
method.
Comparing tuple-based %
string formatting with dictionary-based
Generally there are three ways of invoking %
string operations (yes, three, not two) like that:
base_string % values
and they differ by the type of values
(which is a consequence of what is the content of base_string
):
it can be a tuple
, then they are replaced one by one, in the order they are appearing in tuple,
>>> 'Three first values are: %f, %f and %f' % (3.14, 2.71, 1)
'Three first values are: 3.140000, 2.710000 and 1.000000'
it can be a dict
(dictionary), then they are replaced based on the keywords,
>>> 'My name is %(name)s, I am %(age)s years old' % {'name':'John','age':98}
'My name is John, I am 98 years old'
it can be a single value, if the base_string
contains single place where the value should be inserted:
>>> 'This is a string: %s' % 'abc'
'This is a string: abc'
There are obvious differences between them and these ways cannot be combined (in contrary to format()
method which is able to combine some features, as mentioned above).
But there is something that is specific only to dictionary-based string formatting operation and is rather unavailable in remaining three formatting operations' types. This is ability to replace specificators with actual variable names in a simple manner:
>>> name = 'John'
>>> surname = 'Smith'
>>> age = 87
# some code goes here
>>> 'My name is %(surname)s, %(name)s %(surname)s. I am %(age)i.' % locals()
'My name is Smith, John Smith. I am 87.'
Just for the record: of course the above could be easily replaced by using format()
by unpacking the dictionary like that:
>>> 'My name is {surname}, {name} {surname}. I am {age}.'.format(**locals())
'My name is Smith, John Smith. I am 87.'
Does anyone else have an idea what could be a feature specific to one type of string formatting operation, but not to the other? It could be quite interesting to hear about it.
This could easily become an opinion-based thread, but I find formatting to be more readable in most cases, and more maintainable. It's easier to visualize what the final string will look like, without doing "mental concatenation". Which of these is more readable, for example?
errorString = "Exception occurred ({}) while executing '{}': {}".format(
e.__class__.__name__, task.name, str(e)
)
Or:
errorString = "Exception occurred (" + e.__class__.__name__
+ ") while executing '" + task.name + "': " + str(e)
As for whether to use %
or .format()
, I can answer more objectively: Use .format()
. %
is the "old-style", and, per the Python Documentation they may soon be removed:
Since str.format()
is quite new, a lot of Python code still uses the %
operator. However, because this old style of formatting will eventually be removed from the language, str.format()
should generally be used.
Later versions of the documentation have stopped mentioning this, but nonetheless, .format()
is the way of the future; use it!
Concatenation is faster, but that should not be a concern. Make your code readable and maintainable as a first-line goal, and then optimize the parts you need to optimize later. Premature optimization is the root of all evil ;)
Best Answer
To answer your first question...
.format
just seems more sophisticated in many ways. An annoying thing about%
is also how it can either take a variable or a tuple. You'd think the following would always work:yet, if
name
happens to be(1, 2, 3)
, it will throw aTypeError
. To guarantee that it always prints, you'd need to dowhich is just ugly.
.format
doesn't have those issues. Also in the second example you gave, the.format
example is much cleaner looking.Only use it for backwards compatibility with Python 2.5.
To answer your second question, string formatting happens at the same time as any other operation - when the string formatting expression is evaluated. And Python, not being a lazy language, evaluates expressions before calling functions, so the expression
log.debug("some debug info: %s" % some_info)
will first evaluate the string to, e.g."some debug info: roflcopters are active"
, then that string will be passed tolog.debug()
.