课题笔记：
例子：
>>> class int(int): def __add__(self, other): return int.__sub__(self, other) >>> a = int('5') >>> a 5 >>> b = int('3') >>> a + b 2 >>>
反运算魔方方法，与算术运算符保持一一对应，不同之处就是反运算的魔法方法多了一个“r”。Python学习：反运算 来自：南淮北安，链接：https://blog.csdn.net/nanhuaibeian/article/details/86687806
>>> class Nint(int): def __radd__(self, other): return int.__sub__(self, other) >>> a = Nint(5) >>> b = Nint(3) >>> a + b 8 >>> 1 + b # 这边self = b， other是1， 所以返回了b - 1 2 >>> #注意这里1 和 b 两个类型不一样！
解释：反运算在运算符左右类型不同，且左边没用相应运算方法时被调用。官方文档：右操作数为左操作数的子类时，优先调用子类的反运算方法。
在举个反例：
>>> class Nint(int): def __rsub__(self, other): return int.__sub__(self, other) >>> a = Nint(5) >>> 3 - a 2
这里3没有sub，所以去找a的rsub，__rsub__(self, other)这里self是a，other是3；调用sub就变成了a - 3了，所以要实现3 - a的话要在sub括号里对调两个参数。
找不到a的方法是因为a后面没有运算符。
增量运算符
a = a + b就是 a += b
一元操作符
-a，取相反数的意思
~a，按位取反
测试题：
0. 对象相加（a + b），如果 a 对象有 __add__ 方法，请问 b 对象的 __radd__ 会被调用吗？
不会，实验如下：
>>> class Nint(int): def __radd__(self, other): print("__radd__ 被调用了！") return int.__add__(self, other) >>> a = Nint(5) >>> b = Nint(3) >>> a + b 8 >>> 1 + b __radd__ 被调用了！ 4
1. Python 什么时候会调用到反运算的魔法方法？
当右边找不到相应方法的时候。
答：例如 a + b，如果 a 对象的 __add__ 方法没有实现或者不支持相应的操作，那么 Python 就会自动调用 b 的 __radd__ 方法。
2. 请问如何在继承的类中调用基类的方法？
基类.__XX__（），就是调用基类的魔法方法
答：使用 super() 这个 BIF 函数。
class Derived(Base): def meth (self): super(Derived, self).meth()
3. 如果我要继承的基类是动态的（有时候是 A，有时候是 B），我应该如何部署我的代码，以便基类可以随意改变。
基类用一个变量代替吗？
答：你可以先为基类定义一个别名，在类定义的时候，使用别名代替你要继承的基类。如此，当你想要改变基类的时候，只需要修改给别名赋值的那个语句即可。顺便说一下，当你的资源是视情况而定的时候，这个小技巧很管用。
例子：
BaseAlias = BaseClass # 为基类取别名 class Derived(BaseAlias): def meth(self): BaseAlias.meth(self) # 通过别名访问基类 ...
4. 尝试自己举一个例子说明如何使用类的静态属性。（一定要自己先动手再看答案哦^_^）
类.XX属性，调用吧
答：类的静态属性很简单，在类中直接定义的变量（没有 self.）就是静态属性。引用类的静态属性使用”类名.属性名”的形式。
类的静态属性应用（计算该类被实例化的次数）：
class C: count = 0 # 静态属性 def __init__(self): C.count = C.count + 1 # 类名.属性名的形式引用 def getCount(self): return C.count
5. 尝试自己举例说明如何使用类的静态方法，并指出使用类的静态方法有何有点和需要注意的地方？（一定要自己先动手再看答案哦^_^）
类的属性名和类的方法名要注意不能同名。
答：静态方法是类的特殊方法，静态方法只需要在普通方法的前边加上 @staticmethod 修饰符即可。
class C: @staticmethod # 该修饰符表示 static() 是静态方法 def static(arg1, arg2, arg3): print(arg1, arg2, arg3, arg1 + arg2 + arg3) def nostatic(self): print("I'm the f**king normal method!")
静态方法最大的优点是：不会绑定到实例对象上，换而言之就是节省开销。
>>> c1 = C() >>> c2 = C() # 静态方法只在内存中生成一个，节省开销 >>> c1.static is C.static True >>> c1.nostatic is C.nostatic False >>> c1.static <function C.static at 0x03001420> >>> c2.static <function C.static at 0x03001420> >>> C.static <function C.static at 0x03001420> # 普通方法每个实例对象都拥有独立的一个，开销较大 >>> c1.nostatic <bound method C.nostatic of <__main__.C object at 0x03010590>> >>> c2.nostatic <bound method C.nostatic of <__main__.C object at 0x032809D0>> >>> C.nostatic <function C.nostatic at 0x0328D2B8>
使用的时候需要注意的地方：静态方法并不需要 self 参数，因此即使是使用对象去访问，self 参数也不会传进去。
>>> c1.static(1, 2, 3) 1 2 3 6 >>> C.static(1, 2, 3) 1 2 3 6
动动手：
0. 定义一个类，当实例化该类的时候，自动判断传入了多少个参数，并显示出来：
>>> c = C() 并没有传入参数 >>> c = C(1, 2, 3) 传入了 3 个参数，分别是：1 2 3
答：其实很容易啦，检查下大家之前的知识点有没有记牢固而已。
class C: def __init__(self, *args): #定义了一个可变参数 if not args: print("并没有传入参数") else: print("传入了 %d 个参数，分别是：" % len(args), end='') for each in args: print(each, end=' ')
1. 定义一个单词（Word）类继承自字符串，重写比较操作符（参考自学：Python 魔法方法详解），当两个 Word 类对象进行比较时，根据单词的长度来进行比较大小。
加分要求：实例化时如果传入的是带空格的字符串，则取第一个空格前的单词作为参数。
答：加分要求可以通过重载 __new__ 方法来实现（因为字符串是不可变类型），通过重写 __gt__、__lt__、__ge__、__le__ 方法来定义 Word 类在比较操作中的表现。注意，我们没有定义 __eq__ 和 __ne__ 方法。这是因为将会产生一些怪异不符合逻辑的结果（比如 Word('FishC') 会等于 Word('Apple')）
代码清单：
class Word(str): '''存储单词的类，定义比较单词的几种方法''' def __new__(cls, word): # 注意我们必须要用到 __new__ 方法，因为 str 是不可变类型 # 所以我们必须在创建的时候将它初始化 if ' ' in word: print "Value contains spaces. Truncating to first space." word = word[:word.index(' ')] #单词是第一个空格之前的所有字符 return str.__new__(cls, word) def __gt__(self, other): return len(self) > len(other) def __lt__(self, other): return len(self) < len(other) def __ge__(self, other): return len(self) >= len(other) def __le__(self, other): return len(self) <= len(other)