Cython实现的速度不比纯python快

作为练习，我编写了一个XOR双链接列表

%%cython

from cpython.object cimport PyObject
from cpython.ref cimport Py_XINCREF, Py_XDECREF
from libc.stdint cimport uintptr_t

cdef class Node:
    cdef uintptr_t _prev_xor_next
    cdef object val

    def __init__(self, object val, uintptr_t prev_xor_next=0):
        self._prev_xor_next=prev_xor_next
        self.val=val

    @property
    def prev_xor_next(self):
        return self._prev_xor_next
    @prev_xor_next.setter
    def prev_xor_next(self, uintptr_t p):
        self._prev_xor_next=p

    def __repr__(self):
        return str(self.val)


cdef class CurrentNode(Node):
    cdef uintptr_t _node, _prev_ptr
    def __init__(self, uintptr_t node, uintptr_t prev_ptr=0):
        self._node = node
        self._prev_ptr= prev_ptr

    @property
    def val(self):
        return self.node.val
    @property
    def node(self):
        ret=<PyObject *> self._node
        return <Node> ret
    @property
    def prev_ptr(self):
        return self._prev_ptr

    cdef CurrentNode forward(self):
        if self.node.prev_xor_next!=self._prev_ptr:
            return CurrentNode(self.node.prev_xor_next^self._prev_ptr, self._node)

    cdef CurrentNode backward(self):
        if self._prev_ptr:
            pp=<PyObject*>self._prev_ptr
            return CurrentNode(self._prev_ptr, self._node^(<Node> pp).prev_xor_next)

    def __repr__(self):
        return str(self.node)

cdef class XORList:
    cdef PyObject* first
    cdef PyObject* last
    cdef int length

    def __init__(self):
        self.length=0
    @property
    def head(self):
        return (<Node> self.first)

    @property
    def tail(self):
        return (<Node> self.last)

    cdef append(self, object val):
        self.length+=1
        #empty list
        if not self.first:
            t=Node(val)
            tp=(<PyObject*> t)
            self.first=tp
            Py_XINCREF(tp)
            self.last=tp
            Py_XINCREF(tp)

        #not empty
        else:
            new_node=Node(val, <uintptr_t> self.last)
            new_ptr=<PyObject*> new_node
            cur_last=<Node>self.last
            cur_last.prev_xor_next=cur_last.prev_xor_next^(<uintptr_t> new_ptr)
            Py_XINCREF(new_ptr)
            self.last=new_ptr
            Py_XINCREF(new_ptr)

    cpdef reverse(self):
        temp=self.last
        self.last=self.first
        self.first=temp

    def __repr__(self):
        return str(list(iter_XORList(self)))
    def __len__(self):
        return self.length

def iter_XORList(l):
    head=<PyObject*>l.head
    cur=CurrentNode(<uintptr_t> head)
    while cur:
        yield cur
        cur=cur.forward()

import time

start=time.time()
cdef XORList l=XORList()
for i in range(100000):
    l.append(i)
print('time xor ', time.time()-start)

start=time.time()
l1=[]
for i in range(100000):
    l1.append(i)
print('time regular ', time.time()-start)

当我为xorlist分析循环时，我得到：

         700003 function calls in 1.184 seconds

   Ordered by: standard name

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.000    0.000    1.184    1.184 <string>:1(<module>)
        1    0.039    0.039    1.184    1.184 _cython_magic_14cf45d2116440f3df600718d58e4f95.pyx:108(list_check)
   100000    0.025    0.000    0.025    0.000 _cython_magic_14cf45d2116440f3df600718d58e4f95.pyx:11(__init__)
    99999    0.019    0.000    0.019    0.000 _cython_magic_14cf45d2116440f3df600718d58e4f95.pyx:16(__get__)
    99999    0.018    0.000    0.018    0.000 _cython_magic_14cf45d2116440f3df600718d58e4f95.pyx:19(__set__)
        1    0.000    0.000    0.000    0.000 _cython_magic_14cf45d2116440f3df600718d58e4f95.pyx:60(__init__)
   100000    0.937    0.000    0.999    0.000 _cython_magic_14cf45d2116440f3df600718d58e4f95.pyx:70(append)
   100000    0.113    0.000    1.146    0.000 line_profiler.py:111(wrapper)
        1    0.000    0.000    1.184    1.184 {built-in method builtins.exec}
        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}
   100000    0.018    0.000    0.018    0.000 {method 'disable_by_count' of '_line_profiler.LineProfiler' objects}
   100000    0.015    0.000    0.015    0.000 {method 'enable_by_count' of '_line_profiler.LineProfiler' objects}

700003次函数调用，耗时1.184秒
订购人：标准名称
ncalls tottime percall cumtime percall文件名：lineno（函数）
1    0.000    0.000    1.184    1.184 :1()
1 0.039 0.039 1.184 1.184赛顿魔法14cf45d2116440f3df600718d58e4f95.pyx:108（列表检查）
100000 0.025 0.000 0.025 0.000 u cython_magic_14cf45d2116440f3df600718d58e4f95。pyx:11（初始值）
99999 0.019 0.000 0.019 0.000(西索恩魔法)14cf45d2116440f3df600718d58e4f95.pyx:16(获取)
99999 0.018 0.000 0.018 0.000 cython\uMagic\u14CF45D2116440F3DF600718D58E4F95.pyx:19（uuuuuuuuu set\uuuuuuuuuu）
1 0.000 0.000 0.000 0.000(cython_magic)14cf45d2116440f3df600718d58e4f95.pyx:60(初始)
100000 0.937 0.000 0.999 0.000 _cython_magic_14cf45d2116440f3df600718d58e4f95。pyx:70（附加）
100000 0.113 0.000 1.146 0.000测线仪py:111（包装器）
1 0.000 0.000 1.184 1.184{内置方法builtins.exec}
1 0.000 0.000 0.000 0.000{方法'disable'的''lsprof.Profiler'对象}
100000 0.018 0.000 0.018 0.000{方法“按”\u line\u profiler.LineProfiler'对象的\u计数禁用”}
100000 0.015 0.000 0.015 0.000{方法'enable_by_count'的'u line_profiler.LineProfiler'对象}

因此，忽略对

append

的调用，似乎大部分时间都花在了特殊方法上

这就引出了我的问题：

我怎样才能加快速度

我认为Cython中的扩展类型是通过结构在底层实现的，那么是什么导致它们的初始化花费了这么长时间呢

---

我还在纯python中尝试了另一个原始双链表的自定义实现，它和cython xorlist的计时在我的机器上相差10%以内。

您的评测中的三个罪魁祸首看起来是节点的

\uuu init\uuu

（这在这里是不可避免的），以及

上一个异或下一个

属性的

获取

和

设置

。我的观点是，您不希望使用

prev\u xor\u next

属性（或者如果您这样做，它应该是只读的），因为它可以在Python中访问应该是Cython内部的内容

无论是否删除该属性，您都在Cython中工作，因此可以直接写入底层C属性

\u prev\u xor\u next

。您可能需要在

append

的开头设置

cdef Node cur\u last

（可能在其他函数中）以确保Cython知道

cur\u last

的类型-我认为它应该能够解决这个问题，但如果您在运行时得到

AttributeErrors

，那么这就是您需要做的事情

这一变化使我的速度提高了30%（也就是说，它仍然比常规列表慢，但这是一个明显的改进）

---

我将概述一个更剧烈的变化，我可能应该在你关于这个问题的第一个问题上提出这个变化。这真的是一个模糊的大纲，所以没有作出任何努力，使其工作

• Node

  完全在

  XORList

  类内部：它不应从Python中使用，并且

  XORList

  中所有

  节点的生存期都直接绑定到列表。因此，应在销毁其所属的
  XORList
  （或者如果列表缩小等）时销毁它们，因此不需要进行引用计数。因此，
  节点
  应该是C结构而不是Python对象：
  
  cdef struct Node:
      uintptr_t prev_xor_next
      PyObject* val
  
  # with associated constructor- and destructor-like functions:
  cdef Node* make_node(object val, uintptr_t prev_xor_next):
      cdef Node* n = <Node*>malloc(sizeof(Node))
      n.val = <PyObject*>val
      Py_XINCREF(n.val)
      n.prev_xor_next = prev_xor_next
      return n
  
  cdef void destroy_node(Node* n):
      Py_XDECREF(n.val)
      free(n)
  
  属性
  我们的\u列表
  的要点是确保
  XORList
  至少在
  CurrentNode
  期间保持活动状态-如果您的
  XORList
  的迭代器不再存在，则
  当前\u节点
  属性将无效
  current_节点
  不属于
  XORListIterator
  所以不需要析构函数
  

我认为这种方案的危险在于，如果对

XORList

进行任何更改，都不会使任何现有的

xorlistators

完全失效，从而导致崩溃。我怀疑这也是您当前版本的一个问题

---

我怀疑内置的

列表

仍将保持竞争力，因为它是一个编写良好、高效的结构。请记住，

list.append

通常是一个简单的

Py_INCREF

，偶尔会进行数组重新分配和复制。您总是需要创建一个新的Python对象（

节点

）以及一些相关的引用计数

我的替代方案避免了大量的引用计数（无论是在计算时间还是“你必须考虑它”的时间方面），所以我希望它更接近。它保留了每个

append

内存分配小的缺点，这对于链表结构来说是不可避免的

---

附录：针对“Cython类的便利性”的评论。在我看来，使用Cython类与使用struct相比，有两个优点：

您可以得到非常接近结构的东西，但不必担心C指针，而且引用计数也会得到处理。很明显，对于这个问题，您对指针做了一些奇怪的事情，并且必须显式地处理引用计数，所以我认为这不适用于您

您可以从Python使用它-您不仅仅限于Cython。在本例中，我认为这完全是

XORList

的实现细节，不应该向Python用户公开

因此，我认为使用Cython类的主要原因并不适用于您的问题。（当然，对于许多代码来说，这些优点确实适用！）

这可能也值得加上

cdef struct Node:
    uintptr_t prev_xor_next
    PyObject* val

# with associated constructor- and destructor-like functions:
cdef Node* make_node(object val, uintptr_t prev_xor_next):
    cdef Node* n = <Node*>malloc(sizeof(Node))
    n.val = <PyObject*>val
    Py_XINCREF(n.val)
    n.prev_xor_next = prev_xor_next
    return n

cdef void destroy_node(Node* n):
    Py_XDECREF(n.val)
    free(n)

cdef class XORListIterator:
    cdef Node* current_node
    cdef XORList our_list