Python: Data Collections - Lists


Like other programming languages, Python supports collection data types like arrays and dictionaries. In these series of posts, we are only looking at the features of Python 3.x where there is no longer any array data type in this version. However, there is no need to worry as the List data type in Python 3.x has all features of an array plus more.Lists are initialized like an array but Python 3.x makes it very easy to add, update and remove elements which can be done as individual elements or as slices.

When dealing with collections it is important to discuss the concept of slices. A slice refers to a group of consecutive elements of the list on which a single operation can be applied. As an example, if you have to divide elements from indexes 1 through 10 by of an array 'numbers' by 2 and transfer the results to a new array 'div', the operation can be performed by the following statement:

div[0:9] = numbers[1:10]/2

In languages that don't support slices, a similar operation will require the use of a loop. FORTRAN was the first language to use slices and it gave programmers tremendous power in array operations.

We now look at code samples to perform the various operations on Python lists. Note that we declare the same functions in a class to adhere to object-oriented semantics, and in-line comments explain what different functions and lines of code are doing. You can easily copy/paste the code in your Python code.

class DemoClass:
   #List is same as Array in Python
class DemoListClass:
    # List Initialization
    def Initialize(self):
        #lists are defined between square brackets '[]'
        self._listStr=["One", "Two", "Three", "Four"]
        self._listNumber = [1, 2, 3, 4]

    # List Print -  values at specific indexes
    def PrintInit(self):
        print("------ PrintInit");
        print("String list element 0 :" + self._listStr[0])
        print("String list element 3 :" + self._listStr[3])
        print("Number list element 3 :" + str(self._listNumber[3]))

    # List Modify - Add
    def ModifyElements_Add(self):
        print("------ ModifyElements_Add");
        # Add 4 elements directly
        self._listNumber.extend([5, 6, 7, 8])
        print("All elements of listNumber", *self._listNumber)
        #NOTE: If individual elements have to be added, use _listNumber.append instead
        # Add 4 elements through another list
        localList1 = [9,10,11,12]
        self._listNumber.extend(localList1)
        print("All elements of listNumber: ",*self._listNumber)
        # Add 8 elements by adding 2 lists
        localList2 = [13, 14, 15, 16]
        localList3 = [17, 18, 19, 20]
        self._listNumber.extend(localList2 + localList3);
        print("All elements of listNumber: ", *self._listNumber)

    # List Modify - Delete
    def ModifyElements_Delete(self):
        print("------ ModifyElements_Delete");
        print("All elements of listNumber: ", *self._listNumber)
        # Specify value of element to be removed
        self._listNumber.remove(1) #Delete one element
        print("All elements of listNumber: ", *self._listNumber)
        # Specify index of element to be removed
        del self._listNumber[1]  #Delete one more element
        print("All elements of listNumber: ", *self._listNumber)
        del self._listNumber[1:3] #Delete two more elements (in slices)
        print("All elements of listNumber: ", *self._listNumber)

    # List Modify - Update
    def ModifyElements_Update(self):
        print("------ ModifyElements_Update");
        print("All elements of listNumber: ", *self._listNumber)
        # Update element at index 0
        self._listNumber[0]=100
        print("All elements of listNumber: ", *self._listNumber)
        # Update 3 elements directly using slices
        self._listNumber[1:3] = [200,300,400];
        print("All elements of listNumber: ", *self._listNumber)
        # Update 4 elements from another list using slides
        localList1 = [500, 600, 700, 800]
        self._listNumber[4:7] = localList1;
        print("All elements of listNumber: ", *self._listNumber)

# Instantiate the class and call member functions
dlc=DemoListClass()
dlc.Initialize()
dlc.PrintInit()
dlc.ModifyElements_Add()
dlc.ModifyElements_Delete()
dlc.ModifyElements_Update()
The output for the above code is:
------ PrintInit
String list element 0 :One
String list element 3 :Four
Number list element 3 :4
------ ModifyElements_Add
All elements of listNumber 1 2 3 4 5 6 7 8
All elements of listNumber:  1 2 3 4 5 6 7 8 9 10 11 12
All elements of listNumber:  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
------ ModifyElements_Delete
All elements of listNumber:  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
All elements of listNumber:  2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
All elements of listNumber:  2 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
All elements of listNumber:  2 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
------ ModifyElements_Update
All elements of listNumber:  2 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
All elements of listNumber:  100 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
All elements of listNumber:  100 200 300 400 8 9 10 11 12 13 14 15 16 17 18 19 20
All elements of listNumber:  100 200 300 400 500 600 700 800 11 12 13 14 15 16 17 18 19 20

In the next article we take a look at Python dictionaries.

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