| by Arround The Web | No comments

Python String Format_Map() Method

The string format_map() method is a built-in feature of strings in Python. This function is created to return the key’s value of a dictionary.

A dictionary is a data type that stores values in the form of indexes just like an array. But the main difference in initializing a dictionary is that it has keys to which the values are the map to it. This dictionary stores values in the form of key values. This guide will show the use of the format_map() function that is applied to the dictionaries to fetch only the values of the keys.




Z is the variable that stores the dictionary.

How Does the Format_Map Function Works?

An example is declared here to demonstrate the basic working of the map_function() of a string. A dictionary data type variable “a” is initiated with input keys x and y. Both these keys are assigned with values that are of string data type. This variable that stores both the keys and their values as a dictionary is subjected to the format_map() function as a parameter.

Print( "{x}'s last name is {y}".format_map(a))

Both the key names are added to the string using the curly brackets. This function fetches the values of both keys and embeds them in the string in place of the keys.

Now, save the code and execute it to see the results.

You can see that the keys of the dictionary are removed from the sentence and the values of those keys are embedded in the string.

Another example is added here in which we simply use the key names to get the values inside them instead of using a whole sentence used for embedding the keys.

Similar to the previous example, both keys are assigned values that are present in a single variable to create a dictionary. Then, using the format_map() function, we are able to get the dictionary values.

Print('{x} {y}'. format_map(a))


You can see that both the strings inside the keys are displayed with a space between them, as we mentioned the keys’ names with a blank space.

Example 1:

Until now, the basic working of this function is described. Now, we come to the practical examples or the approach of the format_map() function that we use in the Python programs or source codes. An input dictionary with the name “profession” is declared. This dictionary is created to store the data of some working candidates. The attributes or the key names that we use in the dictionary are the names of the person, profession, and age. Each key contains two values. Since we used two names, a single profession and their age are added for each name.

Since this example of a dictionary refers to the use of an array, we will understand this concept by using the indexes. Let us suppose that the index starts to form 0 in this instance.  Each first name, first profession, and first age number is present on 0 indexes. The same phenomenon is followed for the whole dictionary.

While using the map function, you will see that the name index and the profession index are mentioned as keys name.

Name[0], profession[0], age[0] are keys that point to the first string in all three key values. Similarly,

Name[1], profession[1], age[1] are keys that point towards the second string which is stored in all three keys.  All these keys are embedded in two separate strings.


The dictionary name is written as an argument of the format_map() function so that the function should access the keys and the values.

The result is seen upon the following execution:

Upon execution, you will see that where the keys are present in the source code, the values are replaced by them. In both sentences, either in the case of zero indexes or 1, the dictionary values which are stored in the keys are displayed accordingly to complete the statement that we used in the print keyword. In this way, the dictionaries, keys, and values are fetched through the map() Python function.

Example 2:

Besides the built-in function of Python, we use a user-defined function to see the working of the format_map() function.

A function named ckk_msg(n) is created which takes a variable as an integer type to accept the digit that is passed through it from the function call as an argument. Further, we also initiate a dictionary-type variable to store the two keys with single values each.

Then, again, the format_map() function is called along the statement having the embedded key names. The map() function takes the dictionary variable with it.

The key names that we use in the states act as simple variables, as we use in other programming languages. By using their names, the value is automatically replaced.

As a user-defined function can get executed through a function call after the format print statement, we make a function call to ensure the working and send the number of missed calls to be printed in place of the keys of the dictionary. The function call takes the same name as the declared function. And a specified number is passed as a parameter to the procedure.



Upon the execution, you will see that both values of the keys are mentioned in the statement.

Example 3:

This example is quite different from the previously-mentioned one, as we use a dictionary subclass here. A subclass is a part of the class but it is declared separately. Here, the class is declared as having a dictionary in the parameter.

Class coordinate(dict):

Inside the class, a user-defined function is declared which takes a variable “self” and a variable “key” as parameters. This function returns the key. Two parameters of the function are: one accepts the whole dictionary data and the other fetches the value of keys only.

Now, the question is from where both these values are passed?

Through the function call, we will make, but not directly, this time the function call is through the format_map() function as a parameter, while using the function inside the print statement.

print('({x}, {y})'.format_map(Coordinate(x='86', y='15')))


We used 3 print statements here. In the first 2, the value of x with 0y, and y coordinate with 0x values are mentioned. And in the third one, both coordinates values are mentioned and passed to the function so that the specified key is fetched.

Upon the execution, you will see that as the x value is allotted, so the key contains only that value and the y coordinate appears as it is. Similarly, in the second print statement, the value of y is displayed with x as it is. Whereas, the third statement contains both the key values of the coordinates.


The format_map function in Python programming language is essential to fetch the specified data among the information provided collectively in the dictionary. The dictionary takes the keys and the values are assigned to them, so the keys are not required. But the values that are stored in them need to be fetched using this function. In this tutorial, we discussed some basic and practical used examples so that each aspect of the purpose of this function could be explained.

Share Button

Source: linuxhint.com

Leave a Reply