python deque的内在实现 本质上就是双向链表所以用于stack、队列非常方便

How collections.deque works?

Cosven

前言：在 Python 生态中，我们经常使用 collections.deque 来实现栈、队列这些只需要进行头尾操作的数据结构，它的 append/pop 操作都是 O(1) 时间复杂度。list 的 pop(0) 的时间复杂度是 O(n)， 在这个场景中，它的效率没有 deque 高。那 deque 内部是怎样实现的呢？ 我从 GitHub 上挖出了 CPython collections 模块的第二个 commit 的源码。

dequeobject 对象定义

注释写得优雅了，无法进行更加精简的总结。

/* The block length may be set to any number over 1.  Larger numbers
 * reduce the number of calls to the memory allocator but take more
 * memory.  Ideally, BLOCKLEN should be set with an eye to the
 * length of a cache line.
 */

#define BLOCKLEN 62
#define CENTER ((BLOCKLEN - 1) / 2)

/* A `dequeobject` is composed of a doubly-linked list of `block` nodes.
 * This list is not circular (the leftmost block has leftlink==NULL,
 * and the rightmost block has rightlink==NULL).  A deque d‘s first
 * element is at d.leftblock[leftindex] and its last element is at
 * d.rightblock[rightindex]; note that, unlike as for Python slice
 * indices, these indices are inclusive on both ends.  By being inclusive
 * on both ends, algorithms for left and right operations become
 * symmetrical which simplifies the design.
 *
 * The list of blocks is never empty, so d.leftblock and d.rightblock
 * are never equal to NULL.
 *
 * The indices, d.leftindex and d.rightindex are always in the range
 *     0 <= index < BLOCKLEN.
 * Their exact relationship is:
 *     (d.leftindex + d.len - 1) % BLOCKLEN == d.rightindex.
 *
 * Empty deques have d.len == 0; d.leftblock==d.rightblock;
 * d.leftindex == CENTER+1; and d.rightindex == CENTER.
 * Checking for d.len == 0 is the intended way to see whether d is empty.
 *
 * Whenever d.leftblock == d.rightblock,
 *     d.leftindex + d.len - 1 == d.rightindex.
 *
 * However, when d.leftblock != d.rightblock, d.leftindex and d.rightindex
 * become indices into distinct blocks and either may be larger than the
 * other.
 */

typedef struct BLOCK {
    struct BLOCK *leftlink;
    struct BLOCK *rightlink;
    PyObject *data[BLOCKLEN];
} block;

typedef struct {
    PyObject_HEAD
    block *leftblock;
    block *rightblock;
    int leftindex;  /* in range(BLOCKLEN) */
    int rightindex; /* in range(BLOCKLEN) */
    int len;
    long state; /* incremented whenever the indices move */
    PyObject *weakreflist; /* List of weak references */
} dequeobject;

下面是我为 Block 结构体画的一个图

                +----------------------------------------+
                |          data: 62 objects              |
 +----------+   |                                        |   +-----------+
 | leftlink |---|  | ... | Obj1 | Obj2 | Obj3 | ... |    |---| rightlink |
 +----------+   |           30     31     32             |   +-----------+
                +----------------------------------------+

创建一个 block

static block *
newblock(block *leftlink, block *rightlink, int len) {
    block *b;
    /* To prevent len from overflowing INT_MAX on 64-bit machines, we
     * refuse to allocate new blocks if the current len is dangerously
     * close.  There is some extra margin to prevent spurious arithmetic
     * overflows at various places.  The following check ensures that
     * the blocks allocated to the deque, in the worst case, can only
     * have INT_MAX-2 entries in total.
     */
    if (len >= INT_MAX - 2*BLOCKLEN) {
        PyErr_SetString(PyExc_OverflowError,
                "cannot add more blocks to the deque");
        return NULL;
    }
    b = PyMem_Malloc(sizeof(block));
    if (b == NULL) {
        PyErr_NoMemory();
        return NULL;
    }
    b->leftlink = leftlink;
    b->rightlink = rightlink;
    return b;
}

创建一个 dequeobject

  1. 创建一个 block
  2. 实例化一个 dequeobject Python 对象（这一块的内在逻辑目前我也不太懂）
  3. leftblock 和 rightblock 指针都指向这个 block
  4. leftindex 是 CENTER+1，rightindex 是 CENTER
  5. 初始化其他一些属性， len state 等

这个第一步和第四步都有点意思，第一步创建一个 block，也就是说， deque 对象创建的时候，就预先分配了一块内存。第四步隐约告诉我们， 当元素来的时候，它先会被放在中间，然后逐渐往头和尾散开。

static PyObject *
deque_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
    dequeobject *deque;
    block *b;

    if (type == &deque_type && !_PyArg_NoKeywords("deque()", kwds))
        return NULL;

    /* create dequeobject structure */
    deque = (dequeobject *)type->tp_alloc(type, 0);
    if (deque == NULL)
        return NULL;

    b = newblock(NULL, NULL, 0);
    if (b == NULL) {
        Py_DECREF(deque);
        return NULL;
    }

    assert(BLOCKLEN >= 2);
    deque->leftblock = b;
    deque->rightblock = b;
    deque->leftindex = CENTER + 1;
    deque->rightindex = CENTER;
    deque->len = 0;
    deque->state = 0;
    deque->weakreflist = NULL;

    return (PyObject *)deque;
}

deque.append 实现

步骤：

  1. 如果 rightblock 可以容纳更多的元素，则放在 rightblock 中
  2. 如果不能，就新建一个 block，然后更新若干指针，将元素放在更新后的 rightblock 中
static PyObject *
deque_append(dequeobject *deque, PyObject *item)
{
    deque->state++;
    if (deque->rightindex == BLOCKLEN-1) {
        block *b = newblock(deque->rightblock, NULL, deque->len);
        if (b == NULL)
            return NULL;
        assert(deque->rightblock->rightlink == NULL);
        deque->rightblock->rightlink = b;
        deque->rightblock = b;
        deque->rightindex = -1;
    }
    Py_INCREF(item);
    deque->len++;
    deque->rightindex++;
    deque->rightblock->data[deque->rightindex] = item;
    Py_RETURN_NONE;
}

看了 append 实现后，我们可以自行脑补一下 pop 和 popleft 的实现。

小结

deque 内部将一组内存块组织成双向链表的形式，每个内存块可以看成一个 Python 对象的数组， 这个数组与普通数据不同，它是从数组中部往头尾两边填充数据，而平常所见数组大都是从头往后。 得益于 deque 这样的结构，它的 pop/popleft/append/appendleft 四种操作的时间复杂度均是 O(1), 用它来实现队列、栈数据结构会非常方便和高效。但也正因为这样的设计， 它不能像数组那样通过 index 来访问、移除元素。链表 + 数组、或者链表 + 字典 这样的设计在实践中有很广泛的应用，比如 LRUCache, LFUCache，有兴趣的同鞋可以继续探索。

  • PS1: LRUCache 在面试中不要太常见
  • PS2: 出 LFUCache 题的面试官都是变态
  • PS3: 头图来自 quora ，图文不怎么有关系列

原文地址：https://www.cnblogs.com/bonelee/p/11433743.html

时间： 2024-10-05 04:02:53

python deque的内在实现 本质上就是双向链表所以用于stack、队列非常方便的相关文章

Python学习第一周总结（上）

Python基础知识总结 一.前期了解 1.1解释型语言和编译型语言 编译型语言在程序执行之前,有一个单独的编译过程,将程序翻译成机器语言,以后执行这个程序的时候,就不用再进行翻译了. 解释型语言,是在运行的时候将程序翻译成机器语言,所以运行速度相对于编译型语言要慢. C/C++ 等都是编译型语言,而Java,C#,Python等都是解释型语言. 1.2动态类型语言和静态类型语言 动态类型语言:指在运行期间才去做数据类型检查的语言.在用动态类型的语言编程时,永远也不用给任何变量指定数据类型,该语

C++学习笔记----2.4 C++引用在本质上是什么，它和指针到底有什么区别

从概念上讲.指针从本质上讲就是存放变量地址的一个变量,在逻辑上是独立的,它可以被改变,包括其所指向的地址的改变和其指向的地址中所存放的数据的改变. 而引用是一个别名,它在逻辑上不是独立的,它的存在具有依附性,所以引用必须在一开始就被初始化,而且其引用的对象在其整个生命周期中是不能被改变的(自始至终只能依附于同一个变量). 在C++中,指针和引用经常用于函数的参数传递,然而,指针传递参数和引用传递参数是有本质上的不同的: 指针传递参数本质上是值传递的方式,它所传递的是一个地址值.值传递过程中,被调

python之模块ftplib(实现ftp上传下载代码)

# -*- coding: utf-8 -*- #python 27 #xiaodeng #python之模块ftplib(实现ftp上传下载代码) #需求:实现ftp上传下载代码(不含错误处理) from ftplib import FTP def ftpconnect(): ftp_server='ftp.python.org' ftp=FTP() ftp.set_debuglevel(2)#打开调式级别2 ftp.connect(ftp_server,21) ftp.login('',''

python 学习笔记 3 -- 数据结构篇上

数据结构是可以处理一些 数据 的 结构 .或者说,它们是用来存储一组相关数据的.在Python中有三种内建的数据结构--列表.元组和字典.本文主要对这三种数据类型以及相关的使用做介绍,以例子的形式演示更加容易理解! 1.列表(List) 列表是处理一组有序项目的数据结构,即你可以在一个列表中存储一个 序列 的项目.在Python中,你在每个项目之间用逗号分割. 列表中的项目应该包括在**方括号**中,这样Python就知道你是在指明一个列表.一旦你创建了一个列表,你可以添加.删除或是搜索列表中的

活动图本质上就是流程图

活动图(activity diagram,动态图)是阐明了业务用例实现的工作流程.业务工作流程说明了业务为向所服务的业务主角提供其所需的价值而必须完成的工作. 在 UML 中, 活动图本质上就是流程图. 它用于描述系统的活动, 判定点和分支等. 活动图是UML用于对系统的动态行为建模的另一种常用工具,它描述活动的顺序,展现从一个活动到另一个活动的控制流.活动图在本质上是一种流程图. 它是UML中用于对系统动态活动建模的图形,反映系统中一个活动到另一个活动的流程,常常用于描述业务过程和并行处理过程

HTTP中GET与POST的区别 (本质上是一样一样的TCP链接)

(转自微信公众号WebTechGarden) GET和POST是HTTP请求的两种基本方法,要说它们的区别,接触过WEB开发的人都能说出一二. 最直观的区别就是GET把参数包含在URL中,POST通过request body传递参数. 你可能自己写过无数个GET和POST请求,或者已经看过很多权威网站总结出的他们的区别,你非常清楚知道什么时候该用什么. 当你在面试中被问到这个问题,你的内心充满了自信和喜悦. 你轻轻松松的给出了一个"标准答案": GET在浏览器回退时是无害的,而POST

python写个简单的文件上传是有多难，要么那么复杂，要么各种，，，老子来写个简单的

def upload(url,params): ''' 上传文件到服务器,不适合大文件 @params url 你懂的 @params {"action":"xxx","@file","file_path"} 普通参数 key:value 文件key头部加@ ''' import os import urllib2 BOUNDARY = "0450de9528f040078csuxianbaozic06"

python模块之HTMLParser抓页面上的所有URL链接

# -*- coding: utf-8 -*- #python 27 #xiaodeng #python模块之HTMLParser抓页面上的所有URL链接 import urllib #MyParser类写法一 ''' from HTMLParser import HTMLParser class MyParser(HTMLParser): def __init__(self): HTMLParser.__init__(self) def handle_starttag(self, tag, a

大数据DDos检测——DDos攻击本质上是时间序列数据，t+1时刻的数据特点和t时刻强相关，因此用HMM或者CRF来做检测是必然！ 和一个句子的分词算法CRF没有区别！

DDos攻击本质上是时间序列数据,t+1时刻的数据特点和t时刻强相关,因此用HMM或者CRF来做检测是必然!--和一个句子的分词算法CRF没有区别!注:传统DDos检测直接基于IP数据发送流量来识别,通过硬件防火墙搞定.大数据方案是针对慢速DDos攻击来搞定.难点:在进行攻击的时候,攻击数据包都是经过伪装的,在源IP 地址上也是进行伪造的,这样就很难对攻击进行地址的确定,在查找方面也是很难的.这样就导致了分布式拒绝服务攻击在检验方法上是很难做到的.领域知识见:http://blog.csdn.n