In Python, it is tedious to write:
print "foo is" + bar + '.'
Can I do something like this in Python?
print "foo is #{bar}."
-
I think I've found a solution, would you check it out? stackoverflow.com/questions/16504732/…HarmonicaMuse– HarmonicaMuse2013-05-12 10:25:33 +00:00Commented May 12, 2013 at 10:25
Add a comment
|
10 Answers
Python 3.6+ does have variable interpolation - prepend an f to your string:
f"foo is {bar}"
For versions of Python below this (Python 2 - 3.5) you can use str.format to pass in variables:
# Rather than this:
print("foo is #{bar}")
# You would do this:
print("foo is {}".format(bar))
# Or this:
print("foo is {bar}".format(bar=bar))
# Or this:
print("foo is %s" % (bar, ))
# Or even this:
print("foo is %(bar)s" % {"bar": bar})
9 Comments
mko
The 3rd one looks neat, but I remember this way kinda deprecated? is that true?
Brian M. Hunt
There is also, for the lazy,
print "foo is %(bar)s" % locals().
Sean Vieira
@yozloy - correct it is deprecated in Python 3 (as I understand it).
Jeff Widman
the % syntax is no longer deprecated in Python 3: stackoverflow.com/a/23381153/770425
smci
This is incorrect since 3.6 introduced f-strings
|
Python 3.6 will have has literal string interpolation using f-strings:
print(f"foo is {bar}.")
1 Comment
Toni Sučić
In case anyone was wondering: yes, you can combine this with say raw strings, like so
rf"foo is {bar}".Python 3.6 has introduced f-strings:
print(f"foo is {bar}.")
Old answer:
Since version 3.2 Python has str.format_map which together with locals() or globals() allows you to do fast:
Python 3.3.2+ (default, Feb 28 2014, 00:52:16)
>>> bar = "something"
>>> print("foo is {bar}".format_map(locals()))
foo is something
>>>
Comments
I have learned the following technique from Python Essential Reference:
>>> bar = "baz"
>>> print "foo is {bar}.".format(**vars())
foo is baz.
This is quite useful when we want to refer to many variables in the formatting string:
- We don't have to repeat all variables in the argument list again: compare it to the explicit keyword argument-based approaches (such as
"{x}{y}".format(x=x, y=y)and"%(x)%(y)" % {"x": x, "y": y}). - We don't have to check one by one if the order of variables in the argument list is consistent with their order in the formatting string: compare it to the positional argument-based approaches (such as
"{}{}".format(x, y),"{0}{1}".format(x, y)and"%s%s" % (x, y)).
2 Comments
Josiah
That's an... odd way to pass in bar... Pretty neat though, makes it more closely follow the Ruby way.
Mike T
This seems like the best solution if you're working with an object. For example, if you are reporting an urllib2.HTTPError you can do
"HTTP error: {error.code} {error.msg}".format(**vars()) This doesn't work with format(**locals())>>> bar = 1
>>> print "foo is {}.".format(bar)
foo is 1.
4 Comments
Edmon
or older but still popular: print "foo is %s" % str(bar)
Josiah
That's supposed to be deprecated by now, though I can't find the PEP.
Sean Vieira
Not deprecated, just superseded.
Josiah
I guess in Python 2 it's not, but it was at least supposed to be deprecated by 3.1, which was released some time ago.
I prefer this approach because you don't have to repeat yourself by referencing the variable twice:
alpha = 123
print 'The answer is {alpha}'.format(**locals())
2 Comments
There is a big difference between this in Ruby:
print "foo is #{bar}."
And these in Python:
print "foo is {bar}".format(bar=bar)
In the Ruby example, bar is evaluated
In the Python example, bar is just a key to the dictionary
In the case that you are just using variables the behave more or less the same, but in general, converting Ruby to Python isn't quite so simple
1 Comment
smci
This is incorrect since 3.6. We now have
print(f"foo is #{bar}")Yes, absolutely. Python, in my opinion, has great support for string formatting, replacements and operators.
This might be helpful:
http://docs.python.org/library/stdtypes.html#string-formatting-operations
Comments
You can also use Template Strings like this:
from string import Template
s = Template('$who likes $what')
s.substitute(who='tim', what='kung pao')
# 'tim likes kung pao'
This works really well for when you want to build the string template ahead of time and inject the variable elsewhere
See Also: PEP 292 – Simpler String Substitutions
Comments
Almost every other answer didn't work for me. Probably it's because I'm on Python3.5. The only thing which worked is:
print("Foobar is %s%s" %('Foo','bar',))
Comments
