先编译在运行

from distutils.core import setup, Extension

from Cython.Build import cythonize

import numpy

setup(ext_modules = cythonize(Extension(

    'dot_cython',

    sources=['dot_cython.pyx'],

    language='c',

    include_dirs=[numpy.get_include()],

    library_dirs=[],

    libraries=[],

    extra_compile_args=[],

    extra_link_args=[]

)))

# dot_cython.pyx
import numpy as np
cimport numpy as np
cimport cython

@cython.boundscheck(False)
@cython.wraparound(False)
cdef np.ndarray[np.float32_t, ndim=2] _naive_dot(np.ndarray[np.float32_t, ndim=2] a, np.ndarray[np.float32_t, ndim=2] b):
    cdef np.ndarray[np.float32_t, ndim=2] c
    cdef int n, p, m
    cdef np.float32_t s
    if a.shape[1] != b.shape[0]:
        raise ValueError('shape not matched')
    n, p, m = a.shape[0], a.shape[1], b.shape[1]
    c = np.zeros((n, m), dtype=np.float32)
    for i in xrange(n):
        for j in xrange(m):
            s = 0
            for k in xrange(p):
                s += a[i, k] * b[k, j]
            c[i, j] = s
    return c

def naive_dot(a, b):
    return _naive_dot(a, b)

python setup.py build_ext --inplace

from distutils.core import setup

from distutils.extension import Extension

from Cython.Build import cythonize

 

setup(

  name = 'helloworld',

  ext_modules=cythonize([

    Extension("helloworld", ["helloworld.pyx"]),

    ]),

)

 

 

编译：

python Setup.py build

安装：

python Setup.py install

安装后，会将在build/lib.???目录下生成的helloworld.pyd拷贝到Lib/site-packages

测试：

>>>import helloworld

>>>helloworld.SayHello()

hello,world

4.2 其次就是可以自己写Makefile进行编译

写Makefile的好处就是可以知道编译的实质：

下面是用于Windows下编译的Makefile，Makefile内容如下:

ALL :helloworld.pyd

helloworld.c : helloworld.pyx

     cython -o helloworld.c helloworld.pyx

helloworld.obj :helloworld.c

     cl -c -Id:\python27\include helloworld.c

helloworld.pyd :helloworld.obj

     link /DLL /LIBPATH:d:\python27\libshelloworld.obj /OUT:helloworld.pyd

 

执行命令:

set PATH=D:\Python27\Scripts;%PATH%

nmake

 

进行编译，会在根目录下生成helloworld.pyd

linux下的Makefile和Windows下的类似，只是编译器不同而己，另外，生成的文件名为:helloworld.so，而不是helloworld.pyd

cpython语法

 

CPython-Tutorial-zh
中文CPython教程
简述
Python有时候太慢，如果手动编译C或者是C++来写#include<Python.h>的文件也比较麻烦。

CPython无疑是一个比较好的选择。

这篇教程是基于

https://cython.readthedocs.io/en/latest/src/tutorial/cython_tutorial.html

同时也参考了 http://docs.cython.org/en/latest/
但我会在这个的基础上做一些补充。

同样，这个项目，我会持续更新到github上
https://github.com/Sean16SYSU/CPython-Tutorial-zh


改进的理由

来源于link1的


每一行的计算量很少，因此python解释器的开销就会变的很重要。
数据的局部性原理：很可能是，当使用C的时候，更多的数据可以塞进CPU的cache中，因为Python的元素都是Object，而每个Object都是通过字典实现的，cache对这个数据不很友好。

项目
Hello World项目
第一个项目是Hello world。
创建一个文件helloworld.pyx，内容如下：
print("Hello world!")

保存后，创建setup.py文件，内容如下：
from distutils.core import setup
from Cython.Build import cythonize

setup(
    ext_modules = cythonize("helloworld.pyx")
)

保存后，命令行进入setup.py所在目录，并输入python setup.py build_ext --inplace，如下：
PS D:\Code\CPython\Test> python setup.py build_ext --inplace
Compiling helloworld.pyx because it changed.
[1/1] Cythonizing helloworld.pyx
running build_ext
building 'helloworld' extension
creating build
creating build\temp.win-amd64-3.6
creating build\temp.win-amd64-3.6\Release
C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Tools\MSVC\14.13.26128\bin\HostX86\x64\cl.exe /c /nologo /Ox /W3 /GL /DNDEBUG /MD -IC:\Users\lijy2\AppData\Local\Programs\Python\Python36\include -IC:\Users\lijy2\AppData\Local\Programs\Python\Python36\include "-IC:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Tools\MSVC\14.13.26128\ATLMFC\include" "-IC:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Tools\MSVC\14.13.26128\include" "-IC:\Program Files (x86)\Windows Kits\NETFXSDK\4.6.1\include\um" "-IC:\Program Files (x86)\Windows Kits\10\include\10.0.16299.0\ucrt" "-IC:\Program Files (x86)\Windows Kits\10\include\10.0.16299.0\shared" "-IC:\Program Files (x86)\Windows Kits\10\include\10.0.16299.0\um" "-IC:\Program Files (x86)\Windows Kits\10\include\10.0.16299.0\winrt" "-IC:\Program Files (x86)\Windows Kits\10\include\10.0.16299.0\cppwinrt" /Tchelloworld.c /Fobuild\temp.win-amd64-3.6\Release\helloworld.obj
helloworld.c
C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Tools\MSVC\14.13.26128\bin\HostX86\x64\link.exe /nologo
/INCREMENTAL:NO /LTCG /DLL /MANIFEST:EMBED,ID=2 /MANIFESTUAC:NO /LIBPATH:C:\Users\lijy2\AppData\Local\Programs\Python\Python36\libs /LIBPATH:C:\Users\lijy2\AppData\Local\Programs\Python\Python36\PCbuild\amd64 "/LIBPATH:C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Tools\MSVC\14.13.26128\ATLMFC\lib\x64" "/LIBPATH:C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Tools\MSVC\14.13.26128\lib\x64" "/LIBPATH:C:\Program Files (x86)\Windows Kits\NETFXSDK\4.6.1\lib\um\x64" "/LIBPATH:C:\Program Files (x86)\Windows Kits\10\lib\10.0.16299.0\ucrt\x64" "/LIBPATH:C:\Program Files (x86)\Windows Kits\10\lib\10.0.16299.0\um\x64" /EXPORT:PyInit_helloworld build\temp.win-amd64-3.6\Release\helloworld.obj /OUT:D:\Code\CPython\Test\helloworld.cp36-win_amd64.pyd /IMPLIB:build\temp.win-amd64-3.6\Release\helloworld.cp36-win_amd64.lib
  正在创建库 build\temp.win-amd64-3.6\Release\helloworld.cp36-win_amd64.lib 和对象 build\temp.win-amd64-3.6\Release\helloworld.cp36-win_amd64.exp
正在生成代码
已完成代码的生成

在该目录下的命令行进入Python操作界面，导入包之后，就会自动输出Hello world!，如下：
PS D:\Code\CPython\Test> python
Python 3.6.6 (v3.6.6:4cf1f54eb7, Jun 27 2018, 03:37:03) [MSC v.1900 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> import helloworld
Hello world!

这就完成了一个简单的CPython的扩展书写。下面再举例子。
Fibonacci Function项目
斐波那契数列：1, 1, 2, 3, 5,…

前两位为1，之后每个数等于前面两个数之和。
创建fib.pyx，内容如下：
from __future__ import print_function

def fib(n):
    a, b = 0, 1
    while b < n:
        print(b, end=' ')
        a, b = b, a + b
    print()

创建setup.py文件，内容如下：
from distutils.core import setup
from Cython.Build import cythonize

setup(
    ext_modules = cythonize("fib.pyx")
)

通过命令python setup.py build_ext --inplace，生成出来的文件：
import fib
fib.fib(100)

输出：
1 1 2 3 5 8 13 21 34 55 89


但是经过测试之后，发现速度并没有很高的提升，很可能是操作本来就很简单，数值也很小，没什么优化的空间了。

Primes项目
给一个数值n，输出前n个质数（list）。
写到primes.pyx中：
def primes(int nb_primes):
    cdef int n, i, len_p
    cdef int p[1000]
    if nb_primes > 1000:
        nb_primes = 1000
    
    len_p = 0
    n = 2
    while len_p < nb_primes:
        for i in p[:len_p]:
            if n % i == 0:
                break
        else:
            p[len_p] = n
            len_p += 1
        n += 1
    result_as_list = [prime for prime in p[:len_p]]
    return result_as_list

同理，setup.py文件内容为：
from distutils.core import setup
from Cython.Build import cythonize

setup(
    ext_modules = cythonize("primes.pyx")
)

在参考的link中给出了测试的案例，有些解释的不太好，我这边描述一下

直接使用Python实现版本，平均用时23ms
Python版本用CPython编译(对，直接把Python文件名字像pyx一样放进去就好了)， 平均用时11ms
pyx的CPython编译版本，平均用时1.6ms

Stat项目
注意，这里不能直接使用stat，因为似乎是有这个库了emmmm
stat_.pyx:
from libc.math cimport sqrt

def mean(list arr):
    cdef:
        int i
        int sz
        double tmp
    tmp = 0
    sz = len(arr)
    for i in range(sz):
        tmp += arr[i]
    return tmp / sz

def std(list arr):
    cdef:
        double m = mean(arr)
        int sz, i
        double tmp
    sz = len(arr)
    tmp = 0
    for i in range(sz):
        tmp += (arr[i] - m) ** 2
    return sqrt(tmp)

setup.py:
from distutils.core import setup
from Cython.Build import cythonize

setup(
    ext_modules = cythonize("stat_.pyx")
)

命令还是一样的：python setup.py build_ext --inplace
测试：
>>> import stat_
>>> a = [1,2,3]
>>> stat_.mean(a)
2.0
>>> stat_.std(a)
1.4142135623730951

广告关闭
腾讯云11.11云上盛惠 ，精选热门产品助力上云，云服务器首年88元起，买的越多返的越多，最高返5000元！
pyobjectcpython 中基本的数据结构是 object，所有的 python 对象都可以用 pyobject * 来访问，cpython 中通过 object 手动实现了对象系统。 pyobject 定义于 includeobject.h 中，可以看到，结构体里只是一个简单的 pyobject_head 宏。 typedef struct _object { pyobject_head} pyobject; 展开之后为typedef struct...
准备调试环境目前 cpython 的开发已经迁移到了 github 上，可以直接去 github clone 对应的分支。 我们将基于 python 2. 7.13 版本， linux x86_64 环境进行接下来的工作。 下载好代码以后以.configure --with-pydebug make -j2编译。 调试可以直接使用 gdb， 然后使用 emacs + ctags 看代码。 (喜欢使用 ide 的话...
所以，python根据实现方式不同分为了cpyhton、pypy、jython等。 cpythoncpython是用c语言实现pyhon，是目前应用最广泛的解释器。 python最新的语言特性都是在这个上面先实现，linux，os x等自带的也是这个版本，包括anaconda里面用的也是cpython。 cpython是官方版本加上对于cpython api的全面支持，基本包含了所有第...
前言本次分析基于 cpython 解释器，python3.x版本在python2时代，整型有 int 类型和 long 长整型，长整型不存在溢出问题，即可以存放任意大小的整数。 在python3后，统一使用了长整型。 这也是吸引科研人员的一部分了，适合大数据运算，不会溢出，也不会有其他语言那样还分短整型，整型，长整型... 因此python就降低...
就在刚刚（2020年2月10日），python之父guido van rossum在其个人blog中发布了他对cpython学习的帮助教程。 下面让我们一睹为快吧！? 1你需要了解的！ 1、你必须知道c语言！ 大多数stdlib是用python编写的，我们也需要doc帮助2、你必须了解git和github！ 如果不会，请看这：? https:devguide.python.orggitbootcamp3...
我想看看这个函数在pypy上的性能是否会更好，但我不完全确定，什么是最可靠和最干净的方法。 我试过的问题是： 目前，我正在使用timeit对两人而言：$ python3.6 -mtimeit -s from test import get_checksumget_checksum(test1 * 100000, test2 * 100000)10 loops, best of 3:329 msec per loop $ pypy -mtimeit -s ...
cpython使用了本地化线程，但是因为使用了gil所以也是无法利用多核cpu优势的。 但是stackless的出现完全可以解决这个问题，并且stackless更是将python提高到了并行计算的高度，这个高度的竞争对手可以是erlang，ruby自然不必窥探。 其中的超轻量线程技术可以确保一台很烂的机器上跑几十万的线程还很轻松。 基于...
吉多编写的第一个python解释器是使用c语言实现的，并且能够调用c语言的库文件，所有也被称为cpython。 使用其他语言实现的python解释器，比如java实现的jpython解释器和python实现的pypy解释器。 经过近30年不断的更新和完善，python称为一种解释型， 面向对象的高级程序设计语言，在不同的领域，不同的项目被开发者...
cpython使用空间换取时间的做法，内部维护一个self.__map字典，键为key，值为指向双向链表节点的link. 这样在删除某个键值对时，通过__map在o(1)内找到link，然后o(1)内从双向链表__root中摘除。 8 heapq基本用法 基于list优化的一个数据结构：堆队列，也称为优先队列。 堆队列特点在于最小的元素总是在根结点：heap ...
step1:安装mpi4py所需要的依赖包(python2.7版本cpythonopenmpi)1. 源码包安装python2.7版本 123.configure prefix=#python安装目录(绝对路径)makemakeinstall2. 安装cpython使用当前用户目录下的python版本来进行安装 1homexxxpython27binpythonsetup.py install3. 安装openmpi 123.configure prefix=#openmpi安装...
如果你的 python 代码依赖于引用计数实现的行为，则这种差异可能会导致一些微妙的移植问题。 在一些 python 实现中，以下代码（在 cpython 中工作的很好）可能会耗尽文件描述符:for file in very_long_list_of_files: f = open(file) c = f.read(1)实际上，使用 cpython 的引用计数和析构函数方案， 每个新赋值的 f ...
如果你的 python 代码依赖于引用计数实现的行为，则这种差异可能会导致一些微妙的移植问题。 在一些 python 实现中，以下代码（在 cpython 中工作的很好）可能会耗尽文件描述符:for file in very_long_list_of_files: f = open(file) c = f.read(1)实际上，使用 cpython 的引用计数和析构函数方案， 每个新赋值的 f ...
如果你的 python 代码依赖于引用计数实现的行为，则这种差异可能会导致一些微妙的移植问题。 在一些 python 实现中，以下代码（在 cpython 中工作的很好）可能会耗尽文件描述符:for file in very_long_list_of_files: f = open(file) c = f.read(1) 实际上，使用 cpython 的引用计数和析构函数方案， 每个新赋值的 f ...
如果你的 python 代码依赖于引用计数实现的行为，则这种差异可能会导致一些微妙的移植问题。 在一些 python 实现中，以下代码（在 cpython 中工作的很好）可能会耗尽文件描述符:for file in very_long_list_of_files: f = open(file) c = f.read(1) 实际上，使用 cpython 的引用计数和析构函数方案， 每个新赋值的 f ...
如果你的python代码依赖于引用计数实现的行为，则这种差异可能会导致一些微妙的移植问题。 在一些python实现中，以下代码（在cpython中工作的很好）可能会耗尽文件描述符:for file in very_long_list_of_files: f = open(file) c = f.read(1) 实际上，使用cpython的引用计数和析构函数方案， 每个新赋值的 f 都会关闭...
如果你的python代码依赖于引用计数实现的行为，则这种差异可能会导致一些微妙的移植问题。 在一些python实现中，以下代码（在cpython中工作的很好）可能会耗尽文件描述符:for file in very_long_list_of_files: f = open(file) c = f.read(1) 实际上，使用cpython的引用计数和析构函数方案， 每个新赋值的 f 都会关闭...
gil (global interpreter lock)1.cpython 解释器的内存管理并不是线程安全的，存在多个线程时，有可能会出现同时修改同一对象，这样容易出现问题。 2.为了保护多线程情况下对 python 对象的访问， cpython 使用了简单的锁机制避免多个线程同时执行字节码。 缺陷便是没有办法同时利用 cpu 的多核，只有一个线程执行...
python 虚拟机内幕cpython 使用基于堆栈的虚拟机。 也就是说，它完全围绕堆栈数据结构(你可以将项目“推”到结构的“顶部”，或者将项目“弹出”到“顶部”)。 cpython 使用三种类型的栈：1. 调用堆栈。 这是运行中的 python 程序的主要结构。 对于每个当前活动的函数调用，它都有一个项目一“帧”，堆栈的底部是程序...
print(e)python性能分析与优化，gil常考题什么是cpython gilgil,global interpreterlockcpython解释器的内存管理并不是线程安全的保护多线程情况下python对象的访问cpython使用简单的锁机制避免多个线程同时执行字节码gil影响 限制了程序的多核执行同一时间只能有一个线程执行字节码cpu密集程序难以利用多核优势io...
ai 科技评论按：作为排名靠前的最受欢迎和增长最快的编程语言之一，python是一种多用途、高级别、面向对象、交互式、解释型和对用户非常友好的编程语言，拥有卓越的可读性和极高的自由度。 而为了能利用多核多线程的的优势，同时又要保证线程之间数据完整性和状态同步，python 官方的、最广泛使用的解释器——cpython...

CPython是特指C语言实现的Python，就是原汁原味的Python。

之所以使用CPython这个词，是因为Python还有一些其它的实现，比如Jython，就是Java版的Python，还有烧脑的PyPy，使用Python再把Python实现了一遍。

如下是官方对CPython的说明：

CPython is Guido van Rossum’s reference version of the Python computing language. It’s most often called simply “Python”; speakers say “CPython” generally to distinguish it explicitly from other implementations.

这个页面对Python各种不同的实现有一个说明：

https://wiki.python.org/moin/PythonImplementations?action=show&redirect=implementation

当我们编写Python代码时，我们得到的是一个包含Python代码的以.py为扩展名的文本文件。要运行代码，就需要Python解释器去执行.py文件。

由于整个Python语言从规范到解释器都是开源的，所以理论上，只要水平够高，任何人都可以编写Python解释器来执行Python代码（当然难度很大）。事实上，确实存在多种Python解释器。

CPython 

当我们从Python官方网站下载并安装好Python 3.5后，我们就直接获得了一个官方版本的解释器：CPython。这个解释器是用C语言开发的，所以叫CPython。在命令行下运行python就是启动CPython解释器。 

CPython是使用最广的Python解释器。教程的所有代码也都在CPython下执行。

IPython 

IPython是基于CPython之上的一个交互式解释器，也就是说，IPython只是在交互方式上有所增强，但是执行Python代码的功能和CPython是完全一样的。好比很多国产浏览器虽然外观不同，但内核其实都是调用了IE。

CPython用>>>作为提示符，而IPython用In [序号]:作为提示符。

PyPy 

PyPy是另一个Python解释器，它的目标是执行速度。PyPy采用JIT技术，对Python代码进行动态编译（注意不是解释），所以可以显著提高Python代码的执行速度。 

绝大部分Python代码都可以在PyPy下运行，但是PyPy和CPython有一些是不同的，这就导致相同的Python代码在两种解释器下执行可能会有不同的结果。如果你的代码要放到PyPy下执行，就需要了解PyPy和CPython的不同点。

Jython 

Jython是运行在Java平台上的Python解释器，可以直接把Python代码编译成Java字节码执行。

IronPython 

IronPython和Jython类似，只不过IronPython是运行在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码。