String formatting named parameters?

Question

I know it's a really simple question, but I have no idea how to google it.

how can I do

print '<a href="%s">%s</a>' % (my_url)

So that my_url is used twice? I assume I have to "name" the %s and then use a dict in the params, but I'm not sure of the proper syntax?

---

just FYI, I'm aware I can just use my_url twice in the params, but that's not the point :)

Syndesmosis

The title of the question is a bit misleading. This has nothing to do with the print statement, just with how string interpolation works. – Egger

When you have no idea how to google it, go here to use search: python.org/doc. It's better than Google for one important reason. – Danelaw

@Danelaw That's really helpful /s – Syndesmosis

Answer 1

Solution in Python 3.6+

Python 3.6 introduces literal string formatting, so that you can format the named parameters without any repeating any of your named parameters outside the string:

print(f'<a href="{my_url:s}">{my_url:s}</a>')

This will evaluate my_url, so if it's not defined you will get a NameError. In fact, instead of my_url, you can write an arbitrary Python expression, as long as it evaluates to a string (because of the :s formatting code). If you want a string representation for the result of an expression that might not be a string, replace :s by !s, just like with regular, pre-literal string formatting.

For details on literal string formatting, see PEP 498, where it was first introduced, and PEP 701, where permitted syntax was extended (starting with Python 3.12).

Engler

That PEP doesn't seem to cover all the formatters; I think they're the same as str.format which is documented here: docs.python.org/3.4/library/string.html#formatstrings – Syndesmosis

Answer 2

print '<a href="%(url)s">%(url)s</a>' % {'url': my_url}

Labiate

I prefer creating the dict with kwargs: '<a href="%(url)s">%(url)s</a>' % dict(url=my_url) – Ensconce

I wonder why you prefer that schmlamar? I would not have readily known what that meant, compared the the normal declaration of a dict that the OP uses... – Nitrite

The documentation doesn't say when this was introduced, so it's probably in all Python 2 versions. – Legator

Use format() if you can, it works better and in more places. Use % if you MUST. – Yemen

@GreenAsJade, I agree with you. However, one such use case: ready_query = query.format(**df_row.to_dict()) This would be converting a dataframe row into a dict and used to format a query. It pairs nicely with df.iterrows() in a loop. – Progression

Answer 3

In Python 2.6+ and Python 3, you might choose to use the newer string formatting method.

print('<a href="{0}">{0}</a>'.format(my_url))

which saves you from repeating the argument, or

print('<a href="{url}">{url}</a>'.format(url=my_url))

if you want named parameters.

print('<a href="{}">{}</a>'.format(my_url, my_url))

which is strictly positional, and only comes with the caveat that format() arguments follow Python rules where unnamed args must come first, followed by named arguments, followed by *args (a sequence like list or tuple) and then *kwargs (a dict keyed with strings if you know what's good for you). The interpolation points are determined first by substituting the named values at their labels, and then positional from what's left. So, you can also do this...

print('<a href="{not_my_url}">{}</a>'.format(my_url, my_url, not_my_url=her_url))

But not this...

print('<a href="{not_my_url}">{}</a>'.format(my_url, not_my_url=her_url, my_url))

Egger

It's nice to see the influence shift from ++ to # – Ashelyashen

The above method is not for named string formatting though, this is positional string formatting. So this does not really answer the question. – Tabescent

The "literal {arg1}".format(arg1="arg!") named format works with Python 3.5, whereas the terser f"literal {arg1}" is a newer innovation in Python 3.6 or newer, AFAIK. – Alectryomancy

The comment from @Tabescent is no longer valid considering the changes to this answer that include the non-positional syntax print('<a href="{url}">{url}</a>'.format(url=my_url)). This works great both with Python 2 and 3. – Ernestinaernestine

@Yemen The examples you added, even the "you can do this" one, has two placeholders but three arguments. You need to drop the second my_url. (Although it seems like it does still work - it's just silently ignored by Python, which is a surprise to me.) – Everara

It’s not ignored exactly. Reread my explanation. – Yemen

Answer 4

You will be addicted to syntax.

Also C# 6.0, EcmaScript developers has also familier this syntax.

In [1]: print '{firstname} {lastname}'.format(firstname='Mehmet', lastname='Ağa')
Mehmet Ağa

In [2]: print '{firstname} {lastname}'.format(**dict(firstname='Mehmet', lastname='Ağa'))
Mehmet Ağa

Goggler

Answer 5

For building HTML pages, you want to use a templating engine, not simple string interpolation.

Hindman

I'm using Django, but this is going into an email. – Syndesmosis

Django's templating engine may also prove to be the ideal tool for the emails you are making. – Hindman

What's stopping you from using a Django template to generate an email body with its render() method? Nothing says you have to feed template output to HttpResponse(). Django is embarrassingly versatile. – Bambibambie

@Mike: I thought Django might have a solution for this too, but I hadn't found it yet :p I probably will move my emails into templates then! Thanks. Maybe I'm 'tarded, but I've found it to be pretty rigid in some areas. – Syndesmosis

@random people that read these comments: found more detail on how to do that here rossp.org/blog/2006/jul/11/sending-e-mails-templates – Syndesmosis

For commenting on questions, you want to use comments, not answers. – Atal

Answer 6

Another option is to use format_map:

print('<a href="{s}">{s}</a>'.format_map({'s': 'my_url'}))

Testate

Answer 7

As well as the dictionary way, it may be useful to know the following format:

print '<a href="%s">%s</a>' % (my_url, my_url)

Here it's a tad redundant, and the dictionary way is certainly less error prone when modifying the code, but it's still possible to use tuples for multiple insertions. The first %s is substituted for the first element in the tuple, the second %s is substituted for the second element in the tuple, and so on for each element in the tuple.

Mallon

I just told a guy off for suggesting this :) He deleting his post. I feel kind of bad now. Yes, I'm aware I can do this, but it just wasn't what I was looking for. As you said, it's redundant, and my_url is actually a function call that I don't want to have to be evaluated twice. Twice isn't so bad, but it could just have easily been 20 times :) – Syndesmosis

I figured I'd keep mine, just in case it helps somebody else. Well the dictionary way is likely the best way to go. But for redundancy, (get_my_url(), )*20 only calls the function once, and duplicates it 20 times. – Mallon

Answer 8

I recommend this syntax

dictionary_of_string_values = {
                               "my_text" : "go to w3schools",
                               "my_url" : "https://www.w3schools.com",
                               }

print ('<a href="{my_url}">{my_text}</a>'.format(**dictionary_of_string_values))

It is very useful when you have to format a string with lots of placeholders.

You can also make it shorter like this:

print ('<a href="{my_url}">{my_text}</a>'.format(
                             **{
                               "my_text" : "go to w3schools",
                               "my_url" : "https://www.w3schools.com",
                               }
                            )
                        )

Rooney