FAQ: String Methods - .format()

"The poem \"{}\" is written by {}."

The topic of escape characters must have come up in early lessons on strings.

Above, the quotes inside the string are escaped so they are ignored by the string parser and render as printed characters.

The output will look like,

The poem "I Hear America Singing" is written by Walt Whitman.

We can also write the code so the string is in single quotes. This way no excapement is required.

'The poem "{}" is written by {}.'


Why are the arguments flipped around when it comes to the .format() code? According to codecademy, the top is incorrect, and the bottom is correct. Why, though?

Originally I wrote it this way:

def poem_title_card(title, poet):
  return "The poem \"{}\" is written by {}".format(title, poet)

I’m very confused. This is the code that codecademy gave as the solution:

def poem_title_card(poet, title):
  poem_desc = "The poem \"{}\" is written by {}".format(title, poet)
  return poem_desc

codecademy didn’t flip the arguments around in the example, so I don’t understand why this is happening now.


They are flipped around because of the order in which they are interpolated in the string. TITLE, first, then, POET. It doesn’t matter what order they are given in the parameter so long as the arguments in the call expression match the correct variable.

If the parameters are written,

(title, poet)

then arguments must be,

("I Hear America Singing", "Walt Whitman")

else if written as such,

(poet, title)

then the arguments must be,

("Walt Whitman", "I Hear America Singing")

Either way won’t matter to the output string. The format arguments are ordered according to how they present.

Now in a case where we wish to have both lists the same, say,

(poet, title)

in the parameters, and,

(poet, title)

in the format arguments, we can use numbers in the placeholder to identify which argument goes where…

'The poem "{2}" is written by {1}.'.format(poet, title)


Instructions say which order the arguments will be provided in to the function


Thanks, that’s very useful to know, especially that last bit about placeholders.

I do understand why the format arguments have to be in a certain order (“according to how they present”), but I’m not sure why the arguments in def poem_title_card(title, poet): need to be flipped. Why can it not be def poem_title_card(poem,title)?


I can see that, too, but is it that way just because the instructions arbitrarily say so?

I don’t see what makes this example so different from the Santana example, that the order the arguments are provided to the function needs to be vice versa.


Argument order is always significant, that is what says which value is which
It’s the same thing as when you send arguments to str’s format method, the order is what says which is which


So then why does the Santana example need the arguments provided in the opposite order?


Opposite to what?

If you mean that there ought to be consistency between the order of title-author … sure? But python certainly doesn’t care about that


in the original argument, it asks for “song, artist,” and then, after .format(, “song, artist.”

Yet in the example I just provided, which is very similar to the Santana one, I need to flip around the arguments. I don’t need to do that with the Santana example.

furthter response:

Then why wouldn’t Python accept this code as correct?:

def poem_title_card(title, poet):
  poem_desc = "The poem \"{}\" is written by {}".format(title, poet)
  return poem_desc

WHAT IS WRONG WITH THAT CODE?? Python says that it’s wrong.

codecademy is not letting me write anymore messages :confused:


Like you point out, codecademy’s designs of the function signatures are a bit inconsistent but it doesn’t have anything to do with python does it?

They say which order the arguments are provided, and yeah they don’t quite match but I kind of fail to care, just write the functions to the provided specs

Good job hitting that limit. I raised it. I think.


yes but I’m new to learning Python, so when these errors occur, it makes me think that I did something wrong. So I could have written what I originally wrote, and it should have been okay?

And thanks for raising the limit. I’m not trying to be a nuisance.


Nah that limit only exists to prevent sudden large quantities of spam.

The order doesn’t match in the specification, but… The easiest way for me to express it is that I’m not bothered by it, and I’m easily bothered by issues is exercises.
You ought to be reading the instructions and matching your code to them… It’s not wrong in some way, just different.
Both of those instructions say which order the values will be fed to your function.

If you were writing a library with many exported function where signatures were similar but had very different ways to use them, like different orders then, yeah that’d be poor design. Here though? Meh.


Point taken, I will follow the instructions as given to me from now on. But just to be clear, the error message at the bottom doesn’t make sense, does it?:

my format arguments are in the correct order, yet look at what it says that my code is returning.

According to that, Walt Whitman is the “title” and “I hear America Singing” is the poet.


No your format arguments are in the wrong order, because the title should come first and then the poet, but you’ve done it the other way around because the first argument provided to the function is the poet

(if you rename your parameters to arg1 and arg2 that makes more sense)

The order they appear in the string shouldn’t be considered related to the order of the parameters

At a glance anyway (not going to bother comparing exactly), the error message seems to match the instructions


Thanks, that does make sense.

Wow, it just hit me like a ton of bricks. Ugh, I’m sorry.


Is there any way in which doing the method provided in this exercise:

'The poem \"{}\" is written by {}.'.format(title, poet)

is better than:

'The poem "%s" is written by %s.' % (title, poet)

The second method seems simpler to me. Am I missing something? Is there a scenario where .format() is better?


The second example is legacy code inherited from C and written into early versions of Python, while the first was a late addition to version 2.7.x, i believe. It is far superior to the its predecessor in many ways.

This page compares the two…


Study the examples and in the end, ask yourself, which is more powerful and robust?


When the opening/closing quotes are single, we don’t need to escape double quotes in the string.

'The poem "{}" is written by {}.'.format(title, poet)



how can i see the example printed? if i put :

print(poem_desc) throws an error


We’ll need to see your complete code to decipher the problem. Please post it in a reply.