《零基础入门学习Python》第047讲：魔法方法：定制序列

左手的ㄟ右手 2022-04-08 08:52 233阅读 0赞

**目录**

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

测试题（笔试，不能上机哦~）

0. 你知道 Python 基于序列的三大容器类指的是什么吗？

1. Python 允许我们自己定制容器，如果你想要定制一个不可变的容器（像 String），你就不能定义什么方法？

2. 如果希望定制的容器支持 reversed() 内置函数，那么你应该定义什么方法？

3. 既然是容器，必然要提供能够查询“容量”的方法，那么请问需要定义什么方法呢？

4. 通过定义哪些方法使得容器支持读、写和删除的操作？

5. 为什么小甲鱼说“在 Python 中的协议就显得不那么正式”？

动动手（一定要自己动手试试哦~）

0. 根据课堂上的例子，定制一个列表，同样要求记录列表中每个元素被访问的次数。

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

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

常言道：“无规矩不成方圆”，讲的是万事万物的发展都要在一定的规则下去运行，只有遵循一定的协议去做，事情才能够按照正确的道路去发展。我们今天要谈的是 定制容器，想要成功的实现容器的定制，我们要先谈一谈协议，那么什么是协议呢？

（1）协议是什么？

协议（Protlcols）与其他编程语言中的接口很相似，它规定你在哪些地方必须定义哪些东西。然而，在Python中的协议就显得不那么正式了。事实上，Python中的协议更像是一种指南，一种建议。

例如，我们之前谈到的[鸭子类型（DuckTyping）][DuckTyping]：当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。

Python就是这样，它并不会严格要求你要怎样去做，而是靠你自觉和经验去把事情做得更好。

（2）定制容器

在Python中，序列类型（例如：列表，元组，字符串）或者映射类型（例如：字典）都是属于容器类型，它们都是里面存放各式各样的对象。那么这一节课我们就来谈定制容器。

我们需要知道的是**有关定义容器的协议**。这里有两种区分：

如果说你希望定制的容器是不可变的话（例如元组、字符串），你只需要定义  \_\_len\_\_() 和 \_\_getitem\_\_() 方法。

如果说你希望定制的容器是可变的话，那么除了 需要定义  \_\_len\_\_() 和 \_\_getitem\_\_() 方法之外，你还需要定义 \_\_setitem\_\_() 和 \_\_delitem\_\_() 两个方法。

有关Python魔法方法的讲解如果忘了的，可以看一下->[Python魔法方法详解][Python]。

（3）练习

编写一个不可改变的自定义列表，要求记录列表中每个元素被访问的次数。

参数是可变数量的 （\*args），因为我们不知道用户要传入多少个数据，我们把用户输入的数据初始化为一个列表，self.values 就是一个列表，我们通过列表推导式的形式把数据存放到 self.values 这个列表中。另外，还需要记录列表中每个元素被访问的次数，我们立刻会想到字典，我们把每个元素在列表中的下标作为字典的键，然后值就是累计的访问次数。我们定义 self.count 这个字典，初始化可以使用 fromkeys ，并把所有下标对应的Key所对应的值初始化为0。我们这是一个不可变的容器，所以需要定义  \_\_len\_\_() 和 \_\_getitem\_\_() 方法，  \_\_len\_\_() 就直接是返回 len(self.values) 的值，\_\_getitem\_\_() 中的 key 就是对应的下标，我们这里是获取key对应的值，所以需要返回self.values\[key\]，另外，对应着访问了它一次，所以对应的 self.count\[key\] 加1。

class CountList:
            def __init__(self, *args):
                    self.values = [x for x in args]
                    self.count = {}.fromkeys(range(len(self.values)), 0)
    
            def __len__(self):
                    return len(self.values)
    
            def __getitem__(self, key):
                    self.count[key] += 1
                    return self.values[key]

验证运行：

>>> c1 = CountList(1, 3, 5, 7, 9)
    >>> c2 = CountList(2, 4, 6, 8, 10)
    >>> c1.count
    {0: 0, 1: 0, 2: 0, 3: 0, 4: 0}
    >>> c2.count
    {0: 0, 1: 0, 2: 0, 3: 0, 4: 0}
    >>> c1[1]
    3
    >>> c1.count
    {0: 0, 1: 1, 2: 0, 3: 0, 4: 0}
    >>> c1[2] + c2[2]
    11
    >>> c1.count
    {0: 0, 1: 1, 2: 1, 3: 0, 4: 0}
    >>> c2.count
    {0: 0, 1: 0, 2: 1, 3: 0, 4: 0}

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

# **测试题（笔试，不能上机哦~）** #

## 0. 你知道 Python 基于序列的三大容器类指的是什么吗？ ##

答：无疑是列表（List），元组（Tuple）和字符串（String）啦。G

## 1. Python 允许我们自己定制容器，如果你想要定制一个不可变的容器（像 String），你就不能定义什么方法？ ##

答：如果你想要定制一个不可变的容器（像 String），你就不能定义像 \_\_setitem\_\_() 和 \_\_delitem\_\_() 这些会修改容器中的数据的方法。

## 2. 如果希望定制的容器支持 reversed() 内置函数，那么你应该定义什么方法？ ##

答：应该定义 \_\_reversed\_\_() 方法，提供对内置函数 reversed() 的支持。

## 3. 既然是容器，必然要提供能够查询“容量”的方法，那么请问需要定义什么方法呢？ ##

答：在 Python 中，我们通过 len() 内置函数来查询容器的“容量”，所以容器应该定义 \_\_len\_\_() 方法。L

## 4. 通过定义哪些方法使得容器支持读、写和删除的操作？ ##

答：读 —— \_\_getitem\_\_()，写 —— \_\_setitem\_\_()，删除 —— \_\_delitem\_\_(),"u

## 5. 为什么小甲鱼说“在 Python 中的协议就显得不那么正式”？ ##

答：在 Python 中，协议更像是一种指南。这有点像我们之前在课后作业中提到的“鸭子类型”（忘了的朋友请戳：[https://blog.csdn.net/qq\_41556318/article/details/84640823][DuckTyping]） —— 当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。Python就是这样，并不会严格地要求你一定要怎样去做，而是让你靠着自觉和经验把事情做好！

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

# **动动手（一定要自己动手试试哦~）** #

## 0. 根据课堂上的例子，定制一个列表，同样要求记录列表中每个元素被访问的次数。 ##

这一次我们希望定制的列表功能更加全面一些，比如支持 append()、pop()、extend() 原生列表所拥有的方法。你应该如何修改呢？

要求1：实现获取、设置和删除一个元素的行为（删除一个元素的时候对应的计数器也会被删除）  
要求2：增加 counter(index) 方法，返回 index 参数所指定的元素记录的访问次数  
要求3：实现 append()、pop()、remove()、insert()、clear() 和 reverse() 方法（重写这些方法的时候注意考虑计数器的对应改变）

今天只有一道动动手的题目，但在写代码的时候要时刻考虑到你的列表增加了计数器功能，所以请务必要考虑周全再提交答案。

附课堂上的例子：

代码清单：

class CountList(list):
        def __init__(self, *args):
            super().__init__(args)
            self.count = []
            for i in args:
                self.count.append(0)
    
        def __len__(self):
            return len(self.count)
    
        def __getitem__(self, key):
            self.count[key] += 1
            return super().__getitem__(key)
    
        def __setitem__(self, key, value):
            self.count[key] += 1
            super().__setitem__(key, value)
    
        def __delitem__(self, key):
            del self.count[key]
            super().__delitem__(key)
    
        def counter(self, key):
            return self.count[key]
    
        def append(self, value):
            self.count.append(0)
            super().append(value)
    
        def pop(self, key=-1):
            del self.count[key]
            return super().pop(key)
    
        def remove(self, value):
            key = super().index(value)
            del self.count[key]
            super().remove(value)
    
        def insert(self, key, value):
            self.count.insert(key, 0)
            super().insert(key, value)
    
        def clear(self):
            self.count.clear()
            super().clear()
    
        def reverse(self):
            self.count.reverse()
            super().reverse()

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