# 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
1 1 1 1 1 2 3 3 2
# 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()
1 2 2
# problem 7
x = 1
class Foo:
a = x
x = 2
print a, x
print x
1 2 1
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.elapsed
Ducktyping
%%file numbers.txt
one
two
three
four
five
Writing numbers.txt
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)
(5, 5, 23) (3, 3, 14) (0, 0, 0)
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.
from StringIO import StringIO
f = StringIO()
f.write("hello\nworld\n")
f.seek(0)
print f.read()
f.seek(0)
print wordcount(f)
hello world (2, 2, 12)
x = 1
print x
1
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
(2, 3)
print repr(1)
1
print repr("hello")
'hello'
print "hello"
hello
[1, 2, "3, 4"]
[1, 2, '3, 4']
print p
(2, 3)
print [p]
[<__main__.Point instance at 0x101fa2f38>]
print repr(p)
<__main__.Point instance at 0x101fa2f38>
We need to implement __repr__
to fix that.
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]
(2, 3) [Point(2, 3), 'hello', (2, 3), 5]
# Do you know what happens when you do this?
x = [1, 2, 3, 4]
print x[1]
2
x.__getitem__(1)
2
x = xrange(2, 8)
print len(x)
print x[3]
6 5
x.__len__()
6
Lets write a class yrange
that behaves like built-in class xrange
.
Node
class¶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]
6 5
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
## Command library using classes
%%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")
Overwriting command1.py
%%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:])
Writing uppercase1.py
!python uppercase1.py 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:])
%%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:])
Writing grep2.py
!python grep2.py def grep2.py
def __init__(self, pattern): def process_line(self, line):
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.py
Lets try to improve the Command
class to handle to make it more generic.
%%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"])
Writing command2.py
!python command2.py
20 47 544 command1.py 29 68 808 command2.py
class Foo:
x = 1
def getx(self):
return self.x
foo = Foo()
print foo.getx()
print Foo.getx(foo)
1 1
Foo.getx
<unbound method Foo.getx>
foo.getx
<bound method Foo.getx of <__main__.Foo instance at 0x101f9f3f8>>
def add(x, y):
return x+y
def make_adder(x):
def adder(y):
return add(x, y)
return adder
add5 = make_adder(5)
print add5(6)
11
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()
1
class Foo:
x = 1
def getx(self):
return self.x
foo = Foo()
Foo
__main__.Foo
dir(Foo)
['__doc__', '__module__', 'getx', 'x']
Foo.__dict__
{'__doc__': None, '__module__': '__main__', 'getx': <function __main__.getx>, 'x': 1}
Foo.__dict__['x'] = 2
Foo.x
2
Foo.__dict__['y'] = 3
Foo.y
3
# Lets try to find how add5 is storing value of x
dir(add5)
['__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__doc__', '__format__', '__get__', '__getattribute__', '__globals__', '__hash__', '__init__', '__module__', '__name__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'func_closure', 'func_code', 'func_defaults', 'func_dict', 'func_doc', 'func_globals', 'func_name']
def inc(x, amount=1): return x+amount
inc.func_defaults
(1,)
x = 1 # what does this mean?
g = globals()
g['x']
1
g['x'] = 2
x
2
def add(x, y): return x+y
add(5, 4)
9
d = [1, 2, 3]
d[2]
3
Foo
__main__.Foo
Foo()
<__main__.Foo instance at 0x102f49050>
class Adder:
def __init__(self, x):
self.x = x
def __call__(self, y):
return add(self.x, y)
add5 = Adder(5)
print add5(6)
11
Problem: Write timeit
decorator as a class.
class timeit:
....
@timeit
def timepass():
for i in range(10000):
for j in range(1000):
x = i*j
class Foo(object):
x = 1
foo = Foo()
foo.x = 1
foo.x
1
getattr(foo, "x")
1
class Attr:
def __getattr__(self, name):
return name.upper()
a = Attr()
a.x
'X'
a.y
'Y'
a.foo
'FOO'
getattr(a, "x")
'X'
x = 1
type(x)
int
type(int)
type
class Foo: pass
type(Foo)
classobj
type(file)
type
class Foo(object): pass
type(Foo)
type
class Foo(object):
def __len__(self): return 4
foo = Foo()
len(foo)
4
foo.__len__ = lambda: 5
len(foo)
4
class Bar:
def __len__(self): return 4
bar = Bar()
len(bar)
4
bar.__len__ = lambda: 5
len(bar)
5
class Bar:
x = 1
def getx(self): return self.x
bar = Bar()
print bar.getx()
1
# What does this mean? bar.getx()
# f = bar.getx
# f()
# What what does x[1]
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
Foo Bar 0 1234567890
dir(Person)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_phonenumber', 'firstname', 'fullname', 'lastname', 'phone']
Person.phone
<property at 0x102f5dcb0>
p.phone
'1234567890'
p.firstname
'Foo'
p.__dict__
{'_phonenumber': '1234567890'}
Person.__dict__
<dictproxy {'__dict__': <attribute '__dict__' of 'Person' objects>, '__doc__': None, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'Person' objects>, '_phonenumber': '0', 'firstname': 'Foo', 'fullname': <property at 0x102f5de10>, 'lastname': 'Bar', 'phone': <property at 0x102f5dcb0>}>
Person.phone.__get__(p)
'1234567890'
Person.phone is a property object, but p.phone gives us a string value instead of a property.
class SimpleDescriptor(object):
def __get__(self, obj, type=None):
if obj is None:
return self
else:
return 1
class Foo:
x = SimpleDescriptor()
Foo.x
<__main__.SimpleDescriptor at 0x102f5c2d0>
foo = Foo()
foo.x
1
Lets try to implement property class.
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
<__main__.my_property object at 0x102f67490> fulname called Foo Bar fulname called Foo Bar
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
<__main__.lazy_property object at 0x102f7c1d0> {'last': 'Bar', 'first': 'Foo'} fulname called Foo Bar {'fullname': 'Foo Bar', 'last': 'Bar', 'first': 'Foo'} Foo Bar
__slots__
¶class Point(object):
def __init__(self, x, y):
self.x = x
self.y = y
p = Point(1, 2)
p.__dict__
{'x': 1, 'y': 2}
class Point2(object):
__slots__ = ["x", "y"]
def __init__(self, x, y):
self.x = x
self.y = y
p2 = Point2(1, 2)
p2.__dict__
--------------------------------------------------------------------------- AttributeError Traceback (most recent call last) <ipython-input-116-6207db46af2a> in <module>() ----> 1 p2.__dict__ AttributeError: 'Point2' object has no attribute '__dict__'