5.1 继承内置不可变对象
python内置的tuple是不可变的，如果想一个tuple的子类，但是只接受int型和大于0的该如何实现。
class IntTuple(tuple):
def __new__(cls, iterable):
g = (x for x in iterable if isinstance(x, int) and x > 0)
return super(IntTuple, cls).__new__(cls, g)
def __init__(self, iterable):
super(IntTuple, self).__init__()
if __name__ == "__main__":
int_tuple = IntTuple([-1, 1, 3, [3, 4, 5], 8])
print(int_tuple)
(1, 3, 8)
需要注意的是，init方法是在new这个实例化方法之后执行，所以在init对传入的参数进行操作的时候其实也是不可改变的。只能在new方法中对传入的参数进行操作，创造一个包含对应条件的生成器，然后调用父类的new方法，此时传入的生成器就对应了init方法中的iterable。
5.2 节省内存方式创建实例
如果在某些场景下需要创建许多实例时，对内存的考量也是十分重要的。使用slots属性来声明类的所有属性能够有效地节省实例所占用的内存资源。
import sys
class User1:
def __init__(self, id, name, addr, sex):
self.id = id
self.name = name
self.addr = addr
self.sex = sex
class User2:
__slots__ = ['id', 'name', 'addr', 'sex']
def __init__(self, id, name, addr, sex):
self.id = id
self.name = name
self.addr = addr
self.sex = sex
if __name__ == "__main__":
user1 = User1(1, 'dai', "bj", 'male')
user2 = User2(2, 'blue', 'sy', 'male')
print(set(dir(user1)) - set(dir(user2)))
print(user1.__dict__)
print(sys.getsizeof(user1.__dict__))
print(sys.getsizeof(user2))
{'__dict__', '__weakref__'}
{'id': 1, 'name': 'dai', 'addr': 'bj', 'sex': 'male'}
192
72
两种方式创建类的实例，首先列出两个实例的属性差集，可以看出user1多出了dict属性，此属性是为了保存实例的属性进行的映射，可以方便动态增加、删改实例属性的。调用sys库的getsizeof可以查看对象的内存大小。可以看出光user1的dict的内存就占用了192的字节，而user2总共占用了72个字节，其内存占用的效率还是很明显的。
使用 slots还有另一点的考虑，能够禁止随意地更改实例的属性值，在很多第三方库中都对其有应用。
5.3 让对象支持上下文管理
像打开文件可以通过with语句来控制，这样的好处就是防止遗忘掉close方法释放资源，调用更加简便。如何使对象能够应用上with语句，这就涉及到让对象支持上下文的操作，其中关键要实现两个方法enter和exit
class Client:
def __init__(self):
print('init')
def start(self):
# raise Exception('Test')
print('start')
def stop(self):
print('stop')
def __enter__(self):
self.start()
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self.stop()
return
if __name__ == "__main__":
with Client() as client:
print('with')
init
start
with
stop
可以看出with语句最先执行的也是对象的init方法，然后执行enter所定义的方法，其中return的值就是with中as后面的值。最后在with中的方法执行结束之后，会执行对象中定义的exit方法，后面的参数是捕获的异常相关。在enter或者 exit方法内抛出异常，会直接向上抛出，结束掉with的语句。
5.4 可管理的对象属性
在java中，提倡对对象的属性设置、取值使用setter和getter方法，这样的好处是提高封装性，其他用户不可随意修改。在python中，有两种方式可以设置、取出属性，一种是传统的setter、getter方法，另一种是通过类.属性操作，能够实现这样的操作是因为在python中一切都是对象。可以看出第二种方式调用起来非常简便，但是存在很多其他问题，例如想要的属性是int，但是通过.操作设置的是str，对于程序来说不会报错，只是输出的结果不是想要的，这样会造成很多不必要的问题。
比较好的方法是通过使用property方法来简化操作并能很好保证其安全性。
class User:
def __init__(self):
self.id = None
def set_id(self, id):
if isinstance(id, int):
self.id = id
else:
raise Exception('Wrong type')
def get_id(self):
return self.id
ID = property(get_id, set_id)
if __name__ == "__main__":
user = User()
user.id = 1
print(user.id)
# user.set_id('123')
user.set_id(1)
print(user.ID)
user.ID = 2
print(user.ID)
1
1
2
可以看出将setter和getter方法作为property的参数，在外部调用时也可以通过.操作来访问，既能提供简单调用又能保证其安全性。
5.5 让类支持比较操作
如果让两个实例直接进行运算符操作，例如比较两个正方形的面积用>, <=等符合直接比较会更加简便，这就需要对象对操作符进行重载操作。
在python中，重载方法lt, gt, le, ge, eq, ne，其含义依次为X<Y，X>Y，X<=Y，X>=Y， X==Y，X!=Y
class Rectangle:
def __init__(self, w, h):
self.w = w
self.h = h
def area(self):
return self.w * self.h
def __lt__(self, other):
return self.area() < other.area()
def __eq__(self, other):
return self.area() == other.area()
if __name__ == "__main__":
rect1 = Rectangle(3, 4)
rect2 = Rectangle(4, 5)
print(rect1 > rect2)
还有另一种方法就是使用total_ordering装饰器来简化操作。
from functools import total_ordering
@total_ordering
class Rectangle:
def __init__(self, w, h):
self.w = w
self.h = h
def area(self):
return self.w * self.h
def __lt__(self, other):
return self.area() < other.area()
def __eq__(self, other):
return self.area() == other.area()
if __name__ == "__main__":
rect1 = Rectangle(3, 4)
rect2 = Rectangle(4, 5)
print(rect1 > rect2)
print(rect1 != rect2)
可以看到，并没有重载！=比较符，但是通过@total_ordering依然能够获取到对应得操作符，前提是已经有两个重载实现，它就会自动地进行其他比较符的实现。
5.6 使用描述符对属性类型进行检查
在java等静态语言中，数据的类型需要在使用之前声明，编译器会进行检查，但是对于python等动态语言来说，属性数据类型是可以不用提前声明的，这样可能会造成一定的误操作影响。
在python中可以通过实现get，set，delete方法，之后通过简单的操作符就可以有效地实现类似java中的效果。
class Attr:
def __init__(self, name, type_):
self.name = name
self.type_ = type_
def __get__(self, instance, owner):
return instance.__dict__[self.name]
def __set__(self, instance, value):
if not isinstance(value, self.type_):
raise TypeError("wrong type!")
instance.__dict__[self.name] = value
def __delete__(self, instance):
del instance.__dict__[self.name]
class User:
name = Attr("name", str)
age = Attr("age", int)
if __name__ == "__main__":
user = User()
user.name = 'blue'
print(user.name)
user.age = '11'
可以看出，赋值语句调用的是set可以在其中对值进行类型检查，取值语句调用的是get语句。这样，当赋值的数据类型不是所定义类型，就会抛出异常。
5.7 循环调用垃圾管理
python的垃圾回收机制是引用计数法，当引用计数为0时，触发gc操作。有些特殊情况类似两个对象循环引用彼此的方法、属性，此时引用计数是一直递增的，所以当想要回收掉这两个对象时，是无法自动触发gc的。
class Data:
def __init__(self, value, owner):
self.value = value
self.owner = owner
def __del__(self):
print('data del')
class Node:
def __init__(self, value):
self.value = Data(value, self)
def __del__(self):
print('node del')
if __name__ == "__main__":
node = Node(100)
input("wait...")
创建两个类，Data和Node，两者在init方法中分别调用彼此，在main方法中使用input方法，在输入回车后会进行停止操作，但是发现无法调用各自的del方法，因为彼此的引用计数一直是递增，所以无法触发gc。
在此情况下，需要创建一种能访问对象但是不增加引用计数的对象，通过使用weakref弱引用库来解决此问题。
import weakref
class Data:
def __init__(self, value, owner):
self.value = value
self.owner = weakref.ref(owner)
def __del__(self):
print('data del')
def __str__(self):
print(self.owner())
class Node:
def __init__(self, value):
self.value = Data(value, self)
def __del__(self):
print('node del')
if __name__ == "__main__":
node = Node(100)
input("wait...")
wait...
node del
data del
可以看出，在对对象进行引用操作时，通过弱引用方式weakref.ref，然后在对其属性进行操作时使用类似方法调用。此时，输入回车就能正常进行gc操作了。
5.8 通过字符串调用函数
在python中可以通过方法名的字符串来调用此方法，所利用的是operator库的methodcaller。
from operator import methodcaller
s = "adb123qwer456"
print(s.find('q', 3))
print(methodcaller('find', 'q', 3)(s))
6
6
在methodcaller中的第一个参数就是想要调用函数的字符串格式，接下来的参数是需要调用函数的参数，之后对methodcaller调用参数传入想要调用函数的实例对象。
