Dictionaries in Python are data structures that optimize element lookups by associating keys to values. You could say that dictionaries are arrays of (key, value) pairs.<\/p>\n
Their syntax is pretty familiar to us, web developers, since its exactly the same as JSON’s. An object starts and ends in curly braces, each pair is separated by a comma, and the (key, value) pairs are associated through a colon (:). Let’s see:<\/p>\n
base_example.py<\/em><\/span><\/p>\n Here, we are defining a dictionary which contains an array of animals, a number, a name, a boolean and another dictionary inside. This data structure is pretty versatile, as you can see. By the way, to define an empty dictionary you just write Now, let’s see how to retrieve a value from this dictionary. There are two ways of doing this: The known “[]” syntax where we write What’s the difference? Well, the []<\/em> syntax results in a KeyError if the key is not defined, and we usually don’t want that. The get<\/em> method receives the key and an optional default value, and it does not result in any annoying error if the key is not found, it just returns None.<\/p>\n Let’s check out the []<\/em> syntax a little bit:<\/p>\n base_example.py<\/em><\/span><\/p>\n In every print statement you will find a comment predicting the result, anyway, let’s see the actual output:<\/p>\n There it is, the key “this_one_does_not_exist”<\/em> does not exist, so a KeyError<\/em> is raised. Let’s put that KeyError in an except clause, and check the get<\/em> method.<\/p>\n base_example.py<\/em><\/span><\/p>\n Here, we put the missing key in a try\/except, which prints “KeyError”<\/em> on failure. Then we see the get<\/em> method examples, we ask for a key and return a default message if it’s not found. The output:<\/p>\n It’s pretty much the same behavior, but anything that doesn’t include a try\/except is nicer.<\/p>\n Dictionaries are mutable data structures. We can add keys to it, update their values and even delete them. Let’s see one by one in our example:<\/p>\n base_example.py<\/em><\/span><\/p>\n There is a method called We are creating the key this_one_does_not_exist<\/em> first, and printing it out. Then we are updating a_boolean<\/em> and also printing it. At last, we delete this_one_does_not_exist<\/em> from the dict and print it again. The result:<\/p>\n It works as expected. Notice that, in the context of writing a key, the []<\/em> syntax doesn’t throw an error if the key was not found, so in this case you can use it without worrying.<\/p>\n Python provides some useful operations to work with dictionaries, let’s see some of them:<\/p>\n The in<\/em> keyword is a tool Python provides to, in this case, check whether a key is present in a dictionary or not. Let’s make our own implementation of the get<\/em> method to test this keyword:<\/p>\n dict_get.py<\/em><\/span><\/p>\n Withing our custom get<\/em> method, we use the []<\/em> syntax to retrieve the requested key from the given dictionary, but not without checking if the key is present there with the in<\/em> keyword. We receive a default value which by default is None<\/em>. It behaves exactly like the native get<\/em> method, here is the output:<\/p>\n This tool can also be used to iterate over the dictionary keys, let’s implement a method which returns an array with all the keys in a dictionary to see it working:<\/p>\n dict_all_keys.py<\/em><\/span><\/p>\n It’s pretty simple, right? In human language, that iterates for every key in<\/em> the given dictionary and returns an array with them. The output:<\/p>\n The Its use is pretty simple, it receives the dictionary in question as argument, and just for testing purposes we’ll modify the dict_all_keys.py<\/em> to check that the number of keys its returning is the same as the len of the dict.<\/p>\n dict_all_keys.py<\/em><\/span><\/p>\n There is the check, if we uncomment the second line of the function’s body we’ll see the exception raised:<\/p>\n The message Exception: expected 2 keys. got 3<\/strong><\/em> is telling us that the keys we are about to return contain an extra key. This is another useless but explicit example.<\/p>\n Let’s see a couple functions that render obsolete the function keys<\/em> we just wrote. These are Having a dictionary like Let’s see an example:<\/p>\n dict_keys_values.py<\/em><\/span><\/p>\n Here we are creating a dictionary containing some keys, and then iterating over the keys and values to print them out. I know it’s not the prettiest code but it proves my point. When we execute it one time we see:<\/p>\n Then a second time:<\/p>\n See? That’s because dictionaries’ keys are not sorted, to solve this issue (and fix that awful piece of code) let’s change that script a little bit. We won’t be using the function dict_keys_values.py<\/em><\/span><\/p>\n Now we’ll always see the same output, as the keys are being sorted alphabetically. The output:<\/p>\n Now, why am I giving so much importance to the lack of sorting of dictionaries? Well, imagine you are storing it in a CSV file. Every time you write a dictionary, as the keys are in arbitrary orders, the CSV’s rows won’t be consistent, and it will mess up your program by writing each row with the columns in different orders. So when you need your data in a strict order, please keep in mind this little fact.<\/p>\n This method returns a list of tuples containing every key-value pair in the dictionary as dict_items.py<\/em><\/span><\/p>\n This will output the same as the first dict_keys_values.py<\/em>, “key: value”<\/em> with different orders in each execution. Something to notice is the fact that we can not assign new values to tuples. We access values in tuples by This method changes one dictionary to have new values from a second one. It modifies existing values, as dictionaries are mutable (keep this in mind). Let’s see an example:<\/p>\n dict_update.py<\/em><\/span><\/p>\n Here we are printing the product, executing Notice that we don’t return a new dictionary with the updated values, it updates the existing one. This is an easy way of updating a couple keys in a dictionary without having to overwrite them one by one.<\/p>\n A dictionary’s copy method will copy the entire dictionary into a new one. One thing to notice is that it’s a shallow copy. If you have nested dictionaries, it will copy the first level, but the inner dictionaries will be a reference to the same object. Let’s see an example:<\/p>\n dict_copy.py<\/em><\/span><\/p>\n In this script, we are creating a dictionary with some data and then copying it. We change the clone’s age and print both, and then do the same with the first names.<\/p>\n Now, my clone is a copy of me, it is not a reference to the same memory address, so if I change its age, mine will remain the same. But, the inner dictionary, the one containing the name, is a reference to the same memory address, when I change my clone’s name, mine will change too. Let’s see the output:<\/p>\n So, having this in mind, we can use the This was an basic example on Python Dictionaries.<\/p>\n\r\nEXAMPLE_DICT = {\r\n \"animals\": [\"dog\", \"cat\", \"fish\"],\r\n \"a_number\": 1,\r\n \"a_name\": \"Sebasti\u00e1n\",\r\n \"a_boolean\": True,\r\n \"another_dict\": {\r\n \"you could\": \"keep going\",\r\n \"like this\": \"forever\"\r\n }\r\n}\r\n<\/pre>\nmy_dict = {}<\/code>.
\n
\n[ulp id=’R7QVpFMZmjosABLC’]<\/p>\n2. Read<\/h2>\n
dict[\"key\"]<\/code> and get the result, or the dict.get(\"key\", \"default value\")<\/code> which also returns the result.<\/p>\n\r\nEXAMPLE_DICT = {\r\n \"animals\": [\"dog\", \"cat\", \"fish\"],\r\n \"a_number\": 1,\r\n \"a_name\": \"Sebasti\u00e1n\",\r\n \"a_boolean\": True,\r\n \"another_dict\": {\r\n \"you could\": \"keep going\",\r\n \"like this\": \"forever\"\r\n }\r\n}\r\n\r\nprint(str(EXAMPLE_DICT[\"animals\"])) # outputs ['dog', 'cat', 'fish']\r\nprint(str(EXAMPLE_DICT[\"a_number\"])) # outputs 1\r\nprint(str(EXAMPLE_DICT[\"this_one_does_not_exist\"])) # throws KeyError\r\n\r\n<\/pre>\n\r\n['dog', 'cat', 'fish']\r\nTraceback (most recent call last):\r\n1\r\n File \"\/home\/svinci\/projects\/jcg\/dictionaries\/base_example.py\", line 14, in <module>\r\n print(str(EXAMPLE_DICT[\"this_one_does_not_exist\"]))\r\nKeyError: 'this_one_does_not_exist'\r\n<\/pre>\n
\r\nEXAMPLE_DICT = {\r\n \"animals\": [\"dog\", \"cat\", \"fish\"],\r\n \"a_number\": 1,\r\n \"a_name\": \"Sebasti\u00e1n\",\r\n \"a_boolean\": True,\r\n \"another_dict\": {\r\n \"you could\": \"keep going\",\r\n \"like this\": \"forever\"\r\n }\r\n}\r\n\r\ndefault_message = \"oops, key not found\"\r\n\r\nprint(str(EXAMPLE_DICT[\"animals\"])) # outputs ['dog', 'cat', 'fish']\r\nprint(str(EXAMPLE_DICT[\"a_number\"])) # outputs 1\r\n\r\ntry:\r\n print(str(EXAMPLE_DICT[\"this_one_does_not_exist\"])) # throws KeyError\r\nexcept KeyError:\r\n print(\"KeyError\")\r\n\r\nprint(str(EXAMPLE_DICT.get(\"animals\", default_message))) # outputs ['dog', 'cat', 'fish']\r\nprint(str(EXAMPLE_DICT.get(\"a_number\", default_message))) # outputs 1\r\nprint(str(EXAMPLE_DICT.get(\"this_one_does_not_exist\"))) # outputs None\r\nprint(str(EXAMPLE_DICT.get(\"this_one_does_not_exist\", default_message))) # outputs \"oops, key not found\"\r\n\r\n<\/pre>\n\r\n['dog', 'cat', 'fish']\r\n1\r\nKeyError\r\n['dog', 'cat', 'fish']\r\n1\r\nNone\r\noops, key not found\r\n<\/pre>\n
3. Write<\/h2>\n
\r\nEXAMPLE_DICT = {\r\n \"animals\": [\"dog\", \"cat\", \"fish\"],\r\n \"a_number\": 1,\r\n \"a_name\": \"Sebasti\u00e1n\",\r\n \"a_boolean\": True,\r\n \"another_dict\": {\r\n \"you could\": \"keep going\",\r\n \"like this\": \"forever\"\r\n }\r\n}\r\n\r\n\r\ndef print_key(dictionary, key):\r\n print(str(dictionary.get(key, \"Key was not found\")))\r\n\r\n# Create a key\r\nEXAMPLE_DICT[\"this_one_does_not_exist\"] = \"it exists now\" # This statement will create the key \"this_one_does_not_exist\" and assign to it the value \"it exists now\"\r\nprint_key(EXAMPLE_DICT, \"this_one_does_not_exist\")\r\n\r\n# Update a key\r\nEXAMPLE_DICT[\"a_boolean\"] = False # Exactly, it looks the same, and behaves the same. It just overwrites the given key.\r\nprint_key(EXAMPLE_DICT, \"a_boolean\")\r\n\r\n# Delete a key\r\ndel EXAMPLE_DICT[\"this_one_does_not_exist\"] # Now \"this_one_does_not_exist\" ceased from existing (Again).\r\nprint_key(EXAMPLE_DICT, \"this_one_does_not_exist\")\r\n<\/pre>\nprint_key<\/code> which receives a dictionary and a key. It prints the value of the given key in the given dictionary or “Key was not found”<\/em> instead.<\/p>\n\r\nit exists now\r\nFalse\r\nKey was not found\r\n<\/pre>\n
4. Useful operations<\/h2>\n
4.1. In (keyword)<\/h3>\n
\r\ndef get(dictionary, key, default_value=None):\r\n if key in dictionary:\r\n return dictionary[key]\r\n else:\r\n return default_value\r\n\r\n\r\nmy_dict = {\r\n \"name\": \"Sebasti\u00e1n\",\r\n \"age\": 21\r\n}\r\n\r\nprint(str(get(my_dict, \"name\", \"Name was not present\")))\r\nprint(str(get(my_dict, \"age\", \"Age was not present\")))\r\nprint(str(get(my_dict, \"address\", \"Address was not present\")))\r\n\r\n<\/pre>\n\r\nSebasti\u00e1n\r\n21\r\nAddress was not present\r\n<\/pre>\n
\r\nmy_dict = {\r\n \"name\": \"Sebasti\u00e1n\",\r\n \"age\": 21\r\n}\r\n\r\n\r\ndef keys(dictionary):\r\n return [k for k in dictionary]\r\n\r\n\r\nprint(str(keys(my_dict)))\r\n<\/pre>\n\r\n['name', 'age']\r\n<\/pre>\n
4.2. Len (built-in function)<\/h3>\n
len<\/code> function returns the number of key-value pairs in a dictionary. It’s data types do not matter in this context. Notice the fact that it returns the number of key-value pairs<\/strong>, so a dictionary that looks like {\"key\", \"value\"}<\/code> will return 1<\/em> when asked for its length.<\/p>\n\r\nmy_dict = {\r\n \"name\": \"Sebasti\u00e1n\",\r\n \"age\": 21\r\n}\r\n\r\n\r\ndef keys(dictionary):\r\n result = [k for k in dictionary]\r\n # result.append(\"break the program plz\")\r\n if len(result) != len(dictionary):\r\n raise Exception('expected {} keys. got {}'.format(len(dictionary), len(result)))\r\n return result\r\n\r\n\r\nprint(str(keys(my_dict)))\r\n\r\n<\/pre>\n\r\nTraceback (most recent call last):\r\n File \"\/home\/svinci\/projects\/jcg\/dictionaries\/dict_all_keys.py\", line 15, in <module<\r\n print(str(keys(my_dict)))\r\n File \"\/home\/svinci\/projects\/jcg\/dictionaries\/dict_all_keys.py\", line 11, in keys\r\n raise Exception('expected {} keys. got {}'.format(len(dictionary), len(result)))\r\nException: expected 2 keys. got 3\r\n<\/pre>\n4.3. keys() and values()<\/h3>\n
keys()<\/code> and values()<\/code>. I think it’s pretty intuitive what these functions do, keys<\/strong> returns every key in the dictionary and values<\/strong> returns every value in the dictionary.<\/p>\nme = {\"name\": \"Sebasti\u00e1n\", \"age\": 21}<\/code>, me.keys()<\/code> will return [\"name\", \"age\"]<\/code> and me.values()<\/code> will return [\"Sebasti\u00e1n\", 21]<\/code>. Kind of… see, dictionaries in python are not ordered, then, the result of keys<\/code> and values<\/code> aren’t either. If you need to sort either keys or values just call sorted<\/code> passing the array as argument.<\/p>\n\r\ndef print_dict(dictionary):\r\n ks = list(dictionary.keys())\r\n vs = list(dictionary.values())\r\n for i in range(0, len(ks)):\r\n k = ks[i]\r\n v = vs[i]\r\n print(\"{}: {}\".format(str(k), str(v)))\r\n\r\n\r\nexample = {\r\n \"name\": \"Sebasti\u00e1n\",\r\n \"last_name\": \"Vinci\",\r\n \"age\": 21\r\n}\r\n\r\nprint_dict(example)\r\n\r\n<\/pre>\n\r\nage: 21\r\nname: Sebasti\u00e1n\r\nlast_name: Vinci\r\n<\/pre>\n
\r\nlast_name: Vinci\r\nage: 21\r\nname: Sebasti\u00e1n\r\n<\/pre>\n
values<\/code> anymore since it’s not necessary, but I think it’s pretty clear the way to use it.<\/p>\n\r\ndef print_dict(dictionary):\r\n ks = sorted(dictionary.keys())\r\n for k in ks:\r\n print(\"{}: {}\".format(str(k), str(dictionary.get(k))))\r\n\r\n\r\nexample = {\r\n \"name\": \"Sebasti\u00e1n\",\r\n \"last_name\": \"Vinci\",\r\n \"age\": 21\r\n}\r\n\r\nprint_dict(example)\r\n<\/pre>\n\r\nage: 21\r\nlast_name: Vinci\r\nname: Sebasti\u00e1n\r\n<\/pre>\n
4.4. items()<\/h3>\n
({\"a\": 1, \"b\": 2}.items() => [(\"a\", 1), (\"b\", 2)])<\/code>. With this method we can iterate over this pair array more seamlessly (keep in mind that this is still unordered), so if we just want to print our dictionary and the order doesn’t matter we can write:<\/p>\n\r\ndef print_dict(dictionary):\r\n for k, v in dictionary.items():\r\n print(\"{}: {}\".format(str(k), str(v)))\r\n\r\n\r\nexample = {\r\n \"name\": \"Sebasti\u00e1n\",\r\n \"last_name\": \"Vinci\",\r\n \"age\": 21\r\n}\r\n\r\nprint_dict(example)\r\n\r\n<\/pre>\ntuple[0]<\/code> and tuple[1]<\/code>, but we can’t do tuepl[0] = 1<\/code>. This will rase a TypeError: ‘tuple’ object does not support item assignment<\/em>.<\/p>\n4.5. update()<\/h3>\n
\r\nproduct = {\r\n \"description\": \"WCG E-Book\",\r\n \"price\": 2.75,\r\n \"sold\": 1500,\r\n \"stock\": 5700\r\n}\r\n\r\n\r\ndef sell(p):\r\n update = {\"sold\": p.get(\"sold\", 0) + 1, \"stock\": p.get(\"stock\") - 1}\r\n p.update(update)\r\n\r\n\r\ndef print_product(p):\r\n print(\", \".join([\"{}: {}\".format(str(k), str(product[k])) for k in sorted(p.keys())]))\r\n\r\nprint_product(product)\r\nfor i in range(0, 100):\r\n sell(product)\r\nprint_product(product)\r\n\r\n<\/pre>\nsell<\/code> a hundred times and then printing the product again. The sell function updates de product subtracting one from “stock”<\/em> and adding one to “sold”<\/em>. The output:<\/p>\n\r\ndescription: WCG E-Book, price: 2.75, sold: 1500, stock: 5700\r\ndescription: WCG E-Book, price: 2.75, sold: 1600, stock: 5600\r\n<\/pre>\n
4.6. copy()<\/h3>\n
\r\nme = {\r\n \"name\": {\r\n \"first\": \"Sebasti\u00e1n\",\r\n \"last\": \"Vinci\"\r\n },\r\n \"age\": 21\r\n}\r\nmy_clone = me.copy()\r\n\r\nmy_clone[\"age\"] = 22\r\nprint(\"my age: {}, my clone's age: {}\".format(me.get(\"age\"), my_clone.get(\"age\")))\r\n\r\nmy_clone.get(\"name\")[\"first\"] = \"Michael\"\r\nprint(\"my name: {}, my clone's name: {}\".format(me.get(\"name\").get(\"first\"), my_clone.get(\"name\").get(\"first\")))\r\n<\/pre>\n\r\nmy age: 21, my clone's age: 22\r\nmy name: Michael, my clone's name: Michael\r\n<\/pre>\n
copy<\/code>, which, if used carefully, is a powerful and useful tool.<\/p>\n5. Download the Code Project<\/h2>\n