5分钟掌握在 Cython 中使用 C++

最新推荐文章于 2023-04-09 18:21:18 发布
最新推荐文章于 2023-04-09 18:21:18 发布
阅读量1.2k 收藏 7
点赞数 1
文章标签： c++ 指针 python iterator stl

1. 在Jupyter Notebook上使用C++

  • 首先加载Cython扩展，使用魔术命令 %load_ext Cython

  • 接下来运行Cython代码，使用魔术命令 %%cython --cplus

  • 如果使用MacOS，使用魔术命令 %%cython --cplus --compile-args=-stdlib=libc++ --link-args=-stdlib=libc++，详情请参考https://stackoverflow.com/questions/57367764/cant-import-cpplist-into-cython

%load_ext Cython
%%cython --cplus --compile-args=-stdlib=libc++ --link-args=-stdlib=libc++
# 注意: 使用 'cimport' 而不是 'import'
from libcpp.string cimport string
cdef string s
s = b"Hello world!"
print(s.decode("utf-8"))

Hello world!

2. C++和Python类型的相互转换

3. 使用C++ STL

3.1 使用C++ Vector

可以替代Python的List。

  1. 初始化 - 通过Python的可迭代对象进行初始化，需要声明变量的嵌套类型

  2. 遍历 - 让index自增，通过while循环进行遍历

  3. 访问 - 和Python一样使用'[]'操作符对元素进行访问

  4. 追加 - 与Python list的append方法相似，使用C++ Vector的push_back方法追加元素

最后，我们通过分别实现Python和C++版本的元素计数函数来对比性能，C++大约快240倍左右。

注意: 为了公平起见，函数没有传入参数，而是直接访问函数体外部的变量。避免计入C++版本把Python列表转换为C++ Vector的耗时。如果计入这部分耗时，C++的版本大约快4倍左右。

%%cython --cplus --compile-args=-stdlib=libc++ --link-args=-stdlib=libc++
from libcpp.vector cimport vector
# 通过Python对象初始化
cdef vector[int] vec = range(5)
# 遍历
cdef:
    int i = 0
    int n = vec.size()
print("开始遍历...")
while i < n:
    # 访问
    print("\t第%d个位置的元素是%d" % (i, vec[i]))
    i += 1
print()
# 追加
vec.push_back(5)
print("追加元素之后vec变为", vec)

开始遍历...
        第0个位置的元素是0
        第1个位置的元素是1
        第2个位置的元素是2
        第3个位置的元素是3
        第4个位置的元素是4

    追加元素之后vec变为 [0, 1, 2, 3, 4, 5]

arr = [x // 100 for x in range(1000)]
target = 6

def count_py():
    return sum(1 for x in arr if x == target)

print("用Python来实现，计算结果为%d!"% count_py())

用Python来实现，计算结果为100!

%%cython --cplus --compile-args=-stdlib=libc++ --link-args=-stdlib=libc++
from libcpp.vector cimport vector

cdef:
    int target = 6
    vector[int] v = [x // 100 for x in range(1000)]

cdef int _count_cpp():
    cdef:
        int i = 0
        int n = v.size()
        int ret = 0
    while i < n:
        if v[i] == target:
            ret += 1
        i += 1
    return ret

def count_cpp():
    return _count_cpp()

print("用Cython(C++)来实现，计算结果为%d!"% count_cpp())

用Cython(C++)来实现，计算结果为100!

print("对比Python版本与C++版本的性能...")
%timeit count_py()
%timeit count_cpp()

对比Python版本与C++版本的性能...  
30.8 µs ± 254 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)  
130 ns ± 6.4 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

3.2 使用C++ Unordered Map

可以替代Python的Dict。

  1. 初始化 - 通过Python的可迭代对象进行初始化，需要声明变量的嵌套类型

  2. 遍历 - 让泛型指针自增，通过while循环进行遍历

  3. 访问 - 使用deref(C++中的'*'操作符)来解引用，返回pair对象，通过.first来访问key, .second来访问Value

  4. 查找 - 使用unordered_map.count，返回1或0；或者用unordered_map.find，返回一个泛型指针，如果指针指向unordered_map.end，则表示未找到。

  5. 追加/修改 - unordered_map[key] = value。如果Key不存在，'[]'操作符会添加一个Key，并赋值为默认的Value，比如0.0。所以，除非确定不会产生错误，否则在修改Key对应的Value之前，要先判断Key是否存在。这与Python的DecaultDict有点相似。

最后，我们通过分别实现Python和C++版本的map条件求和函数来对比性能，C++大约快40倍左右。

%%cython --cplus --compile-args=-stdlib=libc++ --link-args=-stdlib=libc++
from cython.operator cimport dereference as deref, preincrement as inc
from libcpp.unordered_map cimport unordered_map
# 通过Python对象初始化
cdef unordered_map[int, float] mymap = {i: i/10 for i in range(10)}
# 遍历
cdef:
    unordered_map[int, float].iterator it = mymap.begin()
    unordered_map[int, float].iterator end = mymap.end()
print("开始遍历...")
while it != end:
    # 访问
    print("\tKey is %d, Value is %.1f" % (deref(it).first, deref(it).second))
    inc(it)
print()

# 查找
print("开始查找...")
if mymap.count(-2):
    print("\t元素-2存在!")
else:
    print("\t元素-2不存在!")

it = mymap.find(3)
if it != end:
    print("\t元素3存在, 它的值是%.1f!" % deref(it).second)
else:
    print("\t元素3不存在!")
print()

# 修改
print("修改元素...")
if mymap.count(3):
    mymap[3] += 1.0
mymap[-2]  # Key -2不存在，会被添加一个默认值0.0
print("\tKey is 3, Value is %.1f" % mymap[3])
print("\tKey is -2, Value is %.1f" % mymap[-2])

开始遍历...
        Key is 0, Value is 0.0
        Key is 1, Value is 0.1
        Key is 2, Value is 0.2
        Key is 3, Value is 0.3
        Key is 4, Value is 0.4
        Key is 5, Value is 0.5
        Key is 6, Value is 0.6
        Key is 7, Value is 0.7
        Key is 8, Value is 0.8
        Key is 9, Value is 0.9

开始查找...
        元素-2不存在!
        元素3存在, 它的值是0.3!

修改元素...
        Key is 3, Value is 1.3
        Key is -2, Value is 0.0

my_map = {x: x for x in range(100)}
target = 50

def sum_lt_py():
    return sum(my_map[x] for x in my_map if x < target)

print("用Python来实现，计算结果为%d!"% sum_lt_py())

用Python来实现，计算结果为1225!

%%cython --cplus --compile-args=-stdlib=libc++ --link-args=-stdlib=libc++
from libcpp.unordered_map cimport unordered_map
from cython.operator cimport dereference as deref, preincrement as inc

cdef:
    unordered_map[int, int] my_map = {x: x for x in range(100)}
    int target = 50

cdef _sum_lt_cpp():
    cdef:
        unordered_map[int, int].iterator it = my_map.begin()
        int ret
    while it != my_map.end():
        if deref(it).first < target:
            ret += deref(it).second
        inc(it)
    return ret

def sum_lt_cpp():
    return _sum_lt_cpp()

print("用Cython(C++)来实现，计算结果为%d!"% sum_lt_cpp())

用Cython(C++)来实现，计算结果为1225!

print("对比Python版本与C++版本的性能...")
%timeit sum_lt_py()
%timeit sum_lt_cpp()

对比Python版本与C++版本的性能...
    6.63 µs ± 183 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
    157 ns ± 3.13 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

3.3 使用C++ Unordered Set

可以替代Python的Set。

  1. 初始化 - 通过Python的可迭代对象进行初始化，需要声明变量的嵌套类型

  2. 遍历 - 让泛型指针自增，通过while循环进行遍历

  3. 访问 - 使用deref(C++中的'*'操作符)来解引用

  4. 查找 - 使用unordered_set.count，返回1或0

  5. 追加 - 使用unordered_set.insert，如果元素已经存在，则元素不会被追加

  6. 交集、并集、差集 - 据我所知，unordered_set的这些操作需要开发者自己去实现，不如Python的Set用起来方便。

最后，我们通过分别实现Python和C++版本的set求交集对比性能，C++大约慢20倍左右。详情可参考https://stackoverflow.com/questions/54763112/how-to-improve-stdset-interp-performance-in-c如果只是求两个集合相同元素的数量，C++的性能大约是Python的6倍。不难推测，C++的unordered set查询很快，但是创建很慢。

%%cython --cplus --compile-args=-stdlib=libc++ --link-args=-stdlib=libc++
from cython.operator cimport dereference as deref, preincrement as inc
from libcpp.unordered_set cimport unordered_set
# 通过Python对象初始化
cdef unordered_set[int] myset = {i for i in range(5)}
# 遍历
cdef:
    unordered_set[int].iterator it = myset.begin()
    unordered_set[int].iterator end = myset.end()
print("开始遍历...")
while it != end:
    # 访问
    print("\tValue is %d" % deref(it))
    inc(it)
print()

# 查找
print("开始查找...")
if myset.count(-2):
    print("\t元素-2存在!")
else:
    print("\t元素-2不存在!")

print()

# 追加
print("追加元素...")
myset.insert(0)
myset.insert(-1)

print("\tMyset is: ", myset)

开始遍历...
        Value is 0
        Value is 1
        Value is 2
        Value is 3
        Value is 4

开始查找...
        元素-2不存在!

追加元素...
        Myset is:  {0, 1, 2, 3, 4, -1}

myset1 = {x for x in range(100)}
myset2 = {x for x in range(50, 60)}

def interp_py():
    return myset1 & myset2

print("用Python来实现，计算结果为%s!"% interp_py())

用Python来实现，计算结果为{50, 51, 52, 53, 54, 55, 56, 57, 58, 59}!

%%cython --cplus --compile-args=-stdlib=libc++ --link-args=-stdlib=libc++
from cython.operator cimport dereference as deref, preincrement as inc
from libcpp.unordered_set cimport unordered_set

cdef:
    unordered_set[int] myset1 = {x for x in range(100)}
    unordered_set[int] myset2 = {x for x in range(50, 60)}

cdef unordered_set[int] _interp_cpp():
    cdef:
        unordered_set[int].iterator it = myset1.begin()
        unordered_set[int] ret
    while it != myset1.end():
        if myset2.count(deref(it)):
            ret.insert(deref(it))
        inc(it)
    return ret

def interp_cpp():
    return _interp_cpp()

print("用Cython(C++)来实现，计算结果为%s!"% interp_cpp())

用Cython(C++)来实现，计算结果为{50, 51, 52, 53, 54, 55, 56, 57, 58, 59}!

print("对比Python版本与C++版本的性能...")
%timeit interp_py()
%timeit interp_cpp()

对比Python版本与C++版本的性能...
    244 ns ± 2.96 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
    4.87 µs ± 100 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

myset1 = {x for x in range(100)}
myset2 = {x for x in range(50, 60)}

def count_common_py():
    return len(myset1 & myset2)

print("用Python(C++)来实现，计算结果为%s!"% count_common_py())

用Python(C++)来实现，计算结果为10!

%%cython --cplus --compile-args=-stdlib=libc++ --link-args=-stdlib=libc++
from cython.operator cimport dereference as deref, preincrement as inc
from libcpp.unordered_set cimport unordered_set

cdef:
    unordered_set[int] myset2 = {x for x in range(100)}
    unordered_set[int] myset1 = {x for x in range(50, 60)}

cdef int _count_common_cpp():
    if myset1.size() > myset2.size():
        myset1.swap(myset2)
    cdef:
        unordered_set[int].iterator it = myset1.begin()
        int ret = 0
    while it != myset1.end():
        if myset2.count(deref(it)):
            ret += 1
        inc(it)
    return ret

def count_common_cpp():
    return _count_common_cpp()

print("用Cython(C++)来实现，计算结果为%s!"% count_common_cpp())

用Cython(C++)来实现，计算结果为10!

print("对比Python版本与C++版本的性能...")
%timeit count_common_py()
%timeit count_common_cpp()

对比Python版本与C++版本的性能...
276 ns ± 3.18 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
46.2 ns ± 0.845 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

4. 传值与传引用

Python的函数，如果是容器类对象(如List, Set)，传递的是引用，否则传递的是值(如int, float)，如果不希望让函数修改容器类对象，可以用deepcopy函数先拷贝一份容器的副本。但在C++里默认都是传值，如果需要传引用需要声明。

以int型Vector为例，可以看到v1的值没有被pass_value修改，但被pass_reference修改了。

  • 传值使用 vector[int]，pass_value函数只是传入了v1的一份拷贝，所以函数无法修改v1

  • 传引用使用 vector[int]&，pass_reference传入了v1的引用，函数可以修改v1。

下面的两块代码可以展示Python与C++的不同之处。

from copy import deepcopy

def pass_value(v):
    v = deepcopy(v)
    v[0] = -1

def pass_reference(v):
    v[0] = -1

v1 = [0, 0, 0]
print("v1的初始值是%s" % v1)
pass_value(v1)
print("执行pass_value函数后，v1的值是%s" % v1)
pass_reference(v1)
print("执行pass_reference函数后，v1的值是%s" % v1)

v1的初始值是[0, 0, 0]
执行pass_value函数后，v1的值是[0, 0, 0]
执行pass_reference函数后，v1的值是[-1, 0, 0]

%%cython --cplus --compile-args=-stdlib=libc++ --link-args=-stdlib=libc++

from libcpp.vector cimport vector

cdef void pass_value(vector[int] v):
    v[0] = -1

cdef void pass_reference(vector[int]& v):
    v[0] = -1

cdef vector[int] v1 = [0, 0, 0]
print("v1的初始值是%s" % v1)
pass_value(v1)
print("执行pass_value函数后，v1的值是%s" % v1)
pass_reference(v1)
print("执行pass_reference函数后，v1的值是%s" % v1)

v1的初始值是[0, 0, 0]
执行pass_value函数后，v1的值是[0, 0, 0]
执行pass_reference函数后，v1的值是[-1, 0, 0]

5. 数字的范围

Python只有int型，而且int的范围可以认为是无限大的，只要没有超出内存限制，所以Python使用者一般不太关心数值溢出等问题。但使用C++的时候就需要谨慎，C++各个数字类型对应的范围如下：

比如下面的函数就会造成错误。

%%cython --cplus --compile-args=-stdlib=libc++ --link-args=-stdlib=libc++
def sum_py(num1, num2):
    print("The result by python is:", num1 + num2)

cdef int _sum_cpp(int num1, int num2):  # int -> long int
    return num1 + num2

def sum_cpp(num1, num2):
    print("The result by cpp is:", _sum_cpp(num1, num2))

sum_py(2**31-1, 1)
sum_cpp(2**31-1, 1)

The result by python is: 2147483648
The result by cpp is: -2147483648

%%cython --cplus --compile-args=-stdlib=libc++ --link-args=-stdlib=libc++
from libcpp cimport bool

def lt_py(num1, num2):
    print("The result by python is:", num1 < num2)

cdef bool _lt_cpp(float num1, float num2):  # float -> double
    return num1 > num2

def lt_cpp(num1, num2):
    print("The result by cpp is:", _lt_cpp(num1, num2))

lt_py(1234567890.0, 1234567891.0)
lt_cpp(1234567890.0, 1234567891.0)

The result by python is: True
The result by cpp is: False

作者：李小文，先后从事过数据分析、数据挖掘工作，主要开发语言是Python，现任一家小型互联网公司的算法工程师。

Github: https://github.com/tushushu

推荐阅读

如何在 Matplotlib 中更改绘图背景

Python 解释器 PyPy 7.3.3 版本发布！

有人在代码里下毒！慎用 pip install 命令

点击下方阅读原文加入社区会员

点赞鼓励一下

Python中文社区
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
使用Cython为Python开发C++扩展
trium_KW的博客
05-26 673
Cython的出现免去了为Python开发C/C++扩展的很多麻烦。本文以一个简单的例子来说明如何为Python开发C++扩展。 例子程序：给定一个列表，把列表的每个元素平方，并返回新列表。用Python实现会是这样： def square(l): return [x * x for x in l] 现在我们用C++实现这个函数。根据Using C++ in Cython，Python列表对应于C++的std::vector，因此我们可以用std::vector。 _square.h: #ifnd
Cython封装C++代码示例
03-22
参考Cython官方文档编写而来的一个Cython封装C++的示例demo，可入门学习。
Python3.X使用Cython调用C/C++
huachao1001的专栏
03-07 7638
1 创建C++代码 假设我们需要让Python调用的C++代码如下(文件名为demo.h)： #ifndef DEMO_H #define DEMO_H using namespace std; namespace demo { class MyDemo { public: int a; MyDemo(); ...
Cython--使用Cython封装C++代码（四）
a1040193597的博客
10-04 1968
Using C++ in Cython Cython对C++语言的大部分特性都支持,例如: 可以通过new和del关键字在堆区动态创建和消耗对象 可以在栈区创建对象 也可以通过Cython提供的cppclass关键字声明类类型 Cython支持函数模板(template function)和类模板(template class)，函数重载 Cython支持C++操作符重载(eg: operato...
Cython基础教程(五) -用cython包装C++库
JohnSon
08-25 1592
用cython包装C++库 假设有一个简单的生成随机数的类， 提供了一下接口 namespace mtrandom { const static unsigned int N = 624; class MT_RNG { public: MT_RNG(); MT_RNG(unsigned long s); MT_RNG(unsigned l...
Learning Cython Programming.gz_Cython C++_cython_learning python
09-15
cython入门学习手册，用来指导蒋c语言写的程序扩展成python的模块
Anaconda下的Jupyter Notebook中使用Cython
01-06
Anaconda下的Jupyter Notebook中使用CythonCython使用条件使用方法功能快捷键 Cython使用条件 首先要确保有C的编译器，如下网页为相关权威解释，并含有C编译器下载地址： 参考：来自微软的解释和解决方案 如果无此...
talk-cython:使用 cython 进行 GC 优化的示例
06-05
谈话赛通 在帝国理工学院的 Biomedia 小组中进行了演讲，以来自的图形切割代码示例向 cython 展示。 幻灯片可在：
Cython 3.0 中文文档(chm格式)
11-01
python 调用 c 和 c++ 以及生成动态链接库 .so .dll 案头必备
python调用c++函数
weixin_35752122的博客
01-04 1141
Python是一种高级编程语言，它可以调用其他语言编写的函数。在 Python 中调用 C 函数的方法有两种： 使用 Python 提供的 ctypes 库。ctypes 库是一个用于加载动态链接库的库，可以让你在 Python 中调用 C 函数。 使用 ctypes 库调用 C 函数的步骤如下： 使用 ctypes 库中的 CDLL 函数加载 C 函数所在的动态链接库。 使用函数名称获取...
Cython使用，python提供c++接口
Leo_812的博客
07-18 2882
通过cython，用Python提供c++接口
在Python中调用C/C++：cython及pybind11
weixin_44966641的博客
06-20 1886
在Python中调用C/C++：cython及pybind11
Cython基础--Cython的类型
I2Cbus的专栏
01-18 9048
Cython的类型 1 类型定义 1.1 定义一个C变量： 1.1.1 在Cython里定义一个C变量和C语言类似，不同的地方就是在声明的最前面要加上cdef,另外，末尾不用加分号";“如： cdef int an[10] cdef int n = 123 cdef int *pn = &n printf("%d \n",pn[0])         1.1.2 这里要注意
【Python】C++ & Python 混合编程（3）-- Python 调用 C++（Cython）
zizi7的专栏
02-08 2180
如文章《加速python，保护你的源代码 》所述，”Cython是Python的一个扩展模块，主要功能是将Python代码编译成C/C++，然后再编译成Python扩展（Windows下为.pyd，Linux下为.so）” 其主要作用是： 隐藏 Python 源代码 加速 Cython 可以通过 cdef、cpdef等声明静态变量，获得更高的效率提升 详细的官方开发文档 使用...
python调用c++_python高性能编程之Cython篇 第一章
weixin_39899021的博客
12-07 321
第一节 cython的潜能 •Cython是一种编程语言，它将Python与C和C ++的静态类型系统相结合。 •Cython是一个将Cython源代码转换为高效的C或C ++源代码的编译器。然后可以将此源代码编译为Python扩展模块或独立可执行文件。 Cython的强大功能来自它结合了Python和C的方式：感觉就像Python一样，同时提供了对C语言的轻松访问.Cython...
python 调用c++
花生日记
04-09 4740
在这一步中，我们并不需要去关心它具体是如何工作的，我们只需要知道：当我们在文件中定义了一个函数后，就可以向该函数发出调用请求。当这些操作完成后，我们就可以在文件中看到一个名为 explain （）的文件了，它是一个函数库，其中包含了许多不同类型的函数。函数调用，也叫函数调用，是指在程序中使用一个函数的时候，直接从函数地址出发，向目标函数发出一次操作。另外还有一种方法：如果你使用了` find （）`命令搜索到了“C++”这个函数地址，那么你就可以直接在运行时环境中查看该被调用的“C++”这个函数。
c++/python混合编程（一）
qq_41721951的博客
10-11 419
win10环境中在vs2015中实现c++调用python代码 方法一：通过c++API接口 参考：https://blog.csdn.net/sihai12345/article/details/82745350 总结：这种方法可以实现简单的python的代码、函数、类的调用，但是当代码工程较大时，比如一个demo.py代码中导入了多个模块，如下所示，deep_sort文件夹下的代码均为自己编写...
Python调用C++程序的几种方法
热门推荐
ZONGXP的博客
07-20 10万+
本文列举出集中c++代码导出成Python接口的几种基本方法
C++数组和python数组相互转换（pybind11 numpy和指针数据转换） tcy
tcy-阿春
08-30 6175
1.实例：指针-->numpy #include <iostream> #include<pybind11/pybind11.h> #undef max//放在<pybind11/numpy.h>之前（#define NOMINMAX有时不起作用） #include<pybind11/numpy.h> namespace py = pybind11; using namespace py::literals; //*指针-->nump.
cython 使用c++
最新发布
01-13
具体来说，cython将Python代码中的动态类型转换为静态类型，这样在执行时就不需要进行类型检查，从而减少了运行时的开销。 cython的工作原理是通过在Python的代码中添加特定的注释来指示需要转换为C语言的部分。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值