前言:
上节课我们介绍了很多关于计算的魔法方法,当你的对象进行了相关的算术操作的时候,自然而然就会触发相应的魔法方法,一旦你重写了这些魔法方法,那么Python就会根据你的意图进行计算。
通过对相关的魔法方法进行重写,可以让Python根据你的意图执行程序。
这里我们就让加变成减
>>> class int(int):
def __add__(self,other):
return int.__sub__(self,other)
>>> a=int('5')
>>> a
5
>>> b=int('3')
>>> a+b
2
知识点—— [扩展阅读] Python 魔法方法详解
1.反运算 __radd__(self, other) (与上方相同,当左操作数不支持相应的操作时被调用)
>>> class Nint(int):
def __radd__(self,other):
return int.__sub__(self,other)
>>> a=Nint(5)
>>> b=Nint(6)
>>> a+b
11
>>> 1+b #因为找不到1的add方法,所以就找到b的add方法,然后就触发b的radd方法,然后执行了一个sub方法用6-1
#self指定是b,other指的是self方法
5
2._rsub__(self, other) (与上方相同,当左操作数不支持相应的操作时被调用)
>>> class Nint(int):
def __rsub__(self,other):
return int.__sub__(self,other)
>>> a=Nint(5)
>>> 3-a#和上一个代码同理
2
#改成熟悉的顺序。。。。
class Nint(int):
def __rsub__(self,other):
return int.__sub__(other,self)
3.__iadd__(self, other) 定义赋值加法的行为:+=#操作同上
其他相关的魔法方法很多的相似,我就不在这列出来了,需要更多的魔法方法去开始给的链接处查看
测试题:
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.请问如何在继承的类中调用基类的方法?
答:使用super()这个BIF函数。
>>> class Derived(Base):
def meth(self):
super(Derived,self).meth()
3.如果我要继承的基类是动态的(有时是A,有时是B),我应该如何部署我的代码,以便基类可以随意改变?
答:你可以先为基类定义一个别名,在类定义的时候,使用别名代替你要继承的基类。如此,当你想要改变基类的时候,只需要修改给别名赋值的那个语句即可。顺便说一下,当你的资源是视情况而定的时候,这个小技巧很管用。
BaseAlias = BaseClass#为基类取别名
class Derived(BaseClass):
def meth(self):
BaseAlias.meth(self)#通过别名访问基类
.........
4.尝试自己举一个例子说明如何使用类的静态方法
答:类的静态属性很简单,在类中直接定义的变量(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 0x03FAAC00>
>>> c2.static
<function C.static at 0x03FAAC00>
>>> C.static
<function C.static at 0x03FAAC00>
# 普通方法每个实例对象都拥有独立的一个,开销较大
>>> c1.nostatic
<bound method C.nostatic of <__main__.C object at 0x03F96470>>
>>> c2.nostatic
<bound method C.nostatic of <__main__.C object at 0x03F96910>>
>>> C.nostatic
<function C.nostatic at 0x03FAAC48>
使用的时候需要注意的地方:静态方法并不需要 self 参数,因此即使是使用对象去访问,self 参数也不会传进去。
>>> c1.static(1, 2, 3)
1 2 3 6
>>> C.static(1, 2, 3)
1 2 3 6
动动手
0. 定义一个类,当实例化该类的时候,自动判断传入了多少个参数,并显示出来。z
答:其实很容易啦,检查下大家之前的知识点有没有记牢固而已。
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)