better way to pass data to print in python

Question

I was going through http://web2py.com/book/default/chapter/02 and found this:

>>> print 'number is ' + str(3)
number is 3
>>> print 'number is %s' % (3)
number is 3
>>> print 'number is %(number)s' % dict(number=3)
number is 3

It has been given that The last notation is more explicit and less error prone, and is to be preferred.

I am wondering what is the advantage of using the last notation.. will it not have a performance overhead?

Answer 1

I can think of a few differences.

1. First to me is cumbersome, if more than one variable is involved. I can not speak of performance penalty on that. See additional arguments below.

2. The second example is positional dependent and it can be easy to change position causing errors. It also does not tell you anything about the variables.

3. The third example, the position of variables is not important. You use a dictionary. This makes it elegant as it does not rely on positional structuring of variables.

See the example below:

>>> print 'number is %s %s' % (3,4)
number is 3 4
>>> print 'number is %s %s' % (4,3)
number is 4 3
>>> print 'number is %(number)s %(two)s' % dict(number=3, two=4)
number is 3 4
>>> print 'number is %(number)s %(two)s' % dict(two=4, number=3)
number is 3 4
>>> 

Also another part of discussion on this

"+" is the string concatenation operator.

"%" is string formatting.

In this trivial case, string formatting accomplishes the same result as concatenation. Unlike string formatting, string concatenation only works when everything is already a string. So if you miss to convert your variables to string, concatenation will cause error.

[Edit: My answer was biased towards templating since the question came from web2py where templates are so commonly involved]

As Ryan says below, the concatenation is faster than formatting.

Suggestion is

1. Use the first form - concatenation, if you are concatenating just two strings

2. Use the second form, if there are few variables. You can invariably see the positions and deal with them

3. Use the third form when you are doing templating i.e. formatting a large piece of string with variable data. The dictionary form helps in providing meaning to variables inside the large piece of text.

Answer 2

I am wondering what is the advantage of using the last notation..

Hm, as you said, the last notation is really more explicit and actually is less error prone.

will it not have a performance overhead?

It will have little performance overhead, but it's minor if compared with data fetching from DB or network connections.

Answer 3

>>> print 'number is ' + str(3)
number is 3

This is definitely the worst solution and might cause you problems if you do the beginner mistake "Value of obj: " + obj where obj is not a string or unicode object. For many concatenations, it's not readable at all - it's similar to something like echo "<p>Hello ".$username."!</p>"; in PHP (this can get arbitrarily ugly).

---

print 'number is %s' % (3) number is 3

Now that is much better. Instead of a hard-to-read concatenation, you see the output format immediately. Coming back to the beginner mistake of outputting values, you can do print "Value of obj: %r" % obj, for example. I personally prefer this in most cases. But note that you cannot use it in gettext-translated strings if you have multiple format specifiers because the order might change in other languages.

As you forgot to mention it here, you can also use the new string formatting method which is similar:

>>> "number is {0}".format(3)
'number is 3'

---

Next, dict lookup:

>>> print 'number is %(number)s' % dict(number=3)
number is 3

As said before, gettext-translated strings might change the order of positional format specifiers, so this option is the best when working with translations. The performance drop should be negligible - if your program is not all about formatting strings.

As with the positional formatting, you can also do it in the new style:

>>> "number is {number}".format(number=3)
'number is 3'

---

It's hard to tell which one to take. I recommend you to use positional arguments with the % notation for simple strings and dict lookup formatting for translated strings.

Answer 4

It's a bad, unjustified piece of advice.

The third method is cumbersome, violates DRY, and error prone, except if:

1. You are writing a framework which don't have control over the format string. For example, logging module, web2py, or gettext.
2. The format string is extremely long.
3. The format string is read from a file from a config file.

The problem with the third method should be obvious when you consider that foo appears three times in this code: "%(foo)s" % dict(foo=foo). This is error prone. Most programs should not use the third method, unless they know they need to.

The second method is the simplest method, and is what you generally use in most programs. It is best used when the format string is immediate, e.g. 'values: %s %s %s' % (a, b, c) instead of taken from a variable, e.g. fmt % (a, b, c).

The first concatenation is almost never useful, except perhaps if you're building list by loops:

s = ''
for x in l:
    s += str(x)

however, in that case, it's generally better and faster to use str.join():

s = ''.join(str(x) for x in l)