161

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 :)

Improve this question
3
  • The title of the question is a bit misleading. This has nothing to do with the print statement, just with how string interpolation works. Commented Mar 16, 2010 at 5:47
  • 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. Commented Mar 16, 2010 at 10:20
  • 1
    @S.Lott That's really helpful /s Commented Sep 4, 2015 at 17:50

8 Answers 8

Reset to default
238 
print '<a href="%(url)s">%(url)s</a>' % {'url': my_url}
Improve this answer
Sign up to request clarification or add additional context in comments.

5 Comments

I prefer creating the dict with kwargs: '<a href="%(url)s">%(url)s</a>' % dict(url=my_url)
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...
The documentation doesn't say when this was introduced, so it's probably in all Python 2 versions.
Use format() if you can, it works better and in more places. Use % if you MUST.
@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.
106

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))
Improve this answer

6 Comments

It's nice to see the influence shift from ++ to #
The above method is not for named string formatting though, this is positional string formatting. So this does not really answer the question.
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.
The comment from @jaapz 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.
@uchuugaka 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.)
|
47

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).

Improve this answer

1 Comment

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
7

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
Improve this answer

Comments

5

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

Improve this answer

6 Comments

Django's templating engine may also prove to be the ideal tool for the emails you are making.
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.
@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.
@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
For commenting on questions, you want to use comments, not answers.
|
4

Another option is to use format_map:

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

Comments

2

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.

Improve this answer

2 Comments

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 :)
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.
1

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",
                               }
                            )
                        )
Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.