Python: Data Collections - Dictionary


In a previous article, we looked at the features of the list data collection in Python. In this article we look at the dictionary collection type in Python. As in other languages, the dictionary is a list of key-value pairs and just like other variables in Python we do not explicitly need to define the data type of key and value. It is easy to do bulk updates in Python dictionaries using other dictionary objects, but unlike a list the slice(:) operator is not supported. Hence some bulk updates have to be done using a loop.

The following code snippets demonstrate how dictionaries are created, modified and deleted. Inline comments (starting with #) clarify the purpose of specific lines of code.

# Code for demonstration of Python Dictionary
class DemoDictClass:
    # List Initialization
    def Initialize(self):
        # Dictionaries are defined between curly brackets '{}'
        self._dictStr={"One" : 1, "Two":2, "Three":3, "Four":4}
        self._dictNumber =  {1:"One", 2:"Two", 3:"Three", 4:"Four"}

    # List Print -  values at specific indexes
    def PrintInit(self):
        print("------ PrintInit");
        #Loop to print all elements
        print("------ All key,value pairs")
        for key, value in self._dictStr.items():
            print(key + "," + str(value))
        #Single command to print all Keys
        print("------ All keys")
        print(self._dictStr.keys())
        # Single command to print all values
        print("------ All values")
        print(self._dictStr.values())
        print("String dictionary element with key 'One' :" + str(self._dictStr["One"]))
        print("String dictionary element with key 'Three' :" + str(self._dictStr["Three"]))
        print("Number dictionary element with key 2 :" + self._dictNumber[2])
        print("Number dictionary element with key 4 :" + self._dictNumber[4])

    # List Modify - Add
    def ModifyElements_Add(self):
        print("------ ModifyElements_Add");
        # Add 4 elements directly
        self._dictNumber.update({5:"Five", 6:"Six", 7:"Seven", 8:"Eight"})
        print("------ All values of dicNumber:",self._dictNumber.values())
        # Add 4 elements through another dictionary
        localDict1 = {9:"Nine", 10:"Ten", 11:"Eleven", 12:"Twelve"}
        self._dictNumber.update(localDict1)
        print("------ All values of dicNumber:", self._dictNumber.values())
        #Adding existing element has no impact
        self._dictNumber.update({9:"Nine"})
        print("------ All values of dicNumber:", self._dictNumber.values())
        # Add 8 elements by adding 2 dictionaries
        localDict2 = {13:"Thirteen", 14: "Fourteen", 15:"Fifteen", 16:"Sixteen"}
        localDict3 = {17: "Seventeen", 18: "Eighteen", 19:"Nineteen", 20:"Twenty"}
        #{**localDict2, **localDict3} will merge dictionaries
        self._dictNumber.update({**localDict2, **localDict3});
        print("------ All values of dicNumber:", self._dictNumber.values())

    # List Modify - Delete
    def ModifyElements_Delete(self):
        print("------ ModifyElements_Delete");
        print("------ All values of dicNumber:", self._dictNumber.values())
        # Delete 1 element with specified key
        self._dictNumber.pop(2)
        print("------ All values of dicNumber:", self._dictNumber.values())
        # Delete 1 element with specified key - another way
        del self._dictNumber[5]
        print("------ All values of dicNumber:", self._dictNumber.values())
        # Remove all elements of a dictionary
        self._newDictStr = self._dictStr.copy() # create a new memory copy of dictionary
        self._dictStr.clear() #Delete two more elements (in slices)
        print("------ All values of dicStr:", self._dictStr.values())
        print("------ All values of newDicStr:", self._newDictStr.values())

    # List Modify - Update
    def ModifyElements_Update(self):
        print("------ ModifyElements_Update");
        print("------ All values of newDicStr:", self._newDictStr.values())
        # Update element with key "One"
        self._newDictStr["One"]=10
        print("------ All values of newDicStr:", self._newDictStr.values())
        # Update using another dictionary
        dictTemp = {"Two": 20, "Three": 30, "Four": 40}
        self._newDictStr.update(dictTemp)
        print("------ All values of newDicStr:", self._newDictStr.values())
        # Update dictionary to restore original values. Values with same key will be overwritten
        dictTemp = {"One":1, "Two": 2, "Three": 3, "Four": 4}
        self._newDictStr.update(dictTemp)
        print("------ All values of newDicStr:", self._newDictStr.values())
        # Update values using a loop
        for k in self._newDictStr: #iterate through every key in k
            self._newDictStr[k] = self._newDictStr[k] * 10
        print("------ All values of newDicStr:", self._newDictStr.values())

# Instantiate the class and call member functions
ddc=DemoDictClass()
ddc.Initialize()
ddc.PrintInit()
ddc.ModifyElements_Add()
ddc.ModifyElements_Delete()
ddc.ModifyElements_Update()

The output for the above code is:
------ PrintInit
------ All key,value pairs
One,1
Two,2
Three,3
Four,4
------ All keys
dict_keys(['One', 'Two', 'Three', 'Four'])
------ All values
dict_values([1, 2, 3, 4])
String dictionary element with key 'One' :1
String dictionary element with key 'Three' :3
Number dictionary element with key 2 :Two
Number dictionary element with key 4 :Four
------ ModifyElements_Add
------ All values of dicNumber: dict_values(['One', 'Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight'])
------ All values of dicNumber: dict_values(['One', 'Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight', 'Nine', 'Ten', 'Eleven', 'Twelve'])
------ All values of dicNumber: dict_values(['One', 'Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight', 'Nine', 'Ten', 'Eleven', 'Twelve'])
------ All values of dicNumber: dict_values(['One', 'Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight', 'Nine', 'Ten', 'Eleven', 'Twelve', 'Thirteen', 'Fourteen', 'Fifteen', 'Sixteen', 'Seventeen', 'Eighteen', 'Nineteen', 'Twenty'])
------ ModifyElements_Delete
------ All values of dicNumber: dict_values(['One', 'Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight', 'Nine', 'Ten', 'Eleven', 'Twelve', 'Thirteen', 'Fourteen', 'Fifteen', 'Sixteen', 'Seventeen', 'Eighteen', 'Nineteen', 'Twenty'])
------ All values of dicNumber: dict_values(['One', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight', 'Nine', 'Ten', 'Eleven', 'Twelve', 'Thirteen', 'Fourteen', 'Fifteen', 'Sixteen', 'Seventeen', 'Eighteen', 'Nineteen', 'Twenty'])
------ All values of dicNumber: dict_values(['One', 'Three', 'Four', 'Six', 'Seven', 'Eight', 'Nine', 'Ten', 'Eleven', 'Twelve', 'Thirteen', 'Fourteen', 'Fifteen', 'Sixteen', 'Seventeen', 'Eighteen', 'Nineteen', 'Twenty'])
------ All values of dicStr: dict_values([])
------ All values of newDicStr: dict_values([1, 2, 3, 4])
------ ModifyElements_Update
------ All values of newDicStr: dict_values([1, 2, 3, 4])
------ All values of newDicStr: dict_values([10, 2, 3, 4])
------ All values of newDicStr: dict_values([10, 20, 30, 40])
------ All values of newDicStr: dict_values([1, 2, 3, 4])
------ All values of newDicStr: dict_values([10, 20, 30, 40])

Comments

Post a Comment

Popular posts from this blog

Part I: Backpropagation mechanics for a Convolutional Neural Network

Image
In another article, we explained the basic mechanism of how a Convolutional Neural Network (CNN) works. In this article we explain the mechanics backpropagation w.r.t to a CNN and derive it value. We use the same simple CNN as used int he previous article, except to make it more simple we remove the ReLu layer. In part-II of this article we derive the backpropagation in the same CNN with the addition of a ReLu layer. The CNN we use is given below: In this simple CNN, there is one 4x4 input matrix, one 2x2 filter matrix (also known as kernel), a single convolution layer with 1 unit, a single pooling layer (which applied the MaxPool function) and a single fully connected (FC) layer. The elements of the filter matrix are equivalent to the unit weights in a standard NN and will be updated during the backpropagation phase. Assuming a stride of 2 with no padding, the size of the convolution layer is determined by the following equation: $$ N={(W - F + 2.P)\over S} + 1 $$ He...
Read more

Introducing Convolution Neural Networks with a simple architecture

Image
Convolution Neural Networks (CNNs) are different from standard Neural Networks (NNs) as their input is 2-dimensional vs. 1-dimensional in a standard neural network. While the underlying principles between CNNs and NNs are same, CNNs do introduce some new concepts. In this article, we take a look at how CNNs operate using a very simple CNN architecture, given below. In this simple CNN, there is one 4x4 input matrix, one 2x2 filter matrix (also known as kernel ), a single convolution layer with 1 unit, 1 Rectified Linear Unit (ReLu) layer with one unit, a single pooling layer and a single fully connected (FC) layer. The elements of the filter matrix are equivalent to the unit weights in a standard NN and are updated during the backpropagation phase. Real-life CNNs are significantly more complex than this with several repeating layers of convolutional, ReLu and pooling layers forming a true deep learning network. All the matrix dimensions are also magnitudes higher to represent hig...
Read more

Part III: Backpropagation mechanics for a Convolutional Neural Network

Image
In part-II of this article, we derived the weight update equation for the backpropagation operation of a simple Convolutional Neural Network (CNN). The input for the CNN considered in part-II is a grayscale image, hence, the input is in the form of a single 4x4 matrix. CNNs used in practice however, use color images where each of the Red, Green and Blue (RGB) color spectrums serve as input. Hence, a CNN with the inputs color coded with their respective spectrums look like: In this article we expand upon the original CNN where the input is represented by 3, 4x4 matrices each presenting the pixel intensities for the RGB color spectrum. Hence is we represent each of the pixels with the CNN given is represented by: In this CNN, there are 3, 4x4 input matrices, one 2x2 filter matrix (also known as kernel), a single convolution layer with 1 unit, a single ReLu layer, a single pooling layer (which applies the MaxPool function) and a single fully connected (FC) layer. The elements ...
Read more