The <name> and <conversion> Components

Thank you Liam. I really like your lessons. You are the teacher whose pronunciation I understand best!

How to print the dictionary element with the string key in the following (stupid) example?

>>> mydict = {'1': 'one', 1: '2nd one'}
>>> "{d[1]}".format(d=mydict)
'2nd one'

@mic I’d recommend using f-strings:

>>> mydict = {'1': 'one', 1: '2nd one'}
>>> f"{mydict['1']}"
'one'
>>> f"{mydict[1]}"
'2nd one'

Thank you very much for the quick answer! This means there is a ‘gap’ regarding this in the format()- method!?

@Bartosz Hi there!

Am I right saying that the <string>.format() method and f-strings have slightly different syntax when it comes to accessing values of a dictionary?

my_dict = {'one': 1, 'two': 2, 'three' : 3}

#1: accessing values of all the 3 keys using the .format() method:

print('{0[one]}, {0[two]}, {0[three]}'.format(my_dict))
--> 1, 2, 3

#2: accessing values of the same dict keys by using an f-string:

print(f"{my_dict['one']}, {my_dict['two']}, {my_dict['three']}")
--> 1, 2, 3

If I use the conventional ‘square bracket notation’ to access a value of a key with the .format() method an exception invalid syntax is raised. However, the []-notation works perfectly fine with f-strings. Why is this so? This only adds confusion (IMO), unless there’re reasons.

What would be real-life examples of using the !a conversion specifier?

@DoubleA The main difference between "".format() and f-strings is that the latter lets you evaluate any legal Python expression placed between the curly brackets, whereas the former only parses a plain string that must conform to a mini-language syntax.

You can refer to any variables present in your current scope within an f-string:

>>> fruits = {"apples": 14, "bananas": 3, "oranges": 0}
>>> f"There are {sum(fruits.values())} fruits in the basket"
'There are 17 fruits in the basket'

Notice how a piece of Python code is embedded directly in the string literal. However, with string formatting, you’re constrained to using replacement fields:

>>> "There are {num_fruits} fruits in the basket".format(num_fruits=sum(fruits.values()))
'There are 17 fruits in the basket'

As to your second question, using the !a format specifier inside a string template will call the built-in ascii() function on the arguments passed to the .format() method:

>>> "{!a}".format("naïve café")
"'na\\xefve caf\\xe9'"

It converts the argument to a printable string representation by escaping non-ASCII characters with their byte representation. It could be useful to safely serialize data before sending it over the network or saving it to a file.

@Bartosz Thank you for the elaborate explanation. It seems now that f-strings allow to write more concise and easier-to-read code when compared to "".format() method, other things being equal.

Nice explenation Bartosz!

dict_one = {
    "name": "student",
    "class": 6,
    "roll_no": 12345,
    "value": False,
    1: True
    }

print("{[name]}".format(dict_one))
print("{0[name]}".format(dict_one))

Could anyone explain me the importance of prefixing 0 to the keyword in {} as I could get the same result WO using it.

Hi @Naresh! You can leave out the 0, which is also called manual field specification. You use these numbers to explicitly tell Python which arguments that you’re passing to .format() it should input at what place in your string.

Because you can define which one should go where with their 0-based-indicies, you can swap them around, or use them more than once:

>>> d1 = {"name": "student"}
>>> d2 = {"name": "teacher"}

>>> print("{0[name]} {1[name]} {0[name]}".format(d1, d2))
student teacher student

If you leave out the manual field specifications like you showed in your example above, that’s fine for Python. It’ll use automatic field numbering instead:

>>> d1 = {"name": "student"}
>>> d2 = {"name": "teacher"}

>>> print("{[name]} {[name]}".format(d1, d2))
student teacher

This works fine as long as you keep the arguments and the string replacements equal length and in the order that you want to substitute them.

If you want to do anything more fancy, you’ll run into errors when you use automatic field numbering:

>>> d1 = {"name": "student"}
>>> d2 = {"name": "teacher"}

>>> print("{[name]} {[name]} {[name]}".format(d1, d2))
IndexError: Replacement index 2 out of range for positional args tuple

In short, as long as you keep it simple, you can leave off the index-based numbering. If you want to do more complex string formatting using .format(), then it’s best to use the manual field specifications.

And, as Tim Peters writes in the second line of The Zen of Python:

Explicit is better than implicit.

Since it doesn’t hurt to add the explicit numbering and can make your code better readable, I’d suggest to add it in most cases.

Hi Breuss, perfect, thanks a lot for detailed explanation!. I feel encouraged to post questions on upcoming topics as I am on the way to learn.