1.運算符重載之反向運算

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

    def __add__(self, other):
        try:
            x = other.x
            return self.x + other.x
        except AttributeError:
            try:
                x = int(other)
            except:
                x = 0
            
 
return A(self.x + x)

    def __iadd__(self, other):
        print(self,‘iadd‘)
        return A(self.x + other.x)

    def __radd__(self, other):
        print(self,‘radd‘)
        return self.x + other.x
    def __repr__(self):
        return ‘{}‘.format(self.x)
#a + 1  ;;; 1+a
a = A(4)
b = A(5)
print
 
("-----------end----------------")
print((a+‘abc‘).x) # a.__add__(1) 1時int沒有self.x屬性 拋出異常

‘‘‘
1+a 等價於
1.__add__(a) int也實現了__add__方法 ,這個方法對這種的加法返回值時notimplement
解釋器發現這個值就會發起對第二個參數a的__radd__方法
‘‘‘
‘‘‘
__add__ 第一個try語句解決了 傳入的 1是int類型沒有x屬性報屬性異常，
第二個try 是解決傳入的字符串問題，如果傳人字符串設置x = 0 不拋出異常
‘‘‘

2.__slots__問題引出、

1.字典為提升查詢效率必須用空間換時間
2.一般來說一個對象，屬性多一i但，都存儲在字典中便於查詢
3.但是如果數百萬個對象，那麽字典占得就很大了
4.考慮把屬性字典__dict__省了
5.提供__slots__

__slots__告訴解釋器，實例的的屬性都叫什麽，一般來說既然節省內存，還是使用元祖比較好
一旦類提供了__slots__，就組織了實例產生__dict__來保存實例
也不可以動態增加屬性
不影響子類實例，不會繼承下去，除非子類也自己定義了__slots__

應用場景
使用構建在數百萬上的對象，且容量較為緊張，實例的屬性簡單，固定且不用增加動態場景

class A:
    x = 1
    __slots__ = (‘z‘,‘y‘)
    def __init__(self):
        self.y = 6
        self.z = 7

Python之__slots__ &運算符重載反向運算