《零基础入门学习Python》第043讲：魔法方法：算术运算2

不念不忘少年蓝@ 2022-04-13 14:59 322阅读 0赞

**目录**

0. 请写下这一节课你学习到的内容：格式不限，回忆并复述是加强记忆的好方式！

测试题

0. 对象相加（a + b），如果 a 对象有 \_\_add\_\_ 方法，请问 b 对象的 \_\_radd\_\_ 会被调用吗？

1. Python 什么时候会调用到反运算的魔法方法？

2. 请问如何在继承的类中调用基类的方法？

3. 如果我要继承的基类是动态的（有时候是 A，有时候是 B），我应该如何部署我的代码，以便基类可以随意改变。

4. 尝试自己举一个例子说明如何使用类的静态属性。（一定要自己先动手再看答案哦^\_^）

5. 尝试自己举例说明如何使用类的静态方法，并指出使用类的静态方法有何有点和需要注意的地方？（一定要自己先动手再看答案哦^\_^）

动动手

0. 定义一个类，当实例化该类的时候，自动判断传入了多少个参数，并显示出来：

1. 定义一个单词（Word）类继承自字符串，重写比较操作符（参考自学：Python 魔法方法详解），当两个 Word 类对象进行比较时，根据单词的长度来进行比较大小。

--------------------

## 0. 请写下这一节课你学习到的内容：格式不限，回忆并复述是加强记忆的好方式！ ##

上节课我们介绍了需要关于算术运算的魔法方法，意思是当你的对象进行相关的算术操作的时候，自然而然的就会触动对应的魔法方法，一旦你重写了这些魔法方法，那么Python就会根据你的意图进行计算。

通过对指定的魔法方法进行重写，你完全可以让Python根据你的意图去实现程序，我们来举个例子：

我们重写 int 函数，偷偷摸摸的把 int 覆盖掉，重写之前，它是继承了正常的 int，很明显，当我们进行加法操作时，给它一个减法操作的结果，然后我们的类还把原来的 int 覆盖掉。

其它方法还是继承了正常的 int，只有加法操作变为了减法。

>>> class int(int):
    	def __add__(self, other):
    		return int.__sub__(self,other)
    
    	
    >>> a = int('5')
    >>> a
    5
    >>> b = int(3)
    >>> a + b
    2
    >>> a - b
    2

其它内容请自学->[Python魔法方法详解][Python]

--------------------

# **测试题** #

## 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(BaseAlias):
        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 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 魔法方法详解][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)

[Python]: https://blog.csdn.net/qq_41556318/article/details/84644116