Python : Magic Methods
In python everything is an object and we are applying some operations on this objects. But every operation have a dedicated method behind the scene in corresponding type implementation.
>> x = 10
>> x + 10 is equivalent to x.__add__(10)
>> x * 2 is equivalent to x.__mul__(2)
>>> names = ['A', 'AB', 'ABC']
>>> names[0] is equivalent to names.__getitem__(0)
>>> names.__setitem__(0, 'BAB')
>>> names is now ['BAB', 'AB', 'ABC']
Now let us use this in a custom class.
class Point:
def __init__(self,x ,y):
self.x = x
self.y = y
def __add__(self,other):
return Point(self.x + other.x,self.y + other.y)
def __str__(self):
return 'Point x= {} and y = {}'.format(self.x, self.y)
p1 = Point(10,20)
p2 = Point(1,2)
p3 = p1 + p2
print(p3)
outputs :Point x= 11 and y = 22
str vs repr
While debugging if you evaluate our point object , it will be displayed like this.
>>p1
>><__main__.Point at 0x24961fbf898>`
__repr__ is used during debugging a lot, its called representation of the object and used widely for debug only purpose.
‘str’ is used for mainly for printing info.
>>d1 = datetime.date(2012, 12,24)
>>d1
outputs:
datetime.date(2012, 12, 24)
>>print(d1)
outputs:
>>2012-12-24
So now let us add this support to our point class as shown below
class Point:
def __init__(self,x ,y):
self.x = x
self.y = y
def __add__(self,other):
return Point(self.x + other.x,self.y + other.y)
def __str__(self):
return 'Point x= {} and y = {}'.format(self.x, self.y)
def __repr__(self):
return('Point({!r},{!r})'.format(self.x, self.y))
>>p1 = Point(10,20)
>>p1
outputs : Point(10,20)
>>print(p1)
outputs: Point x= 10 and y = 20
So when writing your own class ensure to include __str__ and __repr__ as best practice.
Context Managers
The basic resource management pattern we have been following so far is open resource, use it and close it.
In case of file, we have been doing this safeguarding using with statement.
with open(filename, 'r') as f:
Internally this is implemented using two magic methods __enter__ and __exit__. So let us consider
our point class is a resource and needs to do some clean up after its usage. Then in that case we
can add context managers to our class as follows..
class Point(object):
def __init__(self, x, y):
self.x = x
self.y = y
def __add__(self, other):
return Point(self.x + other.x, self.y + other.y)
def __str__(self):
return 'Point x= {} and y = {}'.format(self.x, self.y)
def __repr__(self):
return ('Point({!r},{!r})'.format(self.x, self.y))
def __enter__(self):
print('Entering')
return "A sample P"
def __exit__(self, ty, val, tb):
print('Exiting')
print(ty, val, tb)
As shown above (line:17)the return value of entering is enabling us to use as statement along with
Now we can use this in with context as shown below..
p = Point(10,20)
with p as val:
print(p)
print(val)
outputs:
Entering
Point x= 10 and y = 20
A sample P
Exiting
None None None
The paramters in __exit__ can be used to capture the exceptions and deal based on that.
p = Point(10,20)
with p as val:
print(p)
print(9/0)
print(val)
outputs:
Entering
Traceback (most recent call last):
Point x= 10 and y = 20
File "D:/Git/py-kitchen/apps/test-routines/oop.py", line 29, in <module>
Exiting
print(9/0)
Exception happend <class 'ZeroDivisionError'> division by zero <traceback object at 0x000001F94E5C4C48>
ZeroDivisionError: division by zero
So in the above case even if there was an exception in main program flow, __exit__ in point object gets
called and its aware of exception happend and handle its clean up irrespective of exception in main flow.
Example
As an example let us create a Portfolio holding collection object. So this class loads all holdings and provides a collection interface. The holding information is stored in a csv file.
Name,Date,Shares,Price
HPQ,7/11/2007,100,32.2
IBM,7/12/2007,50,91.9
GE,7/13/2007,150,83.44
CAT,7/14/2007,200,51.23
MSFT,7/15/2007,95,40.37
HPE,7/16/2007,50,65.1
AFL,7/17/2007,100,70.44
As a first step, let us create our Holding class.
class Holding(object):
def __init__(self, name, date, shares, price):
self.name = name
self.date = date
self.shares = shares
self.price = price
def __str__(self):
return 'Name = {}, Date={}, Shares={}, Price={}'.format(self.name,
self.date,
self.shares,
self.price)
Now let us create our Portfolio collection object that can hold Holdings and provides methods to access that. Here we will exercise our knowledge on some magic methods.
class Portfolio(object):
def __init__(self):
self.holdings = []
@classmethod
def load_from_csv(cls, filename):
self = cls()
with open(filename, 'r') as f:
rows = csv.reader(f)
head = next(rows) # skip header
for row in rows:
try:
self.holdings.append(Holding(name=row[0], date=row[1],
shares = int(row[2]), price=float(row[3])))
except ValueError as ve:
print('ignored{}'.format(row))
return self
def __len__(self):
return len(self.holdings)
def __getitem__(self, item):
return self.holdings[item]
def __iter__(self):
return self.holdings.__iter__()
def cost(self):
return sum([(holding.price * holding.shares) for holding in self.holdings])
So first step, we created a factory method (@classmethod) which creates a Portfolio from csv file.(line:5).
Then we added some magic methods that will provide collection like properties to Portfolio. We have
implemented __len__, __getitem__, __iter__ . In addition we have implemented a cost method that
computes the value of the portfolio.
# program.py
portfolio = Portfolio.load_from_csv('stocks.csv')
for item in portfolio:
print (item)
print ('Total number of holdings is {}'.format(len(portfolio)))
print('Total value of portfolio is {}'.format(portfolio.cost()))
outputs..
Name = HPQ, Date=7/11/2007, Shares=100, Price=32.2
Name = IBM, Date=7/12/2007, Shares=50, Price=91.9
Name = GE, Date=7/13/2007, Shares=150, Price=83.44
Name = CAT, Date=7/14/2007, Shares=200, Price=51.23
Name = MSFT, Date=7/15/2007, Shares=95, Price=40.37
Name = HPE, Date=7/16/2007, Shares=50, Price=65.1
Name = AFL, Date=7/17/2007, Shares=100, Price=70.44
Total number of holdings is 7
Total value of portfolio is 44711.15
Coding is fun enjoy…