python里的cdef是什麼的簡單介紹

本文目錄一覽：

1、python怎麼使用cython
2、python 里def什麼意思
3、cython與python的不同有哪些
4、python參數傳遞是值傳遞還是引用傳遞
5、如何實現 C/C++ 與 Python 的通信

python怎麼使用cython

1. Cython是什麼？

它是一個用來快速生成Python擴展模塊(extention module)的工具

語法是Python和c的混血

Cython作為一個Python的編譯器，在科學計算方面很流行，用於提高Python的速度，通過OpenMPI庫還可以進行吧並行計算。

2. Cython安裝（Windows）

我的環境是win7 x64, python27, vs2010

安裝的基礎是有一個c編譯器（這裡以vs2010為例）

從下載安裝包，解壓到一目錄，進入該目錄，在cmd命令行中執行

python setup.py install

註：執行過程可能遇到問題：Windows下pip安裝包報錯：Microsoft Visual C++ 9.0 is required Unable to find vcvarsall.bat

解決方案：下載Microsoft Visual C++ Compiler for Python 2.7，點擊直接安裝即可。

3. 例子

例3.1：入門

創建hello.pyx，內容如下

def say_hello():

print “Hello World!”

創建setup.py，內容如下

from distutils.core import setup

from Cython.Build import cythonize

setup(name = ‘Hello world app’,

ext_modules = cythonize(“hello.pyx”))

編譯Cython代碼

step1: 把.pyx文件被Cython便以為.c文件

step2: 把.c文件編譯為可導入的使用模塊.so(Windows下為.pyd)文件

python setup.py build

python setup.py install

註：可能出現問題：Unable to find vcvarsall.bat

原因：Python 2.7 會搜索 Visual Studio 2008.如果你電腦上沒有這個版本的話就會報錯。

如果裝的是vs2010，那麼在cmd命令行中執行

SET VS90COMNTOOLS=%VS100COMNTOOLS%

如果裝的是vs2010，那麼在cmd命令行中執行　

SET VS90COMNTOOLS=%VS110COMNTOOLS%

執行

import hello

hello.say_hello()

Hello World!

例3.2 通過靜態類型提高速度

在Cython中可以通過標記靜態類型來提高速度，凡是標記為靜態類型的部分都會將動態語言類型變為簡單的c代碼，從而提速。

但是如果濫用靜態類型，會降低可讀性，甚至因類型設置不當導致錯誤類型檢查造成速度降低。

例3.2.1 靜態類型變量

Python原生態代碼

compute.pyx

def f(x):

return x ** 2 – x

def integrate_f(a, b, N):

s = 0

dx = (b – a) / N

for i in range(N):

x += f(a + i * dx)

return s * dx

setup.py

from distutils.core import setup

from Cython.Build import cythonize

setup(

name = ‘Hello world app’,

ext_modules = cythonize(“compute.pyx”),

)

test.py

import compute

import time

starttime = time.clock()

compute.integrate_f(3.2, 6.9, 1000000)

endtime = time.clock()

print “read: %f s” %(endtime – starttime）

執行

python setup.py build

python setup.py install

python test.py

結果

read: 0.332332 s

使用靜態變量替換後的代碼

compute2.pyx

def f(double x):

return x ** 2 – x

def integrate_f(double a, double b, int N):

cdef int i

cdef double s, dx

s = 0

dx = (b – a) / N

for i in range(N):

s += f(a + i * dx)

return s * d

setup2.py

from distutils.core import setup

from Cython.Build import cythonize

setup(

name = ‘Hello world app’,

ext_modules = cythonize(“compute2.pyx”),

)

test2.py

import compute2

import time

starttime = time.clock()

compute2.integrate_f(3.2, 6.9, 1000000)

endtime = time.clock()

print “read: %f s” %(endtime – starttime)

執行

python setup.py build

python setup.py install

python test.py

結果

read: 0.109200s

結論

該測試用例，使用靜態類型速度是不使用靜態類型的3倍。

例3.2.2 靜態類型函數

把compute2.pyx中的函數變為

cdef double f(double x):

return x ** 2 – x

def integrate_f(double a, double b, int N):

cdef int i

cdef double s, dx

s = 0

dx = (b – a) / N

for i in range(N):

s += f(a + i * dx)

return s * dx

結果

read: 0.084859 s

結論：比例子3.2.1速度又快了

例3.3 調用C函數

cdef extern from “math.h”:

double sin(double)

double cos(double)

cpdef double Sin(double x):

return sin(x)

cpdef double Cos(double x):

return cos(x)

cpdef: 對於Python可使用的函數使用（為了使得在以後的Python程序中調用Sin，Cos函數，用cpdef，而不用cdef）

cdef: 對於C可使用的函數使用

請注意，上面的代碼聲明了 math.h 里的函數，提供給 Cython 使用。C編譯器在編譯時將會看到 math.h 的聲明，但 Cython 不會去分析 math.h 和單獨的定義。

python 里def什麼意思

定義方法的關鍵字，聲明一個方法

def func1(var1,var2):

print var1,var2

func1(“Hello”,”World”)

cython與python的不同有哪些

Cython是Python的一個超集，結合了Python的易用性和原生代碼的速度，可以編譯成C語言，產生的性能提升可以從幾個百分點到幾個數量級，具體取決於手頭的任務。

使用Cython，你可以避開Python的許多原生限制，或者完全超越Python，而無需放棄Python的簡便性和便捷性。

Python代碼可以直接調用C模塊。這些C模塊可以是通用的C庫或專門為Python工作的庫。Cython生成第二種類型的模塊：與Python內部對話的C庫，可以與現有的Python代碼綁定在一起。

Cython代碼在設計上看起來很像Python代碼。如果你給Cython編譯器提供了一個Python程序，它將會按原樣接受它，但是Cython的原生加速器都不會起作用。但是如果你用Cython的特殊語法來修飾Python代碼，那麼Cython就可以用快速的C代替慢的Python對象。

請注意，Cython的方法是漸進的。這意味着開發人員可以從現有的Python應用程序開始，通過對代碼立刻進行更改來加快速度，而不是從頭開始重寫整個應用程序。

這種方法通常與軟件性能問題的性質相吻合。在大多數程序中，絕大多數CPU密集型代碼都集中在一些熱點上，也就是帕累托原則的一個版本，也被稱為「80/20」規則。因此，Python應用程序中的大部分代碼不需要進行性能優化，只需要幾個關鍵部分。你可以逐漸將這些熱點轉換為Cython，從而獲得你最需要的性能提升。程序的其餘部分可以保留在Python中，以方便開發人員。

python參數傳遞是值傳遞還是引用傳遞

首先還是應該科普下函數參數傳遞機制，傳值和傳引用是什麼意思？

函數參數傳遞機制問題在本質上是調用函數（過程）和被調用函數（過程）在調用發生時進行通信的方法問題。基本的參數傳遞機制有兩種：值傳遞和引用傳遞。

值傳遞（passl-by-value）過程中，被調函數的形式參數作為被調函數的局部變量處理，即在堆棧中開闢了內存空間以存放由主調函數放進來的實參的值，從而成為了實參的一個副本。值傳遞的特點是被調函數對形式參數的任何操作都是作為局部變量進行，不會影響主調函數的實參變量的值。

引用傳遞(pass-by-reference)過程中，被調函數的形式參數雖然也作為局部變量在堆棧中開闢了內存空間，但是這時存放的是由主調函數放進來的實參變量的地址。被調函數對形參的任何操作都被處理成間接尋址，即通過堆棧中存放的地址訪問主調函數中的實參變量。正因為如此，被調函數對形參做的任何操作都影響了主調函數中的實參變量。

在python中實際又是怎麼樣的呢？

先看一個簡單的例子：

from ctypes import *import os.path

import sysdef test(c): print “test before “

print id(c)

c+=2 print “test after +”

print id(c) return cdef printIt(t): for i in range(len(t)): print t[i]if __name__==”__main__”:

a=2 print “main before invoke test”

print id(a)

n=test(a) print “main afterf invoke test”

print a print id(a)

運行後結果如下：

main before invoke test39601564test before

39601564test after +

39601540main afterf invoke test2

39601564

id函數可以獲得對象的內存地址.很明顯從上面例子可以看出，將a變量作為參數傳遞給了test函數，傳遞了a的一個引用，把a的地址傳遞過去了，所以在函數內獲取的變量C的地址跟變量a的地址是一樣的，但是在函數內，對C進行賦值運算，C的值從2變成了4，實際上2和4所佔的內存空間都還是存在的，賦值運算後，C指向4所在的內存。而a仍然指向2所在的內存，所以後面打印a，其值還是2.

如果還不能理解，先看下面例子

a=1

b=1

id(a)

40650152

id(b)

40650152

a=2

id(a)

40650140

a和b都是int類型的值，值都是1，而且內存地址都是一樣的，這已經表明了在python中，可以有多個引用指向同一個內存（畫了一個很挫的圖，見諒），在給a賦值為2後，再次查看a的內存地址，都已經變化了

而基於最前面的例子，大概可以這樣描述：

那python函數傳參就是傳引用？然後傳參的值在被調函數內被修改也不影響主調函數的實參變量的值？再來看個例子。

from ctypes import *import os.path

import sysdef test(list2): print “test before “

print id(list2)

list2[1]=30 print “test after +”

print id(list2) return list2def printIt(t): for i in range(len(t)): print t[i]if __name__==”__main__”:

list1=[“loleina”,25,’female’] print “main before invoke test”

print id(list1)

list3=test(list1) print “main afterf invoke test”

print list1 print id(list1)

實際值為：

main before invoke test64129944test before

64129944test after +

64129944main afterf invoke test

[‘loleina’, 30, ‘female’]64129944

發現一樣的傳值，而第二個變量居然變化，為啥呢？

實際上是因為python中的序列：列表是一個可變的對象，就基於list1=[1,2] list1[0]=[0]這樣前後的查看list1的內存地址，是一樣的。

list1=[1,2] id(list1)64185208

list1[0]=[0] list1

[[0], 2] id(list1)64185208

結論：python不允許程序員選擇採用傳值還是傳引用。Python參數傳遞採用的肯定是「傳對象引用」的方式。這種方式相當於傳值和傳引用的一種綜合。如果函數收到的是一個可變對象（比如字典或者列表）的引用，就能修改對象的原始值－－相當於通過「傳引用」來傳遞對象。如果函數收到的是一個不可變對象（比如數字、字符或者元組）的引用，就不能直接修改原始對象－－相當於通過「傳值’來傳遞對象。

如何實現 C/C++ 與 Python 的通信

屬於混合編程的問題。較全面的介紹一下，不僅限於題主提出的問題。

以下討論中，Python指它的標準實現，即CPython（雖然不是很嚴格）

本文分4個部分

C/C++ 調用 Python （基礎篇）— 僅討論Python官方提供的實現方式

Python 調用 C/C++ （基礎篇）— 僅討論Python官方提供的實現方式

C/C++ 調用 Python （高級篇）— 使用 Cython

Python 調用 C/C++ （高級篇）— 使用 SWIG

練習本文中的例子，需要搭建Python擴展開發環境。具體細節見搭建Python擴展開發環境 – 蛇之魅惑 – 知乎專欄

1 C/C++ 調用 Python（基礎篇）

Python 本身就是一個C庫。你所看到的可執行體python只不過是個stub。真正的python實體在動態鏈接庫里實現，在Windows平台上，這個文件位於 %SystemRoot%\System32\python27.dll。

你也可以在自己的程序中調用Python，看起來非常容易：

//my_python.c

#include Python.h

int main(int argc, char *argv[])

{

Py_SetProgramName(argv[0]);

Py_Initialize();

PyRun_SimpleString(“print ‘Hello Python!’\n”);

Py_Finalize();

return 0;

}

在Windows平台下，打開Visual Studio命令提示符，編譯命令為

cl my_python.c -IC:\Python27\include C:\Python27\libs\python27.lib

在Linux下編譯命令為

gcc my_python.c -o my_python -I/usr/include/python2.7/ -lpython2.7

在Mac OS X 下的編譯命令同上

產生可執行文件後，直接運行，結果為輸出

Hello Python!

Python庫函數PyRun_SimpleString可以執行字符串形式的Python代碼。

雖然非常簡單，但這段代碼除了能用C語言動態生成一些Python代碼之外，並沒有什麼用處。我們需要的是C語言的數據結構能夠和Python交互。

下面舉個例子，比如說，有一天我們用Python寫了一個功能特彆強大的函數：

def great_function(a):

return a + 1

接下來要把它包裝成C語言的函數。我們期待的C語言的對應函數應該是這樣的：

int great_function_from_python(int a) {

int res;

// some magic

return res;

}

首先，復用Python模塊得做『import』，這裡也不例外。所以我們把great_function放到一個module里，比如說，這個module名字叫 great_module.py

接下來就要用C來調用Python了，完整的代碼如下：

#include Python.h

int great_function_from_python(int a) {

int res;

PyObject *pModule,*pFunc;

PyObject *pArgs, *pValue;

/* import */

pModule = PyImport_Import(PyString_FromString(“great_module”));

/* great_module.great_function */

pFunc = PyObject_GetAttrString(pModule, “great_function”);

/* build args */

pArgs = PyTuple_New(1);

PyTuple_SetItem(pArgs,0, PyInt_FromLong(a));

/* call */

pValue = PyObject_CallObject(pFunc, pArgs);

res = PyInt_AsLong(pValue);

return res;

}

從上述代碼可以窺見Python內部運行的方式：

所有Python元素，module、function、tuple、string等等，實際上都是PyObject。C語言里操縱它們，一律使用PyObject *。

Python的類型與C語言類型可以相互轉換。Python類型XXX轉換為C語言類型YYY要使用PyXXX_AsYYY函數；C類型YYY轉換為Python類型XXX要使用PyXXX_FromYYY函數。

也可以創建Python類型的變量，使用PyXXX_New可以創建類型為XXX的變量。

若a是Tuple，則a[i] = b對應於 PyTuple_SetItem(a,i,b)，有理由相信還有一個函數PyTuple_GetItem完成取得某一項的值。

不僅Python語言很優雅，Python的庫函數API也非常優雅。

現在我們得到了一個C語言的函數了，可以寫一個main測試它

#include Python.h

int great_function_from_python(int a);

int main(int argc, char *argv[]) {

Py_Initialize();

printf(“%d”,great_function_from_python(2));

Py_Finalize();

}

編譯的方式就用本節開頭使用的方法。

在Linux/Mac OSX運行此示例之前，可能先需要設置環境變量：

bash:

export PYTHONPATH=.:$PYTHONPATH

csh:

setenv PYTHONPATH .:$PYTHONPATH

2 Python 調用 C/C++（基礎篇）

這種做法稱為Python擴展。

比如說，我們有一個功能強大的C函數：

int great_function(int a) {

return a + 1;

}

期望在Python里這樣使用：

from great_module import great_function

great_function(2)

考慮最簡單的情況。我們把功能強大的函數放入C文件 great_module.c 中。

#include Python.h

int great_function(int a) {

return a + 1;

}

static PyObject * _great_function(PyObject *self, PyObject *args)

{

int _a;

int res;

if (!PyArg_ParseTuple(args, “i”, _a))

return NULL;

res = great_function(_a);

return PyLong_FromLong(res);

}

static PyMethodDef GreateModuleMethods[] = {

{

“great_function”,

_great_function,

METH_VARARGS,

“”

{NULL, NULL, 0, NULL}

};

PyMODINIT_FUNC initgreat_module(void) {

(void) Py_InitModule(“great_module”, GreateModuleMethods);

}

除了功能強大的函數great_function外，這個文件中還有以下部分：

包裹函數_great_function。它負責將Python的參數轉化為C的參數（PyArg_ParseTuple），調用實際的great_function，並處理great_function的返回值，最終返回給Python環境。

導

出表GreateModuleMethods。它負責告訴Python這個模塊里有哪些函數可以被Python調用。導出表的名字可以隨便起，每一項有4

個參數：第一個參數是提供給Python環境的函數名稱，第二個參數是_great_function，即包裹函數。第三個參數的含義是參數變長，第四個

參數是一個說明性的字符串。導出表總是以{NULL, NULL, 0, NULL}結束。

導出函數initgreat_module。這個的名字不是任取的，是你的module名稱添加前綴init。導出函數中將模塊名稱與導出表進行連接。

在Windows下面，在Visual Studio命令提示符下編譯這個文件的命令是

cl /LD great_module.c /o great_module.pyd -IC:\Python27\include C:\Python27\libs\python27.lib

/LD 即生成動態鏈接庫。編譯成功後在當前目錄可以得到 great_module.pyd（實際上是dll）。這個pyd可以在Python環境下直接當作module使用。

在Linux下面，則用gcc編譯：

gcc -fPIC -shared great_module.c -o great_module.so -I/usr/include/python2.7/ -lpython2.7

在當前目錄下得到great_module.so，同理可以在Python中直接使用。

本部分參考資料

《Python源碼剖析-深度探索動態語言核心技術》是系統介紹CPython實現以及運行原理的優秀教程。

Python 官方文檔的這一章詳細介紹了C/C++與Python的雙向互動Extending and Embedding the Python Interpreter

關於編譯環境，本文所述方法僅為出示原理所用。規範的方式如下：3. Building C and C++ Extensions with distutils

作為字典使用的官方參考文檔 Python/C API Reference Manual

用以上的方法實現C/C++與Python的混合編程，需要對Python的內部實現有相當的了解。接下來介紹當前較為成熟的技術Cython和SWIG。

3 C/C++ 調用 Python（使用Cython）

在

前面的小節中談到，Python的數據類型和C的數據類型貌似是有某種「一一對應」的關係的，此外，由於Python（確切的說是CPython）本身是

由C語言實現的，故Python數據類型之間的函數運算也必然與C語言有對應關係。那麼，有沒有可能「自動」的做替換，把Python代碼直接變成C代碼

呢？答案是肯定的，這就是Cython主要解決的問題。

安裝Cython非常簡單。Python 2.7.9以上的版本已經自帶easy_install：

easy_install -U cython

在Windows環境下依然需要Visual

Studio，由於安裝的過程需要編譯Cython的源代碼，故上述命令需要在Visual

Studio命令提示符下完成。一會兒使用Cython的時候，也需要在Visual

Studio命令提示符下進行操作，這一點和第一部分的要求是一樣的。

繼續以例子說明：

#great_module.pyx

cdef public great_function(a,index):

return a[index]

這其中有非Python關鍵字cdef和public。這些關鍵字屬於Cython。由於我們需要在C語言中使用

「編譯好的Python代碼」，所以得讓great_function從外面變得可見，方法就是以「public」修飾。而cdef類似於Python的

def，只有使用cdef才可以使用Cython的關鍵字public。

這個函數中其他的部分與正常的Python代碼是一樣的。

接下來編譯 great_module.pyx

cython great_module.pyx

得到great_module.h和great_module.c。打開great_module.h可以找到這樣一句聲明：

__PYX_EXTERN_C DL_IMPORT(PyObject) *great_function(PyObject *, PyObject *)

寫一個main使用great_function。注意great_function並不規定a是何種類型，它的

功能只是提取a的第index的成員而已，故使用great_function的時候，a可以傳入Python

String，也可以傳入tuple之類的其他可迭代類型。仍然使用之前提到的類型轉換函數PyXXX_FromYYY和PyXXX_AsYYY。

//main.c

#include Python.h

#include “great_module.h”

int main(int argc, char *argv[]) {

PyObject *tuple;

Py_Initialize();

initgreat_module();

printf(“%s\n”,PyString_AsString(

great_function(

PyString_FromString(“hello”),

PyInt_FromLong(1)

)

));

tuple = Py_BuildValue(“(iis)”, 1, 2, “three”);

printf(“%d\n”,PyInt_AsLong(

great_function(

tuple,

PyInt_FromLong(1)

)

));

printf(“%s\n”,PyString_AsString(

great_function(

tuple,

PyInt_FromLong(2)

)

));

Py_Finalize();

}

編譯命令和第一部分相同：

在Windows下編譯命令為

cl main.c great_module.c -IC:\Python27\include C:\Python27\libs\python27.lib

在Linux下編譯命令為

gcc main.c great_module.c -o main -I/usr/include/python2.7/ -lpython2.7

這個例子中我們使用了Python的動態類型特性。如果你想指定類型，可以利用Cython的靜態類型關鍵字。例子如下：

#great_module.pyx

cdef public char great_function(const char * a,int index):

return a[index]

cython編譯後得到的.h里，great_function的聲明是這樣的：

__PYX_EXTERN_C DL_IMPORT(char) great_function(char const *, int);

很開心對不對！

這樣的話，我們的main函數已經幾乎看不到Python的痕迹了：

//main.c

#include Python.h

#include “great_module.h”

int main(int argc, char *argv[]) {

Py_Initialize();

initgreat_module();

printf(“%c”,great_function(“Hello”,2));

Py_Finalize();

}

在這一部分的最後我們給一個看似實用的應用（僅限於Windows）：

還是利用剛才的great_module.pyx，準備一個dllmain.c：

#include Python.h

#include Windows.h

#include “great_module.h”

extern __declspec(dllexport) int __stdcall _great_function(const char * a, int b) {

return great_function(a,b);

}

BOOL WINAPI DllMain(HINSTANCE hinstDLL,DWORD fdwReason,LPVOID lpReserved) {

switch( fdwReason ) {

case DLL_PROCESS_ATTACH:

Py_Initialize();

initgreat_module();

break;

case DLL_PROCESS_DETACH:

Py_Finalize();

break;

}

return TRUE;

}

在Visual Studio命令提示符下編譯：

cl /LD dllmain.c great_module.c -IC:\Python27\include C:\Python27\libs\python27.lib

會得到一個dllmain.dll。我們在Excel裏面使用它，沒錯，傳說中的Excel與Python混合編程：

參考資料：Cython的官方文檔，質量非常高：

Welcome to Cython』s Documentation

出自：Jerry Jho

原創文章，作者：簡單一點，如若轉載，請註明出處：https://www.506064.com/zh-hk/n/128367.html

python里的cdef是什麼的簡單介紹

本文目錄一覽：

python怎麼使用cython

python 里def什麼意思

cython與python的不同有哪些

python參數傳遞是值傳遞還是引用傳遞

如何實現 C/C++ 與 Python 的通信

相關推薦

發表回復