class Property(object):
	"Emulate PyProperty_Type() in Objects/descrobject.c"

	def __init__(self, fget=None, fset=None, fdel=None, doc=None):
		self.fget = fget
		self.fset = fset
		self.fdel = fdel
		if doc is None and fget is not None:
			doc = fget.__doc__
		self.__doc__ = doc

	def __get__(self, obj, objtype=None):
		if obj is None:
			return self
		if self.fget is None:
			raise AttributeError("unreadable attribute")
		return self.fget(obj)

	def __set__(self, obj, value):
		if self.fset is None:
			raise AttributeError("can't set attribute")
		self.fset(obj, value)

	def __delete__(self, obj):
		if self.fdel is None:
			raise AttributeError("can't delete attribute")
		self.fdel(obj)

	def getter(self, fget):
		return type(self)(fget, self.fset, self.fdel, self.__doc__)
		# 返回描述器，可省略

	def setter(self, fset):
		return type(self)(self.fget, fset, self.fdel, self.__doc__)
		# 返回更新`fset`的描述器，同名所以覆盖前者

	def deleter(self, fdel):
		return type(self)(self.fget, self.fset, fdel, self.__doc__)

class Student(object):

	def __init__(self, value):
		self.birth = value
			# 使用`self.birth`而不是`self._birth`，保证即使
				# 实在初始化时仍然进行参数检查

	@property
		# 将一个getter-like方法变为属性
		# `@property`同时会创建装饰器`@method.setter`
	def birth(self):
		return self._birth

	@birth.setter
		# `@property`对应，将setter-like方法变为属性
	def birth(self, value):
		if not instance(value, int):
			raise ValueError("birth must be an integer")
		if value < 1900 or value > 2020:
			raise ValueError("birth must between 1900 ~ 2020")
		self._birth = value

	@birth.deleter
		# 同`@property`对应，在`del`时调用
	def birth(self):
		del(self._age)
		del(self._birth)

	@property
		# 只设置`@property`而没有设置对应`@birth.setter`
		# 这样`birth`就成了只读属性
	def age(self):
		return 2018 - self._birth

	def get_first_name(self):
		return self._first_name
	
	def set_first_name(self):
		if not instance(value, str):
			raise TypeError("expected a string")
		self._first_name = value

	def del_first_name(self):
		raise AttributeError("can't delete attribute")

	name = property(get_first_name,
		set_first_name,
		del_first_name)
		# 在已有getter-like、setter-like方法上创建property
		# 注意：这里就是应该定义类属性，本身使用`@property`
			# 装饰器也是相当于创建类属性

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

	@property
	def name(self):
		return self._name

	@name.setter
	def name(self, value):
		if not instance(value, str):
			raise TypeError("expected a string")
		self._name = value

	@name.deleter
	def name(self):
		raise AttributeError("can't delete attribute")

class SubPersonAll(Person):
	# 这个类继承、扩展了`name`属性的所有功能
	@property
	def name(self):
		print("getting name")
		return super().name

	@name.setter
	def name(self, value):
		print("Setting name to", value)
		super(SubPerson, SubPerson).name.__set__(self, value)
			# 使用`super(SubPerson, SubPerson)`调用父类实现
			# 将控制权传递给`.name.__set__`方法，委托给父类
				# 中定义的setter方法

	@name.deleter
	def name(self):
		print("deleting name")
		super(SubPerson, SubPerson).name.__delete__(self)

class SubPersonPart(Person):
	# 仅修改`name`属性的某个方法
	# 需要知道定义`name`属性的基类，否则重新定义property属性
		# 的所有方法，并使用`super`将控制权转移给父类
	@Person.name.getter
		# 使用硬编码的`Person`类名，这样会把之前已经定义的
			# property属性方法复制过来，而对应的`getter`、
			# `setter`、`deleter`方法被替换
		# 这里如果直接使用`@property`装饰，那么`setter`、
			# `deleter`方法将会消失
	def name(self):
		print("getting name")
		return super().name

class super:
	super()
		# 等同于：`super(__class__, <first_argument>)`
		# `<first_argument>`常常就是`self`
	super(type)
		# 返回：未绑定super对象，需要`__get__`绑定
	super(type, obj)
		# 返回：已绑定super对象，要求`isinstance(obj,type)`
	super(type, type2)
		# 返回：已绑定super对象，要求`issubclass(type2, type)`
		# 此时调用方法返回是函数，不是绑定方法，不会默认传入
			# `type2`作为首个参数

	def __get__(self, obj, type=None):
		

def super(cls, inst/subcls):
    mro = inst.__class__.mro()
	mro = subcls.mro()
    return mro[mro.index(cls) + 1]

class LoggedMappingMixin:
	__slots__ = ()
	def __getitem__(self, key):
		print("getting:", str(key))
		return super9).__getimte__(key)

	def __setitem__(self, key, value):
		print("setting {} = {!r}".format(key, value))
		return super().__setitem__(key, value)

	def __delitem__(self, key):
		print("deleting", str(key))
		return super().__delitem__(key)

class SetOnceMappingMixin:
	__slots__ = ()
	def __setitem__(self, key, value):
		if key in self:
			raise KeyError(str(key), "alreay set")
		return super().__setitem__(key, value)

class StringKeysMappingMixin:
	__slots__ = ()
	def __setitem__(self, key, value):
		if not isinstance(key, str):
			raise TypeError("keys must be strings")
		return super().__setitem__(key, value)

	# 单独的Mixin类使用没有意义，也无法实例化

class LoggedDict(LoggedMappingMixin, dict):
	# 把混入类和其他已存在的类结合起来使用
	pass

from collections import defaultdict

class SetOnceDefaultDict(SetOnceMappingMixin, defaultdict):
	pass

def test():
	d = LoggedDict()
	d["x"] = 23
	print(d["x"])
	del d["x"]

	d = setOnceDefaultDict(list)
	d["x"].append(2)

class lazyproperty:
	def __init__(self, func):
		self.func = func

	def __get__(self, instance, cls):
		if instance is None:
			return self
		else:
			value = self.func(instance)
			setattr(instance, self.func.__name__, value)
			# 计算完成之后，缓存计算结果于类实例中
			return value
	# 描述器仅仅定义一个`__get__`方法，比通常具有更弱的绑定
	# 这里，只有被访问属性不在**实例**底层字典`__dict__`中时
		# `__get__`方法才会被触发
	# 描述器属性是类属性，但优先级好像是高于实例属性？？？

def lazyproperty_unchangable(func):
	# 这个版本的延迟计算，使用property属性限制对结果的修改
	name = "_lazy_" + func.__name __

	@property
		# 这里`@property`是在类外定义的
		# 并且，这里实际上返回的是`property`类实例，也不需要
			# `wraps(func)`保持原函数元信息
		# 但此时所有的操作都定向到`getter`函数上，效率较低
	def lazy(self):
		if hasattr(self, name):
			return getattr(self, name)
		else:
			value = func(self)
			setattr(self, name, value)
			return value
	return lazy

import math

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

	@lazyproperty
	def area(self):
		print("computing area")
		return math.pi * self.radius ** 2
	# 等价于`area = lazyproperty(area)`
	# 所以是真的把描述器类实例作为类属性

	@lazyproperty
	def perimeter(self):
		print("computing perimeter")
		return 2 * math.pi * self.radius

class Descriptor:
	def __init__(self, name=None, **opts):
		self.name = name
		for key, value in opts.items()
			setattr(self, key, value)

	def __set__(self, instance, value):
		if instance is None:
			return self
		instance.__dict__[self.name] = value

class Typed(Descriptor):
	def __set__(self, instance, value):
		if value < 0:
			raise ValueError("expected >= 0")
		super().__set__(instance, value)

class Unsigned(Descriptor):
	def __set__(self, instance, value):
		if value < 0:
			raise ValueError("expect >= 0")
		super().__set__(instance, value)

class MaxSized(Descriptor):
	def __init__(self, name=None, **opts):
		if "size" not in opts:
			raise TypeError("missing size options")
		super.__init__(name, **opts)

	def __set__(self, instance, value):
		if len(value) >= self.size:
			raise ValueError("size must be <" + str(self.size))
		super().__set__(instance, value)

class Integer(Typed):
	expected_type = int

class UsignedInteger(Integer, Unsigned):
	# 描述器类是基于混入实现的
	pass

class Float(Typed):
	expected_type = Float

class UnsignedFloat(Float, Unsigned):
	pass

class String(Typed):
	expected_type = str

class SizedString(String, MaxSized):
	pass

class Stock:
	name = SizedString("name", size=8)
	shares = UnsignedInteger("shares")
	price = UnsignedFloat("price")

	def __init__(self, name, shares, price):
		self.name = name
		self.shares = shares
		self.price = price

def check_attributes(**kwargs):
	def decrator(cls):
		for key, value in kwargs.items():
			if isinstance(value, Descriptor):
				value.name = key
				setattr(cls, key, value)
			else:
				setattr(cls, key, value(key))
		return cls
	return decrator

@check_attributes(name=SizedString(size=8),
	shares=UnsignedInteger,
	price=UnsignedFloat)
	# 使用类装饰器简化版本
class Stock2:
	def __init__(self, name, shares, price):
		self.name = name
		self.shares = shares
		self.price = price

class checkmeta(type):
	def __new__(cls, clsname, bases, methods):
		for key, value in method.items():
			if isinstance(value, Descriptor):
				value.name = key
		return type.__new__(cls, clsname, bases, methods)

class Stock3(metaclass=checkdmeta):
	name = SizedString(size=8)
	shares = UnsignedInteger()
	price = UnsignedFloat()

	def __init__(self, name, shares, price):
		self.name = name
		self.shares = shares
		self.price = price

def LoggedMapping(cls):
	cls_getitem = cls.__getitem__
	cls_setitem = cls.__setitem__
	cls_delitem = cls.__setitem__
		# 获取原`cls`的方法，避免死循环调用

	def __getitem__(self, key):
		print("getting", str(key))
		return cls_getitem(self, key)
			# 这里使用之前获取的方法指针调用，而不直接使用
				# `cls.__getitem__`避免死循环

	def __setitem__(self, key, value):
		pritn("setting {} = {!r}", str(key))
		return cls_set(self, key, value)

	def __delitem__(self, key):
		print("deleting", str(key))
		return cls_delitem(self, key)

	cls.__getitem__ = __getitem__
	cls.__setitem__ = __setitem__
	cls.__delitem__ = __delitem__

	return cls

@LoggedMapping
class LoggedDict(dict):
	pass

def Type(expected_type, cls=None):
	if cls is None:
		return lambda cls: Typerd(expected_type, cls)
	super_set = cls.__set__

	def __set__(self, instance, value):
		if no instance(value, expected_type):
			raise TypeError("expect " + str(expected_type))
		super_set(self, instance, value)

	cls.__set__ = __set__
	return cls

def Unsigned(cls):
	super_set = cls.__set__

	def __set__(self, instance, value):
		if value < 0:
			raise TypeError("missing size option")
		super_set(self, name, **opts)

	cls.__init__ = __set__
	return cls

def MaxSized(cls):
	super_init = cls.__init__

	def __init__(self, name=None, **opts):
		if "size" not in opts:
			raise TypeError("missing size option")
		super_init(self, name, **opts)

	cls.__init__ = __init__

	super_set = cls.__set__

	def __set__(self, instance, value):
		if len(value) >= self.size:
			raise ValueError("size must be <" + str(self.size))
		super_set(self, instance, value)

	cls.__set__ = __set__
	return cls

@Typed(int)
class Integer(Descriptor):
	pass

@Unsigned
class UnsignedInteger(Integer):
	pass

@Typed(float)
class Float(Descriptor):
	pass

@Unsigned
class UnsignedFloat(Float):
	pass

@Typed(str)
class String(Descriptor):
	pass

@MaxSized
class SizedString(String):
	pass

from collections import Sequence
import collections

class SortedItems(Sequence):
	# 必须要实现所有抽象方法，否则报错
	def __init__(self, initial=None):
		self._items = sorted(initial) if initial is not None else [ ]
	def __getitem__(self, index):
		return self._items[index]

	def __len__(self):
		return len(self._items)

	def add(self, item):
		bisect.insort(self._items, item)
			# `bisect`模块是用于在排序列表中高效插入元素
			# 保证在元素插入之后仍然保持顺序

	# `SortedItems`继承了`colllections.Sequence`，现在和
	# 普通序列无差，支持常用操作：索引、迭代、包含判断、切片

def test():
	items = SortedItems([5, 1, 3])
	print(list(items))
	print(items[0], items[-1])
	items.add(2)
	print(list(items))

	if instance(items, collections.Iterable):
		pass
	if instance(items, collections.Sequence):
		pass
	if instance(items, collections.Container):
		pass
	if instance(items, collections.Sized):
		pass
	if instance(items, collections.Mapping):
		pass

from collections import MutableSequence

class Item(collections.MutableSequence):
	def __init__(self, initial=None):
		self._items = list(initial) if initial is not None else [ ]

	def __getitem__(self, index):
		print("getting:", index)
		return self._items[index]

	def __setitem__(self, index):
		print("setting:", index)
		self._items[index] = value

	def __delitem__(self, index):
		print("deleting:", index)
		del self._items[index]

	def insert(self, index, value):
		print("inserting:", index, value)
		self._items.insert(index, value)

	def __len__(self):
		print("len")
		return len(self._items)

	# 基本支持几乎所有的核心列表方法：`append`、`remove`、
		# `count`

def count():
	a = Items([1, 2, 3])
	print(len(a))
	a.append(4)
		# 在末尾添加元素
		# 调用了`__len__`、`insert`方法
	a.count(2)
		# 统计值为`2`出现的次数
		# 调用`__getitem__`方法
	a.remove(3)
		# 删除值为`3`的元素
		# 调用`__getitem__`、`__delitem__`方法

class Proxy:
	# 这个类用于包装、代理其他类，修改其行为
	def __init__(self, obj):
		self._obj = obj

	def __getattr__(self, name):
		print("getattr:", name)
		return getattr(self._obj, name)

	def __setattr__(self, name, value):
		if name.startwith("_"):
			# 约定只代理不以`_`开头的属性
			# 代理类只暴露被代理类的公共属性
			super().__setattr__(name, value)
		else:
			print("setattr:", name, value)
			setattr(self._obj, name, value)

	def __delattr__(self, name):
		if name.startwith("_"):
			super().__delattr__("name")
		else:
			print("delattr:", name)
			delattr(self._obj, name)

class Spam:
	def __init__(self, x):
		self.x = x

	def bar(self, x):
		print("Spam.bar", self.x, y)

def test():
	s = Spam(2)
	p = Proxy(s)
	p.bar(3)
	p.x = 37
		# 通过`p`代理`s`

	p = Porxy([1, 3, 5])
	# len(p)
		# `len`函数直接使用会报错
	p.__len__()
		# `p.__len__`可以正常代理，返回代理的列表长度
		# 这说明python中的钩子函数有特殊的结构？

class Connection:
	def __init__(self):
		self.new_state(ClosedConnectionState)

	def new_state(self, newstate):
		self._state = newstate

	def read(self):
		return self._state.read(self)

	def write(self, data):
		return self._state.write(self, data)

	def open(self):
		return self._state.close(self)

class ConnectionState:
	@staticmethod
	def read(conn):
		raise NotImplementedError()

	@staticmethod
	def write(conn, data):
		raise NotImplementedError()

	@staticmethod
	def open(conn):
		raise NotImplementedError()

	@staticmethod
	def close(conn):
		raise NotImplementedError()

class ClosedConnectionState(ConnectionState):
	@staticmethod
	def read(conn):
		raise RuntimeError("not open")

	@staticmethod
	def write(conn):
		raise RuntimeError("not open")

	@staticmethod
	def open(conn):
		conn.new_state(OpenConnectionState)

	@staticmethod
	def close(conn):
		raise RuntimeError("already closed")

calss OpenConnectionState(ConnectionState):
	@staicmethod
	def read(conn):
		print("reading")

	@staticmethod
	def write(conn, data):
		print("writing", data)

	@staticmethod
	def open(conn):
		raise RuntimeError("already open")

	@staticmethod
	def close(conn):
		conn.new_state(ClosedConnectionState)

def test():
	c = Connection()
	c.open()
	c.read()
	c.write("hello")
	c.close()

class Node:
	pass

class UnaryOperator(Node):
	def __init__(self, operand):
		self.operand =operand

class BinaryOperator(Node):
	def __init__(self, left, right):
		self.left = left
		self.right = right

class Add(BinaryOperator):
	pass

class Sub(BinaryOperator):
	pass

class Mul(BinaryOperator):
	pass

class Div(BinaryOperator):
	pass

class Nagate(UnaryOperator):
	pass

class Number(Node):
	def __init__(self, value):
		self.value = value

class NodeVsistor:
	def visit(self, node):
		methname = "visit_" + type(node).__name__
		meth = getattr(self, methname, None)
			# 使用`getattr`获取相应方法，避免大量`switch`
			# 子类需要实现`visit_Node`一系列方法
		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 Evaluator(NodeVisitor):
	def visit_Number(self, node):
		return node.value

	def visit_Add(self, node):
		return self.visit(node.left) + self.visit(node.right)
		# 递归调用`visit`计算结果
		# 因此可能超过python递归嵌套层级限制而失败

	def visit_Sub(self, node):
		return self.visit(node.left) - self.visit(node.right)

	def visit_Mul(self, node):
		return self.visit(node.left) * self.visit(node.right)

	def visit_Div(self, node):
		return self.visit(node.left) / self.visit(node.right)

	def visit_Negate(self, node):
		return -node.operand

def test():
	t1 = Sub(Number(3), Number(4))
	t2 = Mul(Number(2), t1)
	t3 = Div(t2, Number(5))
	t4 = Add(Number(1), t3)

	e = Evaluator()
	e.visit(t4)

import types

class NodeVisitor:
	def visit(self, node):
		stack = [node]
		last_result = None
		while stack:
			try:
				last = stack[-1]
				if isinstance(last, types.GeneratorType):
					# 对`yield`实现
					stack.append(last.send(last_result))
					last_result = None
				elif isinstance(last, Node):
					# 对递归实现
					stack.append(self._visit(stack.pop()))
				else:
					last_result = stack.pop()
			except StopIteration:
				stack.pop()
		return last_result

	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 Evaluator(NodeVisitor):
	# `yield`版本不会多次递归，可以接受更多层级
	def visit_Number(self, node):
		return node.value

	def visit_Add(self, node):
		yield (yield node.left) + (yield node.right)
		# 遇到`yield`，生成器返回一个数据并暂时挂起

	def visit_Sub(self, node):
		yield (yield node.left) + (yield node.right)

	def visit_Mul(self, node):
		yield (yield node.left) * (yield node.right)

	def visit_Div(self, node):
		yield (yield node.left) * (yield node.right)

	def visit_Nagate(self, node):
		yield - (yield node.operand)

import math
from operator import methodcaller

class Point:
	def __init__(self, x, y):
		self.x = x
		self.y = y

	def __repr__(self):
		return "Point({!r}, {!r})".format(self.x, self.y)

	def distance(self, x, y):
		return math.hypot(self.x -x, self.y - y)

def test():
	points = [
		Point(1, 2),
		Point(3, 0),
		Point(10, -3),
		Point(-5, -7)
	]

	points.sort(key=methodcaller("distance', 0, 0))
		# `methodcaller`创建可调用对象，并提供所有必要参数

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

import weakref
_spam_cache = weakref.WeakValueDictionary()
	# `WeakValueDictionary`实例只保存在其他地方还被使用的
		# 实例，否则从字典移除

def get_spam(name):
	# 使用工厂函数修改实例创建行为
	if name not in _spam_cache:
		s = Spam(name)
		_spam_cache[name] = s
	else:
		s = _spam_cache[name]
	return s

def test():
	a = get_spam("foo")
	b = get_spam("foo")
	print(a is b)

import weakref

class CachedSpamManager:
	def __init__(self):
		self._cache = weakref.WeakValueDictionary()

	def get_spam(self, name):
		if name not in self._cache:
			s = Spam(name)
			self._cache[name] = s
		else:
			s = self._cache[name]
		return s

	def clear(self):
		self._cache.clear()

class Spam:
	manager = CacheSpamManager()
	def __init__(self, *args, **kwargs):
		# `__init__`方法抛出异常，防止用户直接初始化
		# 也可以将类名加上`_`，提醒用户不要实例化
		raise RuntimeError("can't instantiate directly")

	@classmethod
	def _new(cls, name):
		self = cls.__new__(cls)
		self.name = name
		return self

import weakref

clas Spam:
	_spam_cache = weakref.WeakValueDictionary()

	def __new__(cls, name):
		if name in cls._spam_cache:
			return cls._spam_cache[name]
		else:
			self = super().__new__(cls)
			cls._spam_cache[name] = self
			return self

	def __init__(self, name):
		print("initializing Spam")
		self.name = name
	# 这种方式实际会多次调用`__init__`方法，即使已经结果已经
		# 缓存，不是个好方法