當前位置:首頁 » 編程軟體 » cython編譯python

cython編譯python

發布時間: 2022-11-25 13:20:37

㈠ 如何編譯python使之成為可執行程序

Python是一個強大的工具,可惜不是每個人的計算機裡面都有安裝。當您寫了一個好用的工具。要如何讓那些沒有安裝Python的人使用你的工具呢?
對於這樣一個需要standalone exectuable環境的需求,直到撰寫經驗為止,只看到兩個比較好用且有持續維護的套件。一個是py2exe。另外一個就是本經驗要介紹的PyInstaller。
1
PyInstaller安裝

2

最新版本:PyInstaller 2.0
3

直接「解壓縮」之後即可使用,解壓到您想讓他在的路徑即可
END

PyInstaller配置

1
事先寫好py程序
2

在命令行執行:python Makespec.py --console --onefile NotePad\notepad.py
報錯:Configfile is missing or unreadable. Please run Configure.py before building
3

在命令行執行:Configure.py
報錯:Python 2.6+ on Windows support needs pywin32,Please install http://sourceforge.net/projects/pywin32/
4

安裝最新版本的 pywin32-217.win32-py2.7.exe
END

PyInstaller使用

命令行中運行
目錄切換到PyInstaller的安裝目錄「E:\pyinstaller-1.5\pyinstaller-1.

在PyInstaller的安裝目錄下新建一個文件夾(比如NotePad), 然後將要轉換的py腳本放到文件夾里(notepad.py)
E:\pyinstaller-1.5\pyinstaller-1.5>python Makespec.py --console --onefile NotePad\notepad.py

E:\pyinstaller-1.5\pyinstaller-1.5>python Build.py NotePad\notepad.spec

驗證exeE:\pyinstaller-1.5\pyinstaller-1.5>

E:\pyinstaller-1.5\pyinstaller-1.5\NotePad\dist\notepad.exe 0 0 100(成功)

查看生成的文件,生成的中間文件spec
查看生成的文件,生成的最終文件exe

END

注意事項

在轉換之前要確保py程序可以正常通過
如果轉換過程中出現什麼錯誤,用搜索引擎搜索解決一下

㈡ 如何實現 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放到一個mole里,比如說,這個mole名字叫 great_mole.py

接下來就要用C來調用Python了,完整的代碼如下:
#include <Python.h>

int great_function_from_python(int a) {
int res;
PyObject *pMole,*pFunc;
PyObject *pArgs, *pValue;

/* import */
pMole = PyImport_Import(PyString_FromString("great_mole"));

/* great_mole.great_function */
pFunc = PyObject_GetAttrString(pMole, "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元素,mole、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_mole import great_function
>>> great_function(2)
3

考慮最簡單的情況。我們把功能強大的函數放入C文件 great_mole.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 GreateMoleMethods[] = {
{
"great_function",
_great_function,
METH_VARARGS,
""
},
{NULL, NULL, 0, NULL}
};

PyMODINIT_FUNC initgreat_mole(void) {
(void) Py_InitMole("great_mole", GreateMoleMethods);
}

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

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

出表GreateMoleMethods。它負責告訴Python這個模塊里有哪些函數可以被Python調用。導出表的名字可以隨便起,每一項有4
個參數:第一個參數是提供給Python環境的函數名稱,第二個參數是_great_function,即包裹函數。第三個參數的含義是參數變長,第四個
參數是一個說明性的字元串。導出表總是以{NULL, NULL, 0, NULL}結束。
導出函數initgreat_mole。這個的名字不是任取的,是你的mole名稱添加前綴init。導出函數中將模塊名稱與導出表進行連接。

在Windows下面,在Visual Studio命令提示符下編譯這個文件的命令是
cl /LD great_mole.c /o great_mole.pyd -IC:\Python27\include C:\Python27\libs\python27.lib

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

在Linux下面,則用gcc編譯:
gcc -fPIC -shared great_mole.c -o great_mole.so -I/usr/include/python2.7/ -lpython2.7

在當前目錄下得到great_mole.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_mole.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_mole.pyx
cython great_mole.pyx

得到great_mole.h和great_mole.c。打開great_mole.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_mole.h"

int main(int argc, char *argv[]) {
PyObject *tuple;
Py_Initialize();
initgreat_mole();
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_mole.c -IC:\Python27\include C:\Python27\libs\python27.lib

在Linux下編譯命令為
gcc main.c great_mole.c -o main -I/usr/include/python2.7/ -lpython2.7

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

#great_mole.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_mole.h"

int main(int argc, char *argv[]) {
Py_Initialize();
initgreat_mole();
printf("%c",great_function("Hello",2));
Py_Finalize();
}

在這一部分的最後我們給一個看似實用的應用(僅限於Windows):
還是利用剛才的great_mole.pyx,准備一個dllmain.c:
#include <Python.h>
#include <Windows.h>
#include "great_mole.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_mole();
break;
case DLL_PROCESS_DETACH:
Py_Finalize();
break;
}
return TRUE;
}

在Visual Studio命令提示符下編譯:
cl /LD dllmain.c great_mole.c -IC:\Python27\include C:\Python27\libs\python27.lib

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

參考資料:Cython的官方文檔,質量非常高:
Welcome to Cython』s Documentation

出自:Jerry Jho

㈢ 如何讓 Python 像 Julia 一樣快地運行

使用 Cython 編譯
一種編譯方式是使用 Cython 編譯器。這個編譯器是使用 Python
編寫的。它可以通過以下命令安裝:
pip install Cython
如果使用 Anaconda,安裝會有所不同。因為安裝有點復雜,所以我編寫了一篇相關的博客文章:將 Cython For Anaconda 安裝在 Windows 上
安裝後,我們使用神奇的 %load_ext 將 Cython 載入到 Notebook 中:
%load_ext Cython

然後就可以在我們的 Notebook 中編譯代碼。我們只需要將想要編譯的代碼放在一個單元中,包括所需的導入語句,使用神奇的 %%cython 啟動該單元:
%%cython

def fib_cython(n):
if n<2:
return n
return fib_cython(n-1)+fib_cython(n-2)

執行該單元會無縫地編譯這段代碼。我們為該函數使用一個稍微不同的名稱,以反映出它是使用 Cython
編譯的。當然,一般不需要這么做。我們可以將之前的函數替換為相同名稱的已編譯函數。
對它計時會得到:
1000 loops, best of 3:1.22 ms per loop

哇,幾乎比最初的 Python 代碼快 3 倍!我們現在比使用 BigInt 的 Julia 快 100 倍。
我們還可以嘗試靜態類型。使用關鍵字 cpdef 而不是 def 來聲明該函數。它使我們能夠使用相應的 C 類型來鍵入函數的參數。我們的代碼變成了:
%%cython
cpdef long fib_cython_type(long n):
if n<2:
return n
return fib_cython_type(n-1)+fib_cython_type(n-2)

執行該單元後,對它計時會得到:
10000 loops, best of 3:36 µs per loop

太棒了,我們現在只花費了 36 微秒,比最初的基準測試快約 100 倍!這與 Julia 所花的 80 毫秒相比更出色。
有人可能會說,靜態類型違背了 Python
的用途。一般來講,我比較同意這種說法,我們稍後將查看一種在不犧牲性能的情況下避免這種情形的方法。但我並不認為這是一個問題。Fibonacci
函數必須使用整數來調用。我們在靜態類型中失去的是 Python 所提供的任意精度。對於 Fibonacci,使用 C 類型 long
會限制輸入參數的大小,因為太大的參數會導致整數溢出。
請注意,Julia 計算也是使用 64 位整數執行的,因此將我們的靜態類型版本與 Julia 的對比是公平的。
回頁首
緩存計算
我們在保留 Python 任意精度的情況下能做得更好。fib 函數重復執行同一種計算許多次。例如,fib(20) 將調用 fib(19) 和
fib(18)。fib(19) 將調用 fib(18) 和 fib(17)。結果 fib(18) 被調用了兩次。簡單分析表明,fib(17) 將被調用 3
次,fib(16) 將被調用 5 次,等等。
在 Python 3 中,我們可以使用 functools 標准庫來避免這些重復的計算。
from functools import lru_cache as cache
@cache(maxsize=None)
def fib_cache(n):
if n<2:
return n
return fib_cache(n-1)+fib_cache(n-2)

對此函數計時會得到:
1000000 loops, best of 3:910 ns per loop

速度又增加了 40 倍,比最初的 Python 代碼快約 3,600 倍!考慮到我們僅向遞歸函數添加了一條注釋,此結果非常令人難忘。
Python 2.7 中沒有提供這種自動緩存。我們需要顯式地轉換代碼,才能避免這種情況下的重復計算。
def fib_seq(n):
if n < 2:
return n
a,b = 1,0
for i in range(n-1):
a,b = a+b,a
return a

請注意,此代碼使用了 Python 同時分配兩個局部變數的能力。對它計時會得到:
1000000 loops, best of 3:1.77 µs per loop

我們又快了 20 倍!讓我們在使用和不使用靜態類型的情況下編譯我們的函數。請注意,我們使用了 cdef 關鍵字來鍵入局部變數。
%%cython
def fib_seq_cython(n):
if n < 2:
return n
a,b = 1,0
for i in range(n-1):
a,b = a+b,a
return a
cpdef long fib_seq_cython_type(long n):
if n < 2:
return n
cdef long a,b
a,b = 1,0
for i in range(n-1):
a,b = a+b,b
return a

我們可在一個單元中對兩個版本計時:
%timeit fib_seq_cython(20)
%timeit fib_seq_cython_type(20)

結果為:
1000000 loops, best of 3:953 ns per loop
10000000 loops, best of 3:51.9 ns per loop

靜態類型代碼現在花費的時間為 51.9 納秒,比最初的基準測試快約 60,000(六萬)倍。
如果我們想計算任意輸入的 Fibonacci 數,我們應堅持使用無類型版本,該版本的運行速度快 3,500 倍。還不錯,對吧?
回頁首
使用 Numba 編譯
讓我們使用另一個名為 Numba 的工具。它是針對部分 Python 版本的一個即時
(jit) 編譯器。它不是對所有 Python 版本都適用,但在適用的情況下,它會帶來奇跡。
安裝它可能很麻煩。推薦使用像 Anaconda 這樣的 Python 發行版或一個已安裝了 Numba 的 Docker 鏡像。完成安裝後,我們導入它的 jit 編譯器:
from numba import jit

它的使用非常簡單。我們僅需要向想要編譯的函數添加一點修飾。我們的代碼變成了:
@jit
def fib_seq_numba(n):
if n < 2:
return n
(a,b) = (1,0)
for i in range(n-1):
(a,b) = (a+b,a)
return a

對它計時會得到:
1000000 loops, best of 3:225 ns per loop

比無類型的 Cython 代碼更快,比最初的 Python 代碼快約 16,000 倍!
回頁首
使用 Numpy
我們現在來看看第二項基準測試。它是快速排序演算法的實現。Julia 團隊使用了以下 Python 代碼:
def qsort_kernel(a, lo, hi):
i = lo
j = hi
while i < hi:
pivot = a[(lo+hi) // 2]
while i <= j:
while a[i] < pivot:
i += 1
while a[j] > pivot:
j -= 1
if i <= j:
a[i], a[j] = a[j], a[i]
i += 1
j -= 1
if lo < j:
qsort_kernel(a, lo, j)
lo = i
j = hi
return a

我將他們的基準測試代碼包裝在一個函數中:
import random
def benchmark_qsort():
lst = [ random.random() for i in range(1,5000) ]
qsort_kernel(lst, 0, len(lst)-1)

對它計時會得到:
100 loops, best of 3:18.3 ms per loop

上述代碼與 C 代碼非常相似。Cython 應該能很好地處理它。除了使用 Cython 和靜態類型之外,讓我們使用 Numpy
數組代替列表。在數組大小較大時,比如數千個或更多元素,Numpy 數組確實比
Python 列表更快。
安裝 Numpy 可能會花一些時間,推薦使用 Anaconda 或一個已安裝了 Python 科學工具組合的 Docker 鏡像。
在使用 Cython 時,需要將 Numpy 導入到應用了 Cython 的單元中。在使用 C 類型時,還必須使用 cimport 將它作為 C 模塊導入。Numpy
數組使用一種表示數組元素類型和數組維數(一維、二維等)的特殊語法來聲明。
%%cython
import numpy as np
cimport numpy as np
cpdef np.ndarray[double, ndim=1] \
qsort_kernel_cython_numpy_type(np.ndarray[double, ndim=1] a, \
long lo, \
long hi):
cdef:
long i, j
double pivot
i = lo
j = hi
while i < hi:
pivot = a[(lo+hi) // 2]
while i <= j:
while a[i] < pivot:
i += 1
while a[j] > pivot:
j -= 1
if i <= j:
a[i], a[j] = a[j], a[i]
i += 1
j -= 1
if lo < j:
qsort_kernel_cython_numpy_type(a, lo, j)
lo = i
j = hi
return a
cpdef benchmark_qsort_numpy_cython():
lst = np.random.rand(5000)
qsort_kernel_cython_numpy_type(lst, 0, len(lst)-1)

對 benchmark_qsort_numpy_cython() 函數計時會得到:
1000 loops, best of 3:1.32 ms per loop

我們比最初的基準測試快了約 15 倍,但這仍然不是使用 Python 的最佳方法。最佳方法是使用 Numpy 內置的 sort()
函數。它的默認行為是使用快速排序演算法。對此代碼計時:
def benchmark_sort_numpy():
lst = np.random.rand(5000)
np.sort(lst)

會得到:
1000 loops, best of 3:350 µs per loop

我們現在比最初的基準測試快 52 倍!Julia 在該基準測試上花費了 419 微秒,因此編譯的 Python 快 20%。
我知道,一些讀者會說我不會進行同類比較。我不同意。請記住,我們現在的任務是使用主機語言以最佳的方式排序輸入數組。在這種情況下,最佳方法是使用一個內置的函數。

㈣ cython 需要 c 基礎嗎

還可以使用Cython來實現混編
1 Cython,用Python setup.py install進行安裝
2 一個實例

① 創建helloworld目錄創建helloworld.pyx,內容如下:cdef extern from"stdio.h": extern int printf(const char *format, ) def SayHello(): printf("hello,world\n")
② 編譯,最方便的是利用python的Distutils了,
helloworld目錄下創建Setup.py,內容如下:from distutils.core import setupfrom distutils.extension import Extensionfrom Cython.Build import cythonize setup( name = 'helloworld', ext_moles=cythonize([ Extension("helloworld", ["helloworld.pyx"]), ]),) 編譯:python Setup.py build安裝:python Setup.py install安裝後,會將在build/lib.???目錄下生成的helloworld.pyd拷貝到Lib/site-packages註: 有時我們只是希望測試一下,並不希望安裝,這時可以把build/lib.???目錄下的helloworld.pyd拷貝到當前目錄 或者在importhelloworld前執行腳本:import sys;sys.path.append(pathof helloworld.pyd) ③ 測試:>>>import helloworld >>>helloworld.SayHello() hello,world

㈤ cython編譯為可執行文件,目標機器上不用安裝Python環境就可以執行

本來就是腳本語言,要做窗口程序的話用C#,VB,再不用易語言也可以
python,lua之類的這方面都有各種弊端

㈥ 通過Cython打包py文件,生成包含pyd的wheel(.whl)

setup.py寫法,參考 這里
linux:

windows:

在cython3上線之前,windows下編譯init始終有個問題:

這個問題是當前cython對windows包支持不好導致的,可以使用 如下方法 修復:
打開cython安裝目錄:

打開 安裝目錄\cython\Compiler\MoleNode.py ,替換如下內容:

替換為

然後刪除項目build下的文件夾,重新buid就行了
python setup.py bdist_wheel

㈦ Python為什麼能擴展

Python 具有高可擴展性,存在許多使用 C 語言或 Fortran 編寫擴展的方法。必要時,Python 代碼可以直接將這些擴展作為子常式來調用。這部分討論用於構建擴展的一些主要編譯器(絕對不是完整列表)。

相關推薦:《Python基礎教程》

Cython

Cython(不同於 CPython)既是指一種語言,也是指一種編譯器。Cython 語言是添加了 C 語言語法的 Python 語言的超集。Cython 可以在代碼段或完整函數中顯式釋放 GIL。變數和類屬性上的 C 類型聲明以及對 C 函數的調用都使用 C 語法。其餘部分代碼則使用 Python 語法。通過這個混合的 Cython 代碼,Cython 編譯器可生成高效的 C 代碼。任何定期優化的 C/C++ 編譯器都可以編譯此 C 代碼,從而高度優化擴展的運行時代碼,性能接近於原生的 C 代碼性能。

Numba

Numba 是一個動態、即時 (JIT) 且可感知 NumPy 的 Python 編譯器。Numba 使用 LLVM 編譯器基礎架構,生成優化的機器代碼和從 Python 調用代碼的包裝器。與 Cython 不同,編碼使用常規的 Python 語言。Numba 可讀取來自裝飾器中所嵌入注釋的類型信息,並優化代碼。對於使用 NumPy 數據結構的程序,比如數組以及許多數學函數,它可以實現與 C 或 Fortran 語言類似的性能。NumPy 對線性代數和矩陣函數使用硬體加速,利用 LAPACK 和 BLAS 提供額外加速,大大提升了性能,參見 IBM 博客文章C、Julia、Python、Numba 和 Cython 在 LU 因式分解方面的速度比較。

除 CPU 以外,Numba 還能夠使用 GP-GPU 後端。Anaconda, Inc. 是 Python 某個主要發行版的幕後公司,該公司還開發了 Numba 和商業版的 Numba Pro。

Fortran to Python Interface Generator

Fortran to Python Interface Generator (F2Py) 起初為一個獨立的程序包,現在包含在 NumPy 中。F2Py 支持 Python 調用以 Fortran 編寫的數值常式,就好像它們是另一個 Python 模塊一樣。因為 Python 解釋器無法理解 Fortran 源代碼,所以 F2Py 以動態庫文件格式將 Fortran 編譯為本機代碼,這是一種共享對象,包含具有 Python 模塊介面的函數。因此,Python 可以直接將這些函數作為子常式來調用,以原生 Fortran 代碼的速度和性能來執行。

㈧ python和cython是什麼關系

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中,以方便開發人員。

㈨ cython和python的區別

cython是用c寫的python實現
Cython是不同的語言,相當於Python再加上些C特性,比如說類型聲明。

㈩ Python編譯器推薦

1、CPython
是Python語言規范的參考實現,能夠優先獲得Python語言的最新、最強的功能,CPython是由C語言編寫而成,不但可以從Python代碼中調用C代碼的函數,還可以直接在Python中使用大量現有的C代碼庫。
2、Brython
Brython可用於在瀏覽器中運行包含了Python 3腳本的Web應用。
3、PyPy Python
雖然第一個推薦的是在Python中使用最廣泛的編譯器,但卻不是最快的,PyPy採用的是即時的編譯概念,在代碼執行前,就直接編譯為機器代碼,因此其執行速度提高了近4倍。
4、Jython或JPython
使用率第二高,Jython最初被稱為JPython,是通過Python語言來實現Java虛擬機的,開發者既可以將現有的Java包和代碼庫,導入自己的Python程序中,還可以在Java程序中嵌入Python腳本。
5、Cython
Cython與CPython不同,更像是一個超集,允許開發者在代碼中結合C和Python,從而生成C語言代碼類型的輸出,以供任何一種C/C++編譯器進行後續編譯。
6、Skulpt
流行的速度非常快,主要目的是提供一種良好的在線式Python編譯器,也可以通過讓Web應用引擎包含Skulpt,以方便開發者編寫出被用於前端的Python腳本。
7、PyJS
是另一款完全用Python去開發Web應用的編譯工具,在後台,PyJS會在使用內置的Ajax框架之前,將Python代碼編譯為JavaScript。
8、WinPython
是Python的"即用型"發行版,也就意味著用戶無需安裝,即可在Windows
PC上運行,作為另一種Python的實現,WinPython編譯器不僅帶來了Python執行環境,而且還包含了諸如:Scipy、Numpy、以及Pandas等各種Python庫。

熱點內容
lovelive腳本 發布:2022-12-06 17:36:43 瀏覽:746
絕地戰警ftp 發布:2022-12-06 17:35:13 瀏覽:754
配置混凝土時可以節約水泥措施的是什麼 發布:2022-12-06 17:30:52 瀏覽:186
如何在伺服器上加個盾 發布:2022-12-06 17:29:52 瀏覽:507
腳本預載入 發布:2022-12-06 17:29:00 瀏覽:865
解壓縮包王 發布:2022-12-06 17:27:50 瀏覽:117
龍少腳本 發布:2022-12-06 17:26:51 瀏覽:674
java方法中的方法 發布:2022-12-06 17:24:48 瀏覽:196
php教程峰 發布:2022-12-06 17:13:42 瀏覽:654
奧維地圖文件夾 發布:2022-12-06 17:12:50 瀏覽:527