Python string formatting

Question

I'm studying the code of an open source project. The code it's written in python and unfortunately I'm not so experienced with it. I found a lot of statement in the code like this:

print "the string is %s" % (name_of_variable, )

I know that, similarly to c language, this is a way to properly format the output, but I really don't understand what is the meaning of the comma right after the "name_of_variable" within the parenthesis.

I searched through python documentation, but I didn't find nothing about that kind of statement. Does anyone know what is its meaning?

Answer 1

The trailing comma is a way to create a one-element tuple. Normally you create a tuple by listing a set of values or variables in parentheses, separated by a comma:

my_tuple = (1, 2, 3)

However, the parentheses are not actually necessary. You can create a tuple like this:

my_tuple = 1, 2, 3

Of course, this raises an issue with one-element tuples. If you leave out the parentheses, you're just assigning a variable to a single variable:

my_tuple = 1    # my_tuple is the integer 1, not a one-element tuple!

But using parentheses is ambiguous, since surrounding a value in parentheses is totally legal:

my_tuple = (1)    # my_tuple is still the integer 1, not a one-element tuple

So you indicate a one-element tuple by adding a trailing comma:

my_tuple = 1,
# or, with parentheses
my_tuple = (1,)

String formatting takes a tuple as an arguments, so if you're using a one-element tuple, you'd use a trailing comma. (Of course, string formatting has special handling for cases in which you are passing only one variable to be formatted—you can just use a value in those cases, instead of a tuple.)

Answer 2

If name_of_variable is a tuple, then

print "the string is %s" % (name_of_variable)

will throw a TypeError.

As a result you'll have to use print "the string is %s" % (name_of_variable, ) to print it.

Answer 3

The comma is used when you have more than one variables. eg

print "the string is %s %s" % (name_of_variable1, name_of_variable2)

More details are here https://stackoverflow.com/a/5082482/2382792

Answer 4

It doesn't matter whether you have comma or not when you are using only one variable, you also don't need the parentheses with only one variable.

It uses tuple (parentheses and comma) here just to be consistent with the multiple variables situations.

And, if you don't have a comma in a one-element tuple, it's no longer a tuple.

For example, a = (1) type(a) # <type 'int'>

People also like to append an additional comma after the last element in a tuple even if they have more than one elements to keep consistency.

Answer 5

This is the syntax to create one-element tuple. See this link for example. It's not essential here, as print will also accept one variable, but in general (x) is equivalent to x, so the only way to force it to be interpreted as a tuple syntax is this weird-looking form. Note the difference:

>>> x = 0
>>> (x)
0
>>> (x,)
(0,)
>>> type((x))
<type 'int'>
>>> type((x,))
<type 'tuple'>
>>>

Also, the parentheses are not needed:

>>>x,
>>>(0,)

You may want to also read about %-formatting syntax.

Answer 6

The comma in (x,) is to tell Python the parenthesis enclose a tuple, as opposed to a parenthesized form of a single value subexpression (most frequently used to change operator precedence, such as (a+b) * 2 being different from a + b*2). The string formatting operator is fairly good at guessing when a single value is not supposed to be a sequence, but if you were to pass a tuple instead of a string it would get unwrapped:

>>> mytup=("Hello world!",)
>>> print "%s"%(mytup)
Hello world!
>>> print "%s"%(mytup,)
('Hello world!',)
>>> mytup=("Hello world!","Yoo-hoo, big summer blow-out!")
>>> print "%s"%(mytup)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: not all arguments converted during string formatting

The operator tries to resemble a function call, where the argument list is always passed as a tuple (and possibly a dictionary for named arguments). This discrepancy disappears when instead called as str.format as the tuple-forming parenthesis are part of the method call syntax.

Answer 7

Here , is not specific as you are using only single variable.

In [96]: print "the string is %s" % (name_of_variable, )
the string is assdf

In [97]: print "the string is %s" % name_of_variable
the string is assdf

Output is same.

but if the name_of_variable is a tuple then it's necessary to use , in print statement

In [4]: tup = (1,2,)
In [6]:  print ("the string is %s" % (tup))
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-6-fb9ef4de3ac3> in <module>()
----> 1 print ("the string is %s" % (tup))

TypeError: not all arguments converted during string formatting

In [7]:  print ("the string is %s" % (tup,))
the string is (1, 2)