Is it more Pythonic to use String Formatting over String Concatenation in Python 3?

Question

So I'm programming a text game in Python 3.4 that requires the use of the print() function very often to display variables to the user.

The two ways I've always done this is with string formatting and string concatenation:

print('{} has {} health left.'.format(player, health))

And,

print(player + ' has ' + str(health) + ' health left.')

So which is better? They're both equally as readable and quick to type, and perform exactly the same. Which one is more Pythonic and why?

Question asked as I couldn't find an answer for this on Stack Overflow that wasn't concerned with Java.

Answer 1

Depends upon how long your string is and how many variables. For your use case I believe string.format is better as it has a better performance and looks cleaner to read.

Sometimes for longer strings + looks cleaner because the position of the variables are preserved where they should be in the string and you don't have to move your eyes around to map the position of {} to the corresponding variable.

If you can manage to upgrade to Python 3.6 you can use the newer more intuitive string formatting syntax like below and have best of both worlds:

player = 'Arbiter'
health = 100
print(f'{player} has {health} health left.')

If you have a very large string, I recommend to use a template engine like Jinja2 (http://jinja.pocoo.org/docs/dev/) or something along the line.

Ref: https://www.python.org/dev/peps/pep-0498/

Answer 2

format() is better:

1. Better, performance-wise.
2. clearer. You can see how the sentence looks like and what are the parameters, you don't have a bunch of + and ' all around.
3. Gives you more features for example how many places after zero in a floating point, thus more flexible to changes.

Answer 3

It depends on the quantity and type of objects you're combining, as well as the kind of output you want.

>>> d = '20160105'
>>> t = '013640'
>>> d+t
'20160105013640'
>>> '{}{}'.format(d, t)
'20160105013640'
>>> hundreds = 2
>>> fifties = 1
>>> twenties = 1
>>> tens = 1
>>> fives = 1
>>> ones = 1
>>> quarters = 2
>>> dimes = 1
>>> nickels = 1
>>> pennies = 1
>>> 'I have ' + str(hundreds) + ' hundreds, ' + str(fifties) + ' fifties, ' + str(twenties) + ' twenties, ' + str(tens) + ' tens, ' + str(fives) + ' fives, ' + str(ones) + ' ones, ' + str(quarters) + ' quarters, ' + str(dimes) + ' dimes, ' + str(nickels) + ' nickels, and ' + str(pennies) + ' pennies.'
'I have 2 hundreds, 1 fifties, 1 twenties, 1 tens, 1 fives, 1 ones, 2 quarters, 1 dimes, 1 nickels, and 1 pennies.'
>>> 'I have {} hundreds, {} fifties, {} twenties, {} tens, {} fives, {} ones, {} quarters, {} dimes, {} nickels, and {} pennies.'.format(hundreds, fifties, twenties, tens, fives, ones, quarters, dimes, nickels, pennies)
'I have 2 hundreds, 1 fifties, 1 twenties, 1 tens, 1 fives, 1 ones, 2 quarters, 1 dimes, 1 nickels, and 1 pennies.'
>>> f'I have {hundreds} hundreds, {fifties} fifties, {twenties} twenties, {tens} tens, {fives} fives, {ones} ones, {quarters} quarters, {dimes} dimes, {nickels} nickels, and {pennies} pennies.'
'I have 2 hundreds, 1 fifties, 1 twenties, 1 tens, 1 fives, 1 ones, 2 quarters, 1 dimes, 1 nickels, and 1 pennies.'

It is much easier to create without error a large format string than it is to do a lot of concatenation, too. Add in the fact that format strings can handle actual formatting, like alignment or rounding, and you'll soon leave concatenation for only the simplest cases, as shown above.