R.I.B.H.U. Academy^®

More about Dictionaries

    In previous pages, you have seen examples of some simple dictio­naries. Dictio­naries are like associ­ative arrays in other program­ming languages, such as PHP and JavaScript. A dictionary can only contain those items/elements, which have unique keys. That is, unlike string, lists, and tuples, dictio­naries are unordered collection of items, and accessing or modifying any item through index number is not guaranteed. Those items can only be accessed and also modified through their respective keys, because dictio­naries are mutable objects.

    Key names must be immutable data-type, that is, integer, float, boolean, string, tuple or None data-type, (which also should be hashable). Thus, a key name can be 0 (zero), 1 (one), etc., but those key names are not index number. An item/element in a dictionary is always in key:value pair. The key and its respective value, both are separated by the : (colon) symbol. And, the items are separated by , (comma) symbol. A empty dictionary can be created by using dict() built-in function or {} (a pair of curly braces). However, without keys items in a pair of curly braces are set data-type literal.

my_dict = { (1, 'a', None, True): 'one' }
print( my_dict, type( my_dict ) )   # Outputs as follows:

my_dict = { False: 'zero' }
print( my_dict, type( my_dict ) )   # Outputs as follows:

my_dict = { None: 'zero' }
print( my_dict, type( my_dict ) )   # Outputs as follows:

my_dict = { [1,2,3,4]: 'one' }
print( my_dict, type( my_dict ) )   # Outputs ERROR as follows:

my_dict = { {1:'a',2:'b',3:'c'}: 'one' }
print( my_dict, type( my_dict ) )   # Outputs ERROR as follows:

my_dict = { (1, ['a'], {}, set()): 'one' }
print( my_dict, type( my_dict ) )   # Outputs ERROR as follows:

    In the above example, you can see that even any item/element in the tuple key of a dictionary literal, is list/dictionary/set (that is, not hashable), then the same TypeError is displayed in output. Thus, every item in the tuple key also must be immutable data-type. When you remove all other items in above example, that is, ['a'], {}, set(), then (1,) key (when comma is present, it is tuple, otherwise it is int data-type) will not throw any ERROR.

    You can see in comparing different methods page, that __hash__() method is available for every data-type, however, when you check it with help() built-in function, you will find at the bottom (of help documen­tation) that __hash__ = None is specified in list, dict (dictionary), set and bytearray data-types. For other data-types, such as bool, None, int, float, complex, string, tuple, bytes, memoryview, __hash__() method is equi­valent to hash() built-in function. There are other (custom) data-types available in Python through different modules. Even you can create custom modules, classes, functions, methods and custom data-types. You should check that whether any data-type is hashable or not, by following examples:

print( help( list.__hash__ ) )

print( help( dict.__hash__ ) )

print( help( set.__hash__ ) )

print( help( bytearray.__hash__ ) )

    For above codes, the output will be same as print( help( None ) ) becuase __hash__ is equal to None (data-type) for list, dict, set, bytearray. However, the OUTPUT for following codes will be same, and they show Return hash(self).

print( help( bool.__hash__ ) )   # Outputs as follows:

print( help( int.__hash__ ) )   # Outputs as follows:

print( help( float.__hash__ ) )   # Outputs as follows:

print( help( complex.__hash__ ) )   # Outputs as follows:

print( help( str.__hash__ ) )   # Outputs as follows:

print( help( tuple.__hash__ ) )   # Outputs as follows:

print( help( bytes.__hash__ ) )   # Outputs as follows:

print( help( memoryview.__hash__ ) )   # Outputs as follows:

print( help( None.__hash__ ) )   # Outputs as follows:

Adding, Modifying & Deleting an Item

    An item/element in a dictionary literal can be added, modified, or deleted using the = (assignment) operator. The process is similar to modifying/deleting any item in a list literal, except that key names are used instead of index number inside a pair of square brackets, just after the variable name or dictionary literal. Unlike list, an item in a dictionary literal can be added with the assignment operator, because dictionary is key-based sequence data-type.

my_dict = {}
my_dict['a'] = [12, 14, 16, 18]
print( my_dict )   # Outputs {'a': [12, 14, 16, 18]}

# Continued with above example:

my_dict[None] = object()
print( my_dict )   # Outputs {'a': [12, 14, 16, 18], None: <object object at 0x000002B098534270>}

    The value of an item in a dictionary literal can be of any valid data-type of Python, but you should carefully name keys. An item in a dictionary can be modified as shown below:

my_dict[None] = True
print( my_dict )   # Outputs {'a': [12, 14, 16, 18], None: True}

del my_dict[None]
print( my_dict )   # Outputs {'a': [12, 14, 16, 18]}

del my_dict
print( my_dict )   # Outputs ERROR as shown below, because whole dictionary literal is deleted

print( help( dict ) )   # Outputs as shown below: