可变序列和不可变序列

快速浏览代码：(已去除空行和部分abstractmethod)

class Collection(Sized, Iterable, Container):
    pass
class Sequence(Reversible, Collection):
    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 is value or v == value:
                return True
        return False

    def __reversed__(self):
        for i in reversed(range(len(self))):
            yield self[i]

    def index(self, value, start=0, stop=None):
        if start is not None and start < 0:
            start = max(len(self) + start, 0)
        if stop is not None and stop < 0:
            stop += len(self)

        i = start
        while stop is None or i < stop:
            try:
                v = self[i]
                if v is value or v == value:
                    return i
            except IndexError:
                break
            i += 1
        raise ValueError

    def count(self, value):
        return sum(1 for v in self if v is value or v == value)


class MutableSequence(Sequence):
    def __setitem__(self, index, value):
        raise IndexError

    def __delitem__(self, index):
        raise IndexError

    def insert(self, index, value):
        raise IndexError

    def append(self, value):
        self.insert(len(self), value)

    def clear(self):
        try:
            while True:
                self.pop()
        except IndexError:
            pass

    def reverse(self):
        n = len(self)
        for i in range(n // 2):
            self[i], self[n - i - 1] = self[n - i - 1], self[i]

    def extend(self, values):
        for v in values:
            self.append(v)

    def pop(self, index=-1):
        v = self[index]
        del self[index]
        return v

    def remove(self, value):
        del self[self.index(value)]

    def __iadd__(self, values):
        self.extend(values)
        return self

列表推导使用原则：

• 列表推导可以增强可读性
• 列表推导可以节省空间消耗
• 过于复杂的列表推导对调试有害

其他序列

• array.array更高效地处理纯数字
• 内存视图可以在不复制的情况下用切片创建视图
• NumPy和SciPy用于数值处理
• deque双向队列
• heapq实现了堆排序，可用于优先级队列