In the last few lessons, we have learned about some Python constructs like lists and tuples. Today, we will have a word about Python dictionaries, which is another type of data structure in Python.<\/p>\n
Moreover, we will study how to create, access, delete, and reassign a dictionary in Python. Along with this, we will learn Python dictionary methods and operations.<\/p>\n
So, let’s start the Python Dictionary Tutorial.<\/p>\n
A real-life dictionary holds words and their meanings. As you can imagine, likewise, a Python dictionary holds key-value pairs.<\/p>\n
Let\u2019s look at how to create one.<\/p>\n
Creating a Dictionary is as easy as pie. Separate keys from values with a colon(:), and pairs from another by a comma(,). Finally, put it all in curly braces.<\/p>\n
>>> {'PB&J':'Peanut Butter and Jelly','PJ':'Pajamas'}<\/pre>\nOutput<\/strong><\/p>\n{‘PB&J’: ‘Peanut Butter and Jelly’, ‘PJ’: ‘Pajamas’}<\/div>\nOptionally, you can put the dictionary in a variable. If you want to use it later in the program, you must do this.<\/p>\n
>>> lingo={'PB&J':'Peanut Butter and Jelly','PJ':'Pajamas'}<\/pre>\nTo create an empty dictionary, simply use curly braces and then assign it to a variable<\/p>\n
>>> dict2={}\r\n>>> dict2<\/pre>\nOutput<\/strong><\/p>\n{}<\/div>\n>>> type(dict2)<\/pre>\nOutput<\/strong><\/p>\n<class ‘dict’><\/div>\n1. Python Dictionary Comprehension<\/h4>\n
You can also create a Python dict using comprehension. This is the same thing that you\u2019ve learned in your math class.<\/p>\n
To do this, follow an expression pair with a for-statement loop in python. Finally, put it all in curly braces.<\/p>\n
>>> mydict={x*x:x for x in range(8)}\r\n>>> mydict<\/pre>\nOutput<\/strong><\/p>\n{0: 0, 1: 1, 4: 2, 9: 3, 16: 4, 25: 5, 36: 6, 49: 7}<\/div>\nIn the above code, we created a Python dictionary to hold squares of numbers from 0 to 7 as keys, and numbers 0-1 as values.<\/p>\n
2. Dictionaries with mixed keys<\/h4>\n
It isn\u2019t necessary to use the same kind of keys (or values) for a dictionary in Python.<\/p>\n
>>> dict3={1:'carrots','two':[1,2,3]}\r\n>>> dict3<\/pre>\nOutput<\/strong><\/p>\n{1: ‘carrots’, ‘two’: [1, 2, 3]}<\/div>\nAs you can see here, a key or a value can be anything from an integer to a list.<\/p>\n
3. dict() function in Python<\/h4>\n
Using the dict() function, you can convert a compatible combination of constructs into a Python dictionary.<\/p>\n
>>> dict(([1,2],[2,4],[3,6]))<\/pre>\nOutput<\/strong><\/p>\n{1: 2, 2: 4, 3: 6}<\/div>\nHowever, this function takes only one argument. So if you pass it three lists, you must pass them inside a list or a tuple. Otherwise, it throws an error.<\/p>\n
>>> dict([1,2],[2,4],[3,6])<\/pre>\nOutput<\/strong><\/p>\n\nTraceback (most recent call last):File “<pyshell#121>”, line 1, in <module><\/p>\n
dict([1,2],[2,4],[3,6])<\/p>\n
TypeError: dict expected at most 1 arguments, got 3<\/p>\n<\/div>\n
4. Declaring one key more than once in the dictionary<\/h4>\n
Now, let\u2019s try declaring one key more than once and see what happens.<\/p>\n
>>> mydict2={1:2,1:3,1:4,2:4}\r\n>>> mydict2<\/pre>\nOutput<\/strong><\/p>\n{1: 4, 2: 4}<\/div>\nAs you can see, 1:2 was replaced by 1:3, which was then replaced by 1:4. This shows us that a dictionary cannot contain the same key twice.<\/p>\n
5. Declaring an empty dictionary and adding elements later<\/h4>\n
When you don\u2019t know what key-value pairs go in your Python dictionary,\u00a0 you can just create an empty Python dict, and add pairs later.<\/p>\n
>>> animals={}\r\n>>> type(animals)<\/pre>\nOutput<\/strong><\/p>\n<class ‘dict’><\/div>\n>>> animals[1]='dog'\r\n>>> animals[2]='cat'\r\n>>> animals[3]='ferret'\r\n>>> animals<\/pre>\nOutput<\/strong><\/p>\n{1: ‘dog’, 2: ‘cat’, 3: ‘ferret’}<\/div>\nAny query on Python Dictionary yet? Leave a comment.<\/p>\n
How to Access a Python Dictionary?<\/h3>\n1. Accessing the entire Python dictionary<\/h4>\n
To get the entire dictionary at once, type its name in the shell.<\/p>\n
>>> dict3<\/pre>\nOutput<\/strong><\/p>\n{1: ‘carrots’, ‘two’: [1, 2, 3]}<\/div>\n2. Accessing a value in the dictionary<\/h4>\n
To access an item from a list or a tuple, we use its index in square brackets. This is the python syntax to be followed. However, a Python dictionary is unordered. So to get a value from it, you need to put its key in square brackets.<\/p>\n
To get the square root of 36 from the above dictionary, we write the following code.<\/p>\n
>>> mydict[36]<\/pre>\nOutput<\/strong><\/p>\n6<\/div>\n3. get() function in python<\/h4>\n
The Python dictionary get() function takes a key as an argument and returns the corresponding value.<\/p>\n
>>> mydict.get(49)<\/pre>\nOutput<\/strong><\/p>\n7<\/div>\n4. When the Python dictionary key doesn\u2019t exist<\/h4>\n
If the key you\u2019re searching for doesn\u2019t exist, let\u2019s see what happens.<\/p>\n
>>> mydict[48]<\/pre>\nOutput<\/strong><\/p>\n\nTraceback (most recent call last):File “<pyshell#125>”, line 1, in <module><\/p>\n
mydict[48]<\/p>\n
KeyError: 48<\/p>\n<\/div>\n
Using the key in square brackets gives us a KeyError. Now let\u2019s see what the get() method returns in such a situation.<\/p>\n
>>> mydict.get(48)\r\n>>><\/pre>\nAs you can see, this didn\u2019t print anything. Let\u2019s put it in the print statement to find out what\u2019s going on.<\/p>\n
>>> print(mydict.get(48))<\/pre>\nOutput<\/strong><\/p>\nNone<\/div>\nSo we see, when the key doesn\u2019t exist, the get() function returns the value None. We discussed it earlier, and know that it indicates an absence of value.<\/p>\n
Reassigning a Python Dictionary<\/h3>\n
The Python dictionary is mutable. This means that we can change it or add new items without having to reassign all of it.<\/p>\n
1. Updating the Value of an Existing Key<\/h4>\n
If the key already exists in the Python dictionary, you can reassign its value using square brackets.<\/p>\n
Let\u2019s take a new Python dictionary for this.<\/p>\n
>>> dict4={1:1,2:2,3:3}<\/pre>\nNow, let\u2019s try updating the value for key 2.<\/p>\n
>>> dict4[2]=4\r\n>>> dict4<\/pre>\nOutput<\/strong><\/p>\n{1: 1, 2: 4, 3: 3}<\/div>\n2. Adding a new key to the dictionary<\/h4>\n
However, if the key doesn\u2019t already exist in the dictionary, then it adds a new one.<\/p>\n
>>> dict4[4]=6\r\n>>> dict4<\/pre>\nOutput<\/strong><\/p>\n{1: 1, 2: 4, 3: 3, 4: 6}<\/div>\nPython dictionary cannot be sliced.<\/p>\n
How to Delete a Python Dictionary?<\/h3>\n
You can delete an entire dictionary. Also, unlike a tuple, a Python dictionary is mutable. So you can also delete a part of it.<\/p>\n
1. Deleting an entire Python dictionary<\/h4>\n
To delete the whole Python dict, simply use its name after the keyword \u2018del\u2019.<\/p>\n
>>> del dict4\r\n>>> dict4<\/pre>\nOutput<\/strong><\/p>\n\nTraceback (most recent call last):File “<pyshell#138>”, line 1, in <module><\/p>\n
dict4<\/p>\n
NameError: name ‘dict4’ is not defined<\/p>\n<\/div>\n
2. Deleting a single key-value pair in a dictionary<\/h4>\n
To delete just one key-value pair, use the keyword \u2018del\u2019 with the key of the pair to delete.<\/p>\n
Now, let\u2019s first reassign dict4 for this example.<\/p>\n
>>> dict4={1:1,2:2,3:3,4:4}<\/pre>\nNow, let\u2019s delete the pair 2:2<\/p>\n
>>> del dict4[2]\r\n>>> dict4<\/pre>\nOutput<\/strong><\/p>\n{1: 1, 3: 3, 4: 4}<\/div>\nA few other methods allow us to delete an item from a dictionary in Python. We will see those in section 8.<\/p>\n
Built-in Functions on a Python Dictionary<\/h3>\n
A function is a procedure that can be applied to a construct to get a value. Furthermore, it doesn\u2019t modify the construct. Python gives us a few functions that we can apply to a Python dictionary. Take a look.<\/p>\n
1. len() function in dictionary<\/h4>\n
The len() function returns the length of the dictionary in Python. Every key-value pair adds 1 to the length.<\/p>\n
>>> len(dict4)<\/pre>\nOutput<\/strong><\/p>\n3<\/div>\nAn empty Python dictionary has a length of 0.<\/p>\n
>>> len({})<\/pre>\n2. any() function in dictionary<\/h4>\n
Like it is with lists an tuples, the any() function returns True if even one key in a dictionary has a Boolean value of True.<\/p>\n
>>> any({False:False,'':''})<\/pre>\nOutput<\/strong><\/p>\nFalse<\/div>\n>>> any({True:False,\"\":\"\"})<\/pre>\nOutput<\/strong><\/p>\nTrue<\/div>\n>>> any({'1':'','':''})<\/pre>\nOutput<\/strong><\/p>\nTrue<\/div>\n3. all() function in dictionary<\/h4>\n
Unlike the any() function, all() returns True only if all the keys in the dictionary have a Boolean value of True.<\/p>\n
>>> all({1:2,2:'',\"\":3})<\/pre>\nOutput<\/strong><\/p>\nFalse<\/div>\n4. sorted() function in dictionary<\/h4>\n
Like it is with lists and tuples, the sorted() function returns a sorted sequence of the keys in the dictionary. The sorting is in ascending order, and doesn\u2019t modify the original Python dictionary.<\/p>\n
But to see its effect, let\u2019s first modify dict4.<\/p>\n
>>> dict4={3:3,1:1,4:4}<\/pre>\nNow, let\u2019s apply the sorted() function on it.<\/p>\n
>>> sorted(dict4)<\/pre>\nOutput<\/strong><\/p>\n[1, 3, 4]<\/div>\nNow, let\u2019s try printing the dictionary dict4 again.<\/p>\n
>>> dict4<\/pre>\nOutput<\/strong><\/p>\n{3: 3, 1: 1, 4: 4}<\/div>\nAs you can see, the original Python dictionary wasn\u2019t modified.<\/p>\n
This function returns the keys in a sorted list. To prove this, let\u2019s see what the type() function returns.<\/p>\n
>>> type(sorted(dict4))<\/pre>\nOutput<\/strong><\/p>\n<class ‘list’><\/div>\nThis proves that sorted() returns a list.<\/p>\n
Built-in Methods on a Python Dictionary<\/h3>\n
A method is a set of instructions to execute on a construct, and it may modify the construct. To do this, a method must be called on the construct. Now, let\u2019s look at the available methods for dictionaries.<\/p>\n
Let\u2019s use dict4 for this example.<\/p>\n
>>> dict4<\/pre>\nOutput<\/strong><\/p>\n{3: 3, 1: 1, 4: 4}<\/div>\n1. keys() in dictionary<\/h4>\n
The keys() method returns a list of keys in a Python dictionary.<\/p>\n
>>> dict4.keys()<\/pre>\nOutput<\/strong><\/p>\ndict_keys([3, 1, 4])<\/div>\n2. values() in dictionary<\/h4>\n
Likewise, the values() method returns a list of values in the dictionary.<\/p>\n
>>> dict4.values()<\/pre>\nOutput<\/strong><\/p>\n\ndict_values([3, 1, 4])<\/p>\n<\/div>\n
3. items() in dictionary<\/h4>\n
This method returns a list of key-value pairs.<\/p>\n
>>> dict4.items()<\/pre>\nOutput<\/strong><\/p>\ndict_items([(3, 3), (1, 1), (4, 4)])<\/div>\n4. get() in dictionary<\/h4>\n
We first saw this function in section 4c. Now, let\u2019s dig a bit deeper.<\/p>\n
It takes one to two arguments. While the first is the key to search for, the second is the value to return if the key isn\u2019t found.<\/p>\n
The default value for this second argument is None.<\/p>\n
>>> dict4.get(3,0)<\/pre>\nOutput<\/strong><\/p>\n3<\/div>\n>>> dict4.get(5,0)<\/pre>\nSince the key 5 wasn\u2019t in the dictionary, it returned 0, like we specified.<\/p>\n
Any doubt yet in Python Dictionary? Leave a comment.<\/p>\n
5. clear() in dictionary<\/h4>\n
The clear function\u2019s purpose is obvious. It empties the\u00a0Python dictionary.<\/p>\n
>>> dict4.clear()\r\n>>> dict4<\/pre>\nOutput<\/strong><\/p>\n{}<\/div>\nLet\u2019s reassign it though for further examples.<\/p>\n
>>> dict4={3:3,1:1,4:4}<\/pre>\n6. copy() in dictionary<\/h4>\n
First, let\u2019s see what shallow and deep copies are. A shallow copy only copies contents, and the new construct points to the same memory location.<\/p>\n
But a deep copy copies contents, and the new construct points to a different location. The copy() method creates a shallow copy of the\u00a0Python\u00a0dictionary.<\/p>\n
>>> newdict=dict4.copy()\r\n>>> newdict<\/pre>\nOutput<\/strong><\/p>\n{3: 3, 1: 1, 4: 4}<\/div>\n7. pop() in dictionary<\/h4>\n
This method is used to remove and display an item from the dictionary. It takes one to two arguments. The first is the key to be deleted, while the second is the value that\u2019s returned if the key isn\u2019t found.<\/p>\n
>>> newdict.pop(4)<\/pre>\nOutput<\/strong><\/p>\n4<\/div>\nNow, let\u2019s try deleting the pair 4:4.<\/p>\n
>>> newdict.pop(5,-1)<\/pre>\nOutput<\/strong><\/p>\n-1<\/div>\nHowever, unlike the get() method, this has no default None value for the second parameter.<\/p>\n
>>> newdict.pop(5)<\/pre>\nOutput<\/strong><\/p>\n\nTraceback (most recent call last):File “<pyshell#191>”, line 1, in <module><\/p>\n
newdict.pop(5)<\/p>\n
KeyError: 5<\/p>\n<\/div>\n
As you can see, it raised a KeyError when it couldn\u2019t find the key.<\/p>\n
8. popitem() in dictionary<\/h4>\n
Let\u2019s first reassign the\u00a0Python dictionary newdict.<\/p>\n
>>> newdict={3:3,1:1,4:4,7:7,9:9}<\/pre>\nNow, we\u2019ll try calling popitem() on this.<\/p>\n
>>> newdict.popitem()<\/pre>\nOutput<\/strong><\/p>\n(9, 9)<\/div>\nIt popped the pair 9:9.<\/p>\n
Let\u2019s restart the shell and reassign the dictionary again and see which pair is popped.<\/p>\n
=============================== RESTART: Shell ===============================\r\n>>> newdict={3:3,1:1,4:4,7:7,9:9}\r\n>>> newdict.popitem()<\/pre>\nOutput<\/strong><\/p>\n(9, 9)<\/div>\nAs you can see, the same pair was popped. We can interpret from this that the internal logic of the popitem() method is such that for a particular dictionary, it always pops pairs in the same order.<\/p>\n
9. fromkeys() in dictionary<\/h4>\n
This method creates a new\u00a0Python dictionary from an existing one. To take an example, we try to create a new dictionary from newdict.<\/p>\n
While the first argument takes a set of keys from the dictionary, the second takes a value to assign to all those keys. But the second argument is optional.<\/p>\n
>>> newdict.fromkeys({1,2,3,4,7},0)<\/pre>\nOutput<\/strong><\/p>\n{1: 0, 2: 0, 3: 0, 4: 0, 7: 0}<\/div>\nHowever, the keys don\u2019t have to be in a set.<\/p>\n
>>> newdict.fromkeys((1,2,3,4,7),0)<\/pre>\nOutput<\/strong><\/p>\n{1: 0, 2: 0, 3: 0, 4: 0, 7: 0}<\/div>\nLike we\u2019ve seen so far, the default value for the second argument is None.<\/p>\n
>>> newdict.fromkeys({'1','2','3','4','7'})<\/pre>\nOutput<\/strong><\/p>\n{‘4’: None, ‘7’: None, ‘3’: None, ‘1’: None, ‘2’: None}<\/div>\n10. update() in dictionary<\/h4>\n
The update() method takes another dictionary as an argument. Then it updates the dictionary to hold values from the other dictionary that it doesn\u2019t already.<\/p>\n
>>> dict1={1:1,2:2}\r\n>>> dict2={2:2,3:3}\r\n>>> dict1.update(dict2)\r\n>>> dict1<\/pre>\nOutput<\/strong><\/p>\n{1: 1, 2: 2, 3: 3}<\/div>\nPython Dictionary Operations<\/h3>\n
We learned about different classes of operators in Python earlier. Let\u2019s now see the applications.<\/p>\n
1. Membership operation<\/h4>\n
We can apply the \u2018in\u2019 and \u2018not in\u2019 operators on a\u00a0Python dictionary to check whether it contains a certain key.<\/p>\n
For this example, we\u2019ll work on dict1.<\/p>\n
>>> dict1<\/pre>\nOutput<\/strong><\/p>\n{1: 1, 2: 2, 3: 3}<\/div>\n>>> 2 in dict1<\/pre>\nOutput<\/strong><\/p>\nTrue<\/div>\n>>> 4 in dict1<\/pre>\nOutput<\/strong><\/p>\nFalse<\/div>\n2 is a key in dict1, but 4 isn\u2019t. Hence, it returns True and False for them, correspondingly.<\/p>\n
Python Iterate Dictionary<\/h3>\n
When in a for loop, you can also iterate on a Python dictionary like on a list, tuple, or set.<\/p>\n
>>> dict4<\/pre>\nOutput<\/strong><\/p>\n{1: 1, 3: 3, 4: 4}<\/div>\n>>> for i in dict4:\r\n\tprint(dict4[i]*2)<\/pre>\nOutput<\/strong><\/p>\n2
\n6
\n8<\/div>\nThe above code, for every key in the\u00a0Python dictionary, multiplies its value by 2, and then prints it.<\/p>\n
Nested Dictionary<\/h3>\n
Finally, let’s look at nested dictionaries. You can also place a Python dictionary as a value within a dictionary.<\/p>\n
>>> dict1={4:{1:2,2:4},8:16}\r\n>>> dict1<\/pre>\nOutput<\/strong><\/p>\n{4: {1: 2, 2: 4}, 8: 16}<\/div>\nTo get the value for the key 4, write the following code.<\/p>\n
>>> dict1[4]<\/pre>\nOutput<\/strong><\/p>\n{1: 2, 2: 4}<\/div>\nHowever, you can\u2019t place it as a key, because that throws an error.<\/p>\n
>>> dict1={{1:2,2:4}:8,8:16}<\/pre>\nOutput<\/strong><\/p>\n\nTraceback (most recent call last):File “<pyshell#227>”, line 1, in <module><\/p>\n
dict1={{1:2,2:4}:8,8:16}<\/p>\n
TypeError: unhashable type: ‘dict’<\/p>\n<\/div>\n
Python Interview Questions on Dictionaries<\/h3>\n
1. What are Python dictionaries?<\/p>\n
2. How do you call a dictionary in Python?<\/p>\n
3. Explain how dictionaries work in Python?<\/p>\n
4. How do you read a dictionary in Python?<\/p>\n
5. How do you create an empty dictionary?<\/p>\n
Conclusion<\/h3>\n
A Python dictionary works like a phone book, where each unique key points to a single value. Keys can be strings, numbers, or any immutable object, while values may be of any type at all. Under the hood, a fast hashing table lets you fetch or update a value in nearly constant time, no matter how big the dict grows, making it the go-to choice for lookup tasks such as counting words, storing config settings, or caching web requests.<\/p>\n
Whenever you are handling a huge amount of data, dictionaries are an important tool that is used to keep everything organised.<\/p>\n
In short, a Python dictionary is a powerful tool that is used to make the code simple, making it faster and more flexible.<\/p>\n","protected":false},"excerpt":{"rendered":"
In the last few lessons, we have learned about some Python constructs like lists and tuples. Today, we will have a word about Python dictionaries, which is another type of data structure in Python....<\/p>\n","protected":false},"author":5,"featured_media":35784,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[46],"tags":[3810,3811,10496,10497],"class_list":["post-5646","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-python","tag-dictionaries-in-python","tag-dictionary-in-python","tag-python-dictionaries","tag-python-dictionary"],"yoast_head":"\n
Python Dictionary with Methods, Functions and Dictionary Operations - DataFlair<\/title>\n<meta name=\"description\" content=\"Learn How to Create Dictionary in Python, access, reassign and delete python dictionaries. Learn built-in functions, methods & operations\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/data-flair.training\/blogs\/python-dictionary\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Python Dictionary with Methods, Functions and Dictionary Operations - DataFlair\" \/>\n<meta property=\"og:description\" content=\"Learn How to Create Dictionary in Python, access, reassign and delete python dictionaries. Learn built-in functions, methods & operations\" \/>\n<meta property=\"og:url\" content=\"https:\/\/data-flair.training\/blogs\/python-dictionary\/\" \/>\n<meta property=\"og:site_name\" content=\"DataFlair\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/DataFlairWS\/\" \/>\n<meta property=\"article:published_time\" content=\"2018-01-03T06:03:30+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2026-04-21T08:46:58+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/01\/Python-Dictionaries-1.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"1200\" \/>\n\t<meta property=\"og:image:height\" content=\"628\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"DataFlair Team\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@DataFlairWS\" \/>\n<meta name=\"twitter:site\" content=\"@DataFlairWS\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"DataFlair Team\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"10 minutes\" \/>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Python Dictionary with Methods, Functions and Dictionary Operations - DataFlair","description":"Learn How to Create Dictionary in Python, access, reassign and delete python dictionaries. Learn built-in functions, methods & operations","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/data-flair.training\/blogs\/python-dictionary\/","og_locale":"en_US","og_type":"article","og_title":"Python Dictionary with Methods, Functions and Dictionary Operations - DataFlair","og_description":"Learn How to Create Dictionary in Python, access, reassign and delete python dictionaries. Learn built-in functions, methods & operations","og_url":"https:\/\/data-flair.training\/blogs\/python-dictionary\/","og_site_name":"DataFlair","article_publisher":"https:\/\/www.facebook.com\/DataFlairWS\/","article_published_time":"2018-01-03T06:03:30+00:00","article_modified_time":"2026-04-21T08:46:58+00:00","og_image":[{"width":1200,"height":628,"url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/01\/Python-Dictionaries-1.jpg","type":"image\/jpeg"}],"author":"DataFlair Team","twitter_card":"summary_large_image","twitter_creator":"@DataFlairWS","twitter_site":"@DataFlairWS","twitter_misc":{"Written by":"DataFlair Team","Est. reading time":"10 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/data-flair.training\/blogs\/python-dictionary\/#article","isPartOf":{"@id":"https:\/\/data-flair.training\/blogs\/python-dictionary\/"},"author":{"name":"DataFlair Team","@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/person\/7f83c342f5d1632d6f7b4b0b0f447823"},"headline":"Python Dictionary with Methods, Functions and Dictionary Operations","datePublished":"2018-01-03T06:03:30+00:00","dateModified":"2026-04-21T08:46:58+00:00","mainEntityOfPage":{"@id":"https:\/\/data-flair.training\/blogs\/python-dictionary\/"},"wordCount":2110,"commentCount":3,"publisher":{"@id":"https:\/\/data-flair.training\/blogs\/#organization"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/python-dictionary\/#primaryimage"},"thumbnailUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/01\/Python-Dictionaries-1.jpg","keywords":["dictionaries in python","dictionary in python","python dictionaries","python dictionary"],"articleSection":["Python Tutorials"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/data-flair.training\/blogs\/python-dictionary\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/data-flair.training\/blogs\/python-dictionary\/","url":"https:\/\/data-flair.training\/blogs\/python-dictionary\/","name":"Python Dictionary with Methods, Functions and Dictionary Operations - DataFlair","isPartOf":{"@id":"https:\/\/data-flair.training\/blogs\/#website"},"primaryImageOfPage":{"@id":"https:\/\/data-flair.training\/blogs\/python-dictionary\/#primaryimage"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/python-dictionary\/#primaryimage"},"thumbnailUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/01\/Python-Dictionaries-1.jpg","datePublished":"2018-01-03T06:03:30+00:00","dateModified":"2026-04-21T08:46:58+00:00","description":"Learn How to Create Dictionary in Python, access, reassign and delete python dictionaries. Learn built-in functions, methods & operations","breadcrumb":{"@id":"https:\/\/data-flair.training\/blogs\/python-dictionary\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/data-flair.training\/blogs\/python-dictionary\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/data-flair.training\/blogs\/python-dictionary\/#primaryimage","url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/01\/Python-Dictionaries-1.jpg","contentUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/01\/Python-Dictionaries-1.jpg","width":1200,"height":628,"caption":"Python Dictionary"},{"@type":"BreadcrumbList","@id":"https:\/\/data-flair.training\/blogs\/python-dictionary\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Blog Home","item":"https:\/\/data-flair.training\/blogs\/"},{"@type":"ListItem","position":2,"name":"Python Tutorials","item":"https:\/\/data-flair.training\/blogs\/category\/python\/"},{"@type":"ListItem","position":3,"name":"Python Dictionary with Methods, Functions and Dictionary Operations"}]},{"@type":"WebSite","@id":"https:\/\/data-flair.training\/blogs\/#website","url":"https:\/\/data-flair.training\/blogs\/","name":"DataFlair","description":"Learn Today. Lead Tomorrow.","publisher":{"@id":"https:\/\/data-flair.training\/blogs\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/data-flair.training\/blogs\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/data-flair.training\/blogs\/#organization","name":"DataFlair","url":"https:\/\/data-flair.training\/blogs\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/logo\/image\/","url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2016\/07\/Data-Flair.png","contentUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2016\/07\/Data-Flair.png","width":106,"height":48,"caption":"DataFlair"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/DataFlairWS\/","https:\/\/x.com\/DataFlairWS","https:\/\/www.linkedin.com\/company\/dataflair-web-services-pvt-ltd\/","https:\/\/www.youtube.com\/user\/DataFlairWS"]},{"@type":"Person","@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/person\/7f83c342f5d1632d6f7b4b0b0f447823","name":"DataFlair Team","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/secure.gravatar.com\/avatar\/4cf3a74600d131330b8c481d519afd1574093ed89f6d3396a95393ad223eb7cd?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/4cf3a74600d131330b8c481d519afd1574093ed89f6d3396a95393ad223eb7cd?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/4cf3a74600d131330b8c481d519afd1574093ed89f6d3396a95393ad223eb7cd?s=96&d=mm&r=g","caption":"DataFlair Team"},"description":"DataFlair Team creates expert-level guides on programming, Java, Python, C++, DSA, AI, ML, data Science, Android, Flutter, MERN, Web Development, and technology. Our goal is to empower learners with easy-to-understand content. Explore our resources for career growth and practical learning.","url":"https:\/\/data-flair.training\/blogs\/author\/dfteam1\/"}]}},"amp_enabled":true,"_links":{"self":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts\/5646","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/users\/5"}],"replies":[{"embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/comments?post=5646"}],"version-history":[{"count":22,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts\/5646\/revisions"}],"predecessor-version":[{"id":147742,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts\/5646\/revisions\/147742"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/media\/35784"}],"wp:attachment":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/media?parent=5646"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/categories?post=5646"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/tags?post=5646"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}