In [2]:
# problem 1
class Foo:
x = 1
f1 = Foo()
f2 = Foo()
print Foo.x, f1.x, f2.x
f2.x = 2
print Foo.x, f1.x, f2.x
Foo.x = 3
print Foo.x, f1.x, f2.x
In [3]:
# problem 4
class A:
x = 1
def f(self):
return self.x
class B(A):
x = 2
def g(self):
return self.x
a = A()
b = B()
print a.f()
print b.f(), b.g()
In [4]:
# problem 7
x = 1
class Foo:
a = x
x = 2
print a, x
print x
Example: Timer class
Problem: Write a Timer class.
class Timer:
pass
def timepass():
for i in range(10000):
for j in range(1000):
x = i*j
t = Timer()
t.start()
timepass()
t.stop()
print "took %f seconds" % t.elapsedDucktyping
In [10]:
%%file numbers.txt
one
two
three
four
five
In [14]:
def wordcount(fileobj):
lc = len(fileobj.readlines())
fileobj.seek(0)
wc = len(fileobj.read().split())
fileobj.seek(0)
cc = len(fileobj.read())
return lc, wc, cc
print wordcount(open("numbers.txt"))
class FakeFile:
def read(self):
return "one\ntwo\nthree\n"
def readlines(self):
return ["one\n", "two\n", "three\n"]
def seek(self, pos):
pass
print wordcount(FakeFile())
class Foo: pass
f = Foo()
f.read = lambda: ""
f.readlines = lambda: []
f.seek = lambda n: 0
print wordcount(f)
Problem: Write a class UpperCaseFile, that takes a fileobj as argument and behaves like a file, but returns everything in uppercase
when read.
f = UpperCaseFile(open("numbers.txt"))
line = f.readline() # should give "ONE\n"
lines = f.readlines() # should give ["TWO\n", "THREE\n", "FOUR\n", "FIVE\n"]
f = UpperCaseFile(open("numbers.txt"))
print wordcount(f) # should be same as wordcount(open("numbers.txt"))There is a StringIO class in StringIO module that give file like interface to in-memory object.
In [18]:
from StringIO import StringIO
f = StringIO()
f.write("hello\nworld\n")
f.seek(0)
print f.read()
f.seek(0)
print wordcount(f)
Special Class Methods
In [19]:
x = 1
print x
In [33]:
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def __str__(self):
return "(%s, %s)" % (self.x, self.y)
p = Point(2, 3)
print p
In [27]:
print repr(1)
In [28]:
print repr("hello")
In [29]:
print "hello"
In [31]:
[1, 2, "3, 4"]
Out[31]:
In [35]:
print p
In [36]:
print [p]
In [37]:
print repr(p)
We need to implement __repr__ to fix that.
In [41]:
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def __str__(self):
return "(%s, %s)" % (self.x, self.y)
def __repr__(self):
return "Point(%s, %s)" % (self.x, self.y)
p = Point(2, 3)
print p, [p, "hello", (2, 3), 5]
Emulating Container Types
In [42]:
# Do you know what happens when you do this?
x = [1, 2, 3, 4]
print x[1]
In [43]:
x.__getitem__(1)
Out[43]:
In [44]:
x = xrange(2, 8)
print len(x)
print x[3]
In [45]:
x.__len__()
Out[45]:
Example: yrange
Lets write a class yrange that behaves like built-in class xrange.
Example: Node class
In [46]:
class yrange:
def __init__(self, start, stop):
self.start = start
self.stop = stop
def __len__(self):
return self.stop - self.start
def __getitem__(self, index):
return self.start + index
y = yrange(2, 8)
print len(y)
print y[3]
Problem: Implement a Node class that allows accessing properties like a dictionary.
class Node:
def __init__(self, tagname, **attrs):
self.tagname = tagname
x = Node("input", type='text', name='x', id='id_x')
x['class'] = 'required'
x['value'] = 'foo'
print x['name'], x['value']
print x
In [48]:
## Command library using classes
In [52]:
%%file command1.py
class Command:
def run(self, filenames):
lines = self.readfiles(filenames)
lines = self.generate_output(lines)
self.printlines(lines)
def process_line(self, line):
"""All bases classes should implement this."""
raise NotImplementedError()
def generate_output(self, lines):
for line in lines:
for outline in self.process_line(line):
yield outline
def readfiles(self, filenames):
for f in filenames:
for line in open(f):
yield line
def printlines(self, lines):
for line in lines:
print line.strip("\n")
In [50]:
%%file uppercase1.py
from command1 import Command
class UpperCase(Command):
def process_line(self, line):
yield line.upper()
if __name__ == "__main__":
import sys
cmd = UpperCase()
cmd.run(sys.argv[1:])
In [53]:
!python uppercase1.py uppercase1.py
In [54]:
%%file grep2.py
from command1 import Command
class Grep(Command):
def __init__(self, pattern):
self.pattern = pattern
def process_line(self, line):
if self.pattern in line:
yield line
if __name__ == "__main__":
import sys
cmd = Grep(sys.argv[1])
cmd.run(sys.argv[2:])
In [55]:
!python grep2.py def grep2.py
Problem: Write a script replace.py using Command class to replace a pattern with
a replacement in given files. The script will get the pattern and replacement as first two arguments, followed by one or more files as input.
python replace.py def define grep2.py command1.pyLets try to improve the Command class to handle to make it more generic.
In [56]:
%%file command2.py
"""A new approach to writing Command class.
"""
class Command:
def run(self, filenames):
for filename in filenames:
self.process_file(filename)
def process_file(self, filename):
for line in open(filename):
process_line(line)
def process_line(self, line):
"""All bases classes should implement this."""
raise NotImplementedError()
class UpperCase(Command):
def process_line(self, line):
print line.upper()
class WordCount(Command):
def process_file(self, filename):
lc = len(open(filename).readlines())
wc = len(open(filename).read().split())
cc = len(open(filename).read())
print lc, wc, cc, filename
cmd = WordCount()
cmd.run(["command1.py", "command2.py"])
In [57]:
!python command2.py
Understanding Methods
In [2]:
class Foo:
x = 1
def getx(self):
return self.x
foo = Foo()
print foo.getx()
print Foo.getx(foo)
In [3]:
Foo.getx
Out[3]:
In [4]:
foo.getx
Out[4]:
In [5]:
def add(x, y):
return x+y
In [7]:
def make_adder(x):
def adder(y):
return add(x, y)
return adder
add5 = make_adder(5)
print add5(6)
In [8]:
def bindself(method, self):
"""Returns a new function with self already bound"""
def f(*a, **kw):
return method(self, *a, **kw)
return f
f = bindself(Foo.getx, foo)
f()
Out[8]:
Looking inside objects
In [10]:
class Foo:
x = 1
def getx(self):
return self.x
foo = Foo()
In [11]:
Foo
Out[11]:
In [12]:
dir(Foo)
Out[12]:
In [13]:
Foo.__dict__
Out[13]:
In [14]:
Foo.__dict__['x'] = 2
Foo.x
Out[14]:
In [15]:
Foo.__dict__['y'] = 3
Foo.y
Out[15]:
In [17]:
# Lets try to find how add5 is storing value of x
dir(add5)
Out[17]:
In [19]:
def inc(x, amount=1): return x+amount
In [20]:
inc.func_defaults
Out[20]:
How Python stores variables?
In [21]:
x = 1 # what does this mean?
In [22]:
g = globals()
In [23]:
g['x']
Out[23]:
In [24]:
g['x'] = 2
In [25]:
x
Out[25]:
Understanding Function Calls
In [28]:
def add(x, y): return x+y
In [29]:
add(5, 4)
Out[29]:
In [30]:
d = [1, 2, 3]
d[2]
Out[30]:
In [31]:
Foo
Out[31]:
In [32]:
Foo()
Out[32]:
In [34]:
class Adder:
def __init__(self, x):
self.x = x
def __call__(self, y):
return add(self.x, y)
add5 = Adder(5)
print add5(6)
Problem: Write timeit decorator as a class.
class timeit:
....
@timeit
def timepass():
for i in range(10000):
for j in range(1000):
x = i*jUnderstanding Atributes
In [41]:
class Foo(object):
x = 1
foo = Foo()
In [42]:
foo.x = 1
foo.x
Out[42]:
In [46]:
getattr(foo, "x")
Out[46]:
In [47]:
class Attr:
def __getattr__(self, name):
return name.upper()
In [48]:
a = Attr()
a.x
Out[48]:
In [49]:
a.y
Out[49]:
In [50]:
a.foo
Out[50]:
In [51]:
getattr(a, "x")
Out[51]:
Old-Style vs. New-Style Classes
In [52]:
x = 1
type(x)
Out[52]:
In [53]:
type(int)
Out[53]:
In [54]:
class Foo: pass
In [55]:
type(Foo)
Out[55]:
In [56]:
type(file)
Out[56]:
In [57]:
class Foo(object): pass
type(Foo)
Out[57]:
In [58]:
class Foo(object):
def __len__(self): return 4
In [59]:
foo = Foo()
len(foo)
Out[59]:
In [60]:
foo.__len__ = lambda: 5
In [61]:
len(foo)
Out[61]:
In [62]:
class Bar:
def __len__(self): return 4
bar = Bar()
len(bar)
Out[62]:
In [63]:
bar.__len__ = lambda: 5
In [64]:
len(bar)
Out[64]:
In [68]:
class Bar:
x = 1
def getx(self): return self.x
bar = Bar()
print bar.getx()
In [69]:
# What does this mean? bar.getx()
# f = bar.getx
# f()
# What what does x[1]
Properties
In [87]:
class Person(object):
firstname = "Foo"
lastname = "Bar"
_phonenumber = "0"
@property
def fullname(self):
return self.firstname + " " + self.lastname
@property
def phone(self):
return self._phonenumber
@phone.setter
def phone(self, value):
if len(value) != 10:
raise ValueError("Invalid Phone number")
self._phonenumber = value
#phone = property(_get_phone, _set_phone)
p = Person()
print p.fullname
print p.phone
p.phone = "1234567890"
print p.phone
In [88]:
dir(Person)
Out[88]:
In [89]:
Person.phone
Out[89]:
In [90]:
p.phone
Out[90]:
In [91]:
p.firstname
Out[91]:
In [92]:
p.__dict__
Out[92]:
In [93]:
Person.__dict__
Out[93]:
In [95]:
Person.phone.__get__(p)
Out[95]:
Person.phone is a property object, but p.phone gives us a string value instead of a property.
In [99]:
class SimpleDescriptor(object):
def __get__(self, obj, type=None):
if obj is None:
return self
else:
return 1
class Foo:
x = SimpleDescriptor()
In [100]:
Foo.x
Out[100]:
In [101]:
foo = Foo()
foo.x
Out[101]:
Lets try to implement property class.
In [105]:
class my_property(object):
def __init__(self, getter):
self.getter = getter
def __get__(self, obj, type=None):
if obj is None:
return self
else:
return self.getter(obj)
class Person:
@my_property
def fullname(self):
print "fulname called"
return "Foo Bar"
p = Person()
print Person.fullname
print p.fullname
print p.fullname
In [111]:
class lazy_property(object):
def __init__(self, getter):
self.getter = getter
def __get__(self, obj, type=None):
if obj is None:
return self
value = self.getter(obj)
obj.__dict__[self.getter.__name__] = value
return value
class Person:
def __init__(self, first, last):
self.first = first
self.last = last
@lazy_property
def fullname(self):
print "fulname called"
return self.first + " " + self.last
p = Person("Foo", "Bar")
print Person.fullname
print p.__dict__
print p.fullname
print p.__dict__
print p.fullname
#p = Person("Foo", "Bar2")
#print p.fullname
__slots__
In [112]:
class Point(object):
def __init__(self, x, y):
self.x = x
self.y = y
In [113]:
p = Point(1, 2)
p.__dict__
Out[113]:
In [115]:
class Point2(object):
__slots__ = ["x", "y"]
def __init__(self, x, y):
self.x = x
self.y = y
p2 = Point2(1, 2)
In [116]:
p2.__dict__