Archives for April 2018

Dictionary  in Python like list is a collection of objects.Unlike lists ,items in dictionary are accessed by key.Similar to lists ,items can be added or removed from dictionary.While the items in a list are sorted in a specific order ,the items in a dictionary are not sorted.The size of dictionary is not fixed ,items can be added or removed from the dictionary.

Creating a dictionary

To create a dictionary you specify key,value pairs.The keys and values are separated by colon.

Dictionary is declared using the parenthesis as:

dict = {'item1': 1, 'item2': 2}

In the above dictionary there are two elements.The key of first element is ‘item1’ and key of the second element is ‘item2’ .

once dictionary is declared you can modify the dictionary by using the key as:

dict['item2']="two"

You can get the length of the dictionary by using the len() function as:

dict.len(dict)

The items in the dictionary can be retreived by using the items method as:

dict.items()

Removing item from a dictionary

You can delete item from a dictionary using the del keyword as:

del sampleDict['2']

looping through the items in the dictionary

for x in sampleDict:
print('x=%s'%(sampleDict[x]))

ashish

Declaring a class

We define a class in Python using the class keyword.To define a class called Main we use the following:

class Main:
   def __init__(self):
     self.tempVar= 1

def SetValue(self,value):
     self.EmpId=value
     def GetValue(self):
     print("EmpId=%s"%(self.EmpId))

There are few important points to be noted in the above code:
1.Class is defined using the class keyword.Here the name of the class is Main.
2.Class initialization happens in a method called __init__.It is similar to class constructor in other languages.
3.Methods are defined in a similar way as normal functions using the def statement followed by method name.
4.self is the parameter defined in the method above.It refers to the class object using which the method is callled.So if you have two different objects a and b then self will refer to a when called using the object a and it will refer to b when called using the object b.

We can declare objects of the above class as:

obj1=Main()
obj1.SetValue(1)
obj1.GetValue()

obj2=Main()
obj2.SetValue(2)
obj2.GetValue()

Inheritance

A class can inherit the attributes from another class.In the following example we are defining a class called Inherited which inherits its behaviour from class Main.

class Inherited(Main):
    def Message(self):
      print("Hello from Inherited")
      print("EmpId=%d"%(self.tempVar))

Following are the main points in the class declaration above:
1.A inherited class is declared just like a normal class.But after the nanme of the class we pass parent class name in brackets.
2.The inherited class has access to the variables of the parent class.In the above sample we are accessing the variable called tempVar in the derived class.

Multilevel Inheritance

You can implement multilevel inheritance as:

class FirstClass:
   pass


class SecondClass(FirstClass):
   pass


class ThirdClass(SecondClass):
   pass

Calling parent class constructor

The constructor defined in the child class is called when the object of child class is created.So if  the child class defines the following constructor,then only this constructor will be called and the parent class constructor will not be called.

def__init__(self):
Main.__init__(self)
print("child constructor")

 class Main:
def__init__(self):
self.tempVar=1
print("base constructor")

super().parentMethodName(args)

ashish

with statement was introduced in Python 2.5 and is quite useful when you want to work with a resource and then want to dispose/close it when you are done.

The with statement is used for writing blocks of code when we want to call methods as defined by context.It allows to write block of code in a more concise way then
try finally block.The with statement is used to wrap the execution of a block with methods defined by a context manager

you use with statement as:

specify expression after with statement followed by target variable

with expression as variable

when the above statement is executed the __enter__ method of the expression result is called and the result is assigned to the given variable.

In following example we are creating an object of file using the with statement.The benefit of using with statement here is that the file object will be automatically closed after the block executes.Even if exception occurs  in the while block ,the file will still be closed.

import csv
with open('csvSample.csv') as file:
csv_values = csv.DictReader(file)
for row in csv_values:
print("%s,%s"%(row['column1'],row['column2']))

Without using with statement we will have to close the file explicitly.Same logic as the above sample can be written without using with statement as:

file = open('csvSample.csv')
csv_values = csv.DictReader(file)
for row in csv_values:
print("%s,%s"%(row['column1'],row['column2']))
file.close()

The above logic is not as concise as the previous one.Not only this if an exception happens file object will not be closed unlike the with statement.When we use with statement the file is guaranteed to be closed whether exception happens or not.

If you want to use your custom class in with statement then you need to define the enter and  exit methods:

class SampleClass():
def __init__(self, value):
# constructor logic
def __enter__(self):
# create logic
def __exit__(self, type, value, traceback):
#destroy logic

The above is just a pseudo code,but you can use it to define actual class which can be used in with statement.

ashish