自定义序列类型

序列类型的分类

按照序列存储数据的类型

• 容器序列：list, tuple, deque
• 扁平序列：str, bytes, array.array, bytearray

按照序列是否可变

• 可变序列：list, deque, array.array, bytearray
• 不可变序列：str, tuple, bytes

序列的abc继承关系

引言

• collections.abc模块中有很多内置的抽象基类
• 序列主要和两个抽象基类有关：Sequence 和 MutableSequence

细节

Sequence

"""
Sequence 抽象基类
它继承了Sized Iterable Contain 这三个抽象基类
"""
class Sequence(Sized, Iterable, Container):

    """All the operations on a read-only sequence.

    Concrete subclasses must override __new__ or __init__,
    __getitem__, and __len__.
    """

    __slots__ = ()

    @abstractmethod
    def __getitem__(self, index):
        raise IndexError

    def __iter__(self):
        i = 0
        try:
            while True:
                v = self[i]
                yield v
                i += 1
        except IndexError:
            return

    def __contains__(self, value):
        for v in self:
            if v == value:
                return True
        return False

    def __reversed__(self):     # 该魔法函数使得序列类型可以反转
        for i in reversed(range(len(self))):
            yield self[i]

class Sized(metaclass=ABCMeta):

    __slots__ = ()

    @abstractmethod
    def __len__(self):      # 这个魔法函数使得序列类型可以使用 len()获得长度
        return 0

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Sized:
            if any("__len__" in B.__dict__ for B in C.__mro__):
                return True
        return NotImplemented

class Iterable(metaclass=ABCMeta):

    __slots__ = ()

    @abstractmethod
    def __iter__(self):     # 这个魔法函数使得序列类型可以进行 for 循环
        while False:
            yield None

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Iterable:
            if any("__iter__" in B.__dict__ for B in C.__mro__):
                return True
        return NotImplemented

class Container(metaclass=ABCMeta):

    __slots__ = ()

    @abstractmethod
    def __contains__(self, x):  # 这个魔法函数使得序列类型可以使用 in 操作符
        return False

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Container:
            if any("__contains__" in B.__dict__ for B in C.__mro__):
                return True
        return NotImplemented

MutableSequence

class MutableSequence(Sequence):

    __slots__ = ()

    """All the operations on a read-write sequence.

    Concrete subclasses must provide __new__ or __init__,
    __getitem__, __setitem__, __delitem__, __len__, and insert().

    """

    @abstractmethod
    def __setitem__(self, index, value):
        raise IndexError

    @abstractmethod
    def __delitem__(self, index):
        raise IndexError
        
    def __iadd__(self, values):     # 使得序列可以使用 += 运算符号进行计算
        self.extend(values)
        return self
    
    # ......只列出几个有代表意义的魔法函数......
    # 这些魔法函数使得序列类型可以改变

序列的+、+=和extend

引言

• 对于可变序列，我们有三种方式来扩充原始序列
• 三种方式有原理和效率上的不同，我们要根据实际情况选择合适的方式来使用

使用范例

"""
普通的加法会在内存中产生一个新的序列对象
时间 空间开销相对比较大
必须要是类型完全一致才能够使用这种合并方式
"""
a, b, c = [1, 2], [3, 4], (5, 6)

d = a + b   # [1, 2] + [3, 4]
print(d)

# result:
# [1, 2, 3, 4]

d = a + c   # [1, 2] + (5, 6)
print(d)

# result:
# TypeError: can only concatenate list (not "tuple") to list

"""
+= 可以理解为原地加，单纯地在原对象上进行修改，效率比 + 要高很多
这个功能背后有一个魔法函数，__iadd__(self, values)
上一小节中有这个函数具体的实现，我们可以看到，它是调用了 extend()方法
所以本质上，它和调用 extend()函数产生的效果是一模一样的
"""
a, b, c = [1, 2], [3, 4], (5, 6)

a += b
print(a)

# result:
# [1, 2, 3, 4]

a += c
print(a)
# result:
[1, 2, 3, 4, 5, 6]

在鸭子类型那一小节，我们分析了extend()函数的参数要求，只要是可迭代类型都能够作为参数扩充列表。

+=操作本质上就是调用 extend() 函数，所以能将列表和元组进行合并也就不奇怪了，因为他们本质上都是可迭代的类型。

实现可切片的对象

引言

• 切片介绍

# 使用模式：[start:end:step]
"""
start: 切片开始的位置，默认是 0
end: 切片截止（不包括）的位置，默认是列表长度
step: 切片的步长，默认是 1
start和end为默认值时可以省略不写，step为默认值时可以连同最后的冒号一起省略
step为负数时，表示反向切片，此时需满足： start > end
"""

• 切片举例

li = [8, 4, 3, 2, 1, 7]
li[::]      # 返回原序列
li[::-1]    # 返回原序列的逆序列表
li[::2]     # 隔一个取一个，所有偶数位置
li[1::2]    # 隔一个取一个，所有奇数位置
li[3:6]     # 取[3, 6)区间内的所有元素，左包含，右不包含
li[0:666]   # 结束位置大于列表长度，从尾部截断，返回原列表
li[666:]    # 开始位置大于列表长度，直接返回空列表

li = [6, 6]
li[:0] = [1, 2]     # 列表头部插入元素 [1, 2, 6, 6]
li[1:1] = [1, 1]    # 列表的某一位置插入元素 [6, 1, 1, 6]
li[:1] = [1, 1]     # 替换列表元素 [1, 1, 6]
li[1:] = [1, 1]     # 替换列表元素 [6, 1, 1]

使用案例

class Group:
    def __init__(self, group_name, staffs):
        self.group_name = group_name
        self.staffs = staffs
        
    def __reversed__(self):     # reversed(group)
        self.staffs.reverse()
        
    """
    在使用切片和索引访问操作时，相关的参数会传递到 __getitem__(self, item) 中
    我们通常希望，切片返回的对象和原对象是同一种类型
    使用切片的话，传入的item是一个slice类型
    使用索引访问，传入的item是一个int类型
    """
    def __getitem__(self, item):  # 对象可切片的关键
        cls = type(self)    # 获得该实例的类型
        if isinstance(item, slice):
            return cls(self.group_name, self.staffs[item])  # 委托给列表实现切片
        elif isinstance(item, int):
            return self.staffs[item]
    
    def __len__(self):
        return len(self.staffs)
        
    def __iter__(self):
        return iter(self.staffs)    # 后面会详细讲解
        
    def __contains__(self, item):
        return item in self.staffs   # 同样委托给列表的in操作来实现
    
    def __str__(self):
        return "name:{name}\nstaffs:{staffs}".format(name=self.group_name, staffs=self.staffs)


staffs = ["MetaTian0", "MetaTian1", "MetaTian2"]
group = Group("HIT", staffs)

print(group[1])     # 索引访问
print(group[0:2])   # 切片
reversed(group)     # 反转
print(group)
print(len(group))   # 长度
print("MetaTian0" in group, "MetaTian6" in group)   # in 操作符

# result:
# MetaTian1
# name:HIT; staffs:['MetaTian0', 'MetaTian1']
# name:HIT; staffs:['MetaTian2', 'MetaTian1', 'MetaTian0']
# 3
# True False

bisect模块

引言

• 如果我们在一个有序序列中需要增加一个元素，但任然要维持序列的有序性，可以使用append()添加元素，再调用sort()来重新排序。
• bisect模块用来维持已排序序列（升序）的顺序，效率更高。
• 两个关键函数insort()和bisect

使用案例

import bisect

int_list = []
"""
在插入过程中维护序列的有序性
"""
bisect.insort(int_list, 2)
bisect.insort(int_list, 6)
bisect.insort(int_list, 1)
bisect.insort(int_list, 3)
bisect.insort(int_list, 5)

print(int_list)

# result:
# [1, 2, 3, 5, 6]

"""
查询一个元素在序列中应该插入的位置
bisect(): 同值元素默认插在右侧
bisect_left(): 同值元素默认插在左侧
"""
print(bisect.bisect(int_list, 3))
print(bisect.bisect_left(int_list, 3))

# result:
# 3
# 2

列表一定是最好的吗

引言

• Python中的array，只可以存储指定类型的元素
• 相当与是C语言中的数组，操作效率比列表更高
• 官方文档：https://docs.python.org/3.7/library/array.html?highlight=array

使用案例

import array
"""
使用前要引入array模块，要申明存储的对象类型
"""

my_array = array.array("i")
my_array.append(666)
my_array.append(4)
my_array.extend([1, 2, 3])
my_list = my_array.tolist()

# 大部分基本的操作函数和序列差不多，这里就不做详细介绍
print(my_array)

# result:
# array('i', [666, 4, 1, 2, 3])
# [666, 4, 1, 2, 3]

列表推导、生成器表达式、字典推导

引言

• 推导表达式是一种更加简洁高效，生成相关对象的一种方式

使用案例

"""
列表推导
生成1-20中的奇数
"""
# 普通方式
odd_list = []
for i in range(1, 21):
    if i%2 == 1:
        odd_list.append(i)

# 列表推导
odd_list = [i for i in range(1, 21) if i%2 == 1]

"""
生成器表达式
后面部分会详细介绍其原理
"""
odd_list = (i for i in range(1, 21) if i%2 == 1)
print(type(odd_list))

# result:
# <class 'generator'>

for item in odd_list:
    print(item, end=' ')
    
# result:
# 1 3 5 7 9 11 13 15 17 19 

"""
字典推导式
"""
my_dict = {"a":1, "b":2, "c":3}
reversed_dict = {val:k for k, val in my_dict.items()}
print(reversed_dict)

# result:
# {1: 'a', 2: 'b', 3: 'c'}