class SaveVar:
    def __init__(self, avar):
	self.avar = avar
    def __enter__(self):
	print("__enter__ called")

class Circle:
    def __init__(self, radis):
	self.radis = radis

    @property
    def area(self):
	print("getting area")
	return self.radis*self.radis*3.14

p = Circle(4)
print(p.radis)
print(p.area)

super() # unbound
super(type, obj) # isinstance(obj, type)
super(type, type2) # issubclass(type2, type). issubclass(object, object) is True

class Integer:
    def __init__(self, name):
	self.name = name

    def __get__(self, instance, cls):
	print("__get__ method called, name: %s" % self.name)
	# If instance is None, then it is the class attribute
	if instance:
	    return instance.__dict__[self.name]
	else:
	    return instance

    def __set__(self, instance, value):
	print("__set__ method called, name %s, value: %s" % (self.name, value))
	instance.__dict__[self.name] = value

class Point:
    # 关键的是量的值，输入参数的值只是用于内部实现的。并且Integer的实现中使用instance.__dict__保存数据也只是一种实现方式。
    # Point.x决定了atribute的名称为x
    x = Integer('z')
    def __init__(self, x, y):
	self.x = x
	self.y = y

    def __str__(self):
	return '({0.x}, {0.y})'.format(self)


p = Point(3, 2)
print("p.x")
print(p.x)
print(p.__dict__)
# setattr(p, 'x', 5)
p.__dict__['x'] = 5
print(p.x)
print(p.__dict__)

# python  is very flexiable
class Structure:
    _fields = []
    def __init__(self, *args):
	if len(self._fields) != len(args):
	    raise TypeError('Expected {} arguments'.format(len(self._fields)))
	for k, v in zip(self._fields, args):
	    setattr(self, k, v)
    def __str__(self):
	return '({})'.format(', '.join('{}: {}'.format(f, getattr(self, f)) for f in self._fields))

class Point(Structure):
    _fields = ['x', 'y']
    # def __str__(self):
    #     return '(x: {0.x}, y: {0.y})'.format(self)

class Circle(Structure):
    _fields = ['radius']
    # def __str__(self):
    #     return '(radius: {0.radius})'.format(self)

p = Point(1, 2)
print(p)
p = Circle(3)
print(p)

class Foo:
    class_attr = "ABC"
    def __init__(self, a):
	self.a = a

f = Foo('BB')
print(f.class_attr, f.a)
print(f.class_attr is Foo.class_attr)

class Bar:
    class_attr = "ABC"
    def __init__(self, a):
	self.class_attr = a
	self.a = a

b = Bar('BB')
print(b.class_attr, b.a)
print(b.class_attr is Bar.class_attr)

class TraceDescriptor:
    def __init__(self, name):
	self.name = name

    def __get__(self, instance, cls):
	if instance:
	    print('Getting attribute {}, value is {}'.format(self.name, instance.__dict__[self.name]))
	    return instance.__dict__[self.name]
	    # return getattr(instance, self.name)
	else:
	    return instance


    def __set__(self, instance, value):
	print('Setting attribute {} to {}'.format(self.name, value))
	instance.__dict__[self.name] = value

class Circle:
    radius = TraceDescriptor('radius')
    def __init__(self,  radius):
	self.radius = radius

c =  Circle(4)

print(c.radius)

import time

class Date:
    def __init__(self, y, m,  d):
	self.year = y
	self.month = m
	self.day =  d

    @classmethod
    def today(cls):
	t = time.localtime()
	return cls(t.tm_year, t.tm_mon, t.tm_mday)

    def __str__(self):
	return '({0.year}, {0.month}, {0.day})'.format(self)

d1 = Date(2017, 1, 2)
d2 = Date.today()
print(d1, d2)

class A:
    def foo(self):
	print("A")
	print(super())
	super().foo()
class B:
    def foo(self):
	print("B")
	print(super())

class C(A, B):
    def foo(self):
	print("C")
	print(super())
	super().foo()

o = C()
o.foo()
print("MRO of C: ", C.__class__.__mro__)
print("MRO() of C: ", C.__class__.mro(C))

class Foo:
    def foo(self):
	print("foo")

f = Foo()
getattr(f, 'foo')()

class Foo:
    def foo(self, x, y):
	print("foo: {}, {}".format(x, y))

f = Foo()
import operator
operator.methodcaller('foo', 3, 4)(f)

class Visitor:
    def visit(self, node):
	methname = 'visit_' + type(node).__name__
	meth = getattr(self, methname, None)
	if meth is None:
	    meth = self.generic_visit
	return meth(node)

    def generic_visit(self, node):
	raise RuntimeError('No {} method'.format('visit_' + type(node).__name__))

class File:
    def __init__(self, name):
	self.name = name

class RegularFile(File):
    def read_content(self):
	return "This is the content for file {}".format(self.name)

class Directory(File):
    def children(self):
	'''Return all children names as a list'''
	return [RegularFile('a.txt'), RegularFile('b.exe')]

class Symbolic(File):
    def real(self):
	'''Return real file this symbolic point to'''
	return RegularFile('dd.txt')

class CatVisitor(Visitor):
    '''Implement cat command for a File object.'''
    def  visit_RegularFile(self, node):
	print('content for regular file {}'.format(node.name))
	print(node.read_content())
    def visit_Directory(self, node):
	print('content for directory {}'.format(node.name))
	for f in node.children():
	    self.visit(f)
    def visit_Symbolic(self, node):
	print('content for symbolic file {}'.format(node.name))
	self.visit(node.real())

files = [RegularFile('foo.txt'), Directory('bar'), RegularFile('a.txt'), Symbolic('aa.c')]
visitor = CatVisitor()
for file in files:
    visitor.visit(file)
    print()

class Dispatcher:
    def visit(self, node):
	methname = 'visit_' + type(node).__name__
	meth = getattr(self, methname, None)
	if meth is None:
	    meth = self.generic_visit
	return meth(node)

    def generic_visit(self, node):
	raise RuntimeError('No {} method'.format('visit_' + type(node).__name__))

class FooDispatcher(Dispatcher):
    def visit_RegularFile(self, node):
	pass
    def visit_Directory(self, node):
	pass

import weakref
class Node:
    pass
a = Node()
b = weakref.ref(a)
# c = a     # if this line exists, then a will not be deleted after 'del a', then the second call to b() will still return a

print(b())
del a
print(b())