Python计算生态的构建，,本专题的内容结构：第

Python计算生态的构建，,本专题的内容结构：第

本专题的内容结构：

第一部分主要是：如何编写Python第三方库（包和模块）

第二部分主要是：如何编写带有c语言扩展的Python第三方库（包和模块）

第一部分的结构：

unit1:深入理解Python库：

(1),库，模块和包

(2),模块的命名空间

(3),包的命名空间

(4),模块的名称属性

unit2:模块和包的构建：

(1),模块的构建

(2),常规包的构建

(3),命名空间包的构建

unit3:实例1：矩阵乘法模块的构建

(1),矩阵乘法运算

(2),模块构造方法实践

unit4:深入立即import系统

(1),import系统

(2),模块对象

(3),模块的查找和加载

unit5:Python第三方库的发布：

(1),发布前的准备和发布概念

(2),第三方库的发布流程

第二部分的结构：

unit1:c语言精简概述：

(1),c语言概述，语法及实例

(2),c编辑环境配置

unit2:Python与C的交互方法：

(1),Python的扩展方法

(2),Python的嵌入方法

(3),Python的调用方法

unit3:Python扩展的CFFI 方法

(1),CFFI的功能接口

(2),CFFI 库的应用

unit4:实例2：矩阵乘法的c语言加速

(1),c语言加速文件组织结构及示例

(2),Python和c性能比较

第一部分的内容：

unit1:深入理解Python库：

(1),库，模块和包：

库： Library :一种对特定功能集合的通俗“说法”

它只是通俗说法，不是语法元素

>包含一些程序功能，通过import 引入使用，对应模块和包

>标准库：Standard Library ,与Python解释器一同安装的库

>第三方库：Third-Party Library ，需要额外安装的库

模块：Module: 以单个文件为命名空间的代码片段

简单说模块也是语法元素

>模块是一个单独的.py 文件，模块名就是文件名

>模块本质上是一个独立的，由模块名组织的命名空间

>模块中可以引入其他模块，并由一些Python语法来约束和管理

包：Package :由一组模块构成，有层次命名空间的程序功能

>包由多个模块(多个.py 文件)有组织的构成

>模块的组织方式构成了命名空间的层次结构

>包是模块的上一级组织概念，其中可以包括子包

模块是一切库的基础单元：

>包由模块构成，可以理解为：包是目录，模块是.py文件

>库是通俗的说法，具体指Python的模块和包

>Python库的核心是 模块 及 模块的组织方式 (体现为命名空间）

(2),模块的命名空间：

模块是一个命名空间

>模块对应单独的.py 文件，它是一个独立的命名空间

>模块内可能包含:类，函数，语句(直接可执行)，变量等元素

>模块内还包括一些其他对模块进行约束和管理的语法元素

例子：

在m.py 文件中：

module_var = 1 #全局变量

class module_class: #全局类

mc_classattr = 1

def __init__(self,mc_instattr = 1):

self.mc_instattr = mc_instattr

def mc_func(self):

return "Method with a count of {}".format(self.mc_classattr)

def module_func(): #全局函数

print("Module Function")

print("Moudle Statement") #全局语句

那么m.py 就是模块

那么在使用m模块的时候：

1, <模块名>.<名称> :访问模块内顶层命名空间的变量，类和函数

import m # 这时会执行一遍m.py ，所以会打印 Module Statement

print(m.module_var)

mc = m.module_calss(99)

print(mc.mc_func())

m.module_func()

2,from m import * 将所有的顶层的东西加载到当前模块中

from m import * #仍然打印Moudule Statement

print(module_var)

mc= module_class(99)

print(mc.mc_func())

module_func()

扩展： m.py 文件如下：

_module_var = 1 #前加_

class _module_class: #前加_

mc_classattr = 1

def __init__(self,mc_instattr = 1):

self.mc_instattr = mc_instattr

def mc_func(self):

return "Method with a count of {}".format(self.mc_classattr)

def _module_func(): #前加_

print("Module Function")

print("Moudle Statement")

如果用上面第一种,import m

import m

print(m._module_var)

mc = m._module_calss(99)

print(mc.mc_func())

m._module_func()

依然是可以的

但是如果用第二种：

from m import *

print(_module_var)

mc= _module_class(99)

print(mc.mc_func())

_module_func()

这时会出错，也就是说使用单下划线开头时，如果使用from m import * 时，加载不进来

总结：

>模块中的顶层语句：在import 时一次性执行

>模块内的变量，类和函数：在import时采用<模块名>方式访问

>单下划线的顶层命名元素：不会在from ...import *时被导入

(3),包的命名空间：

与模块不同，包是一个有层次的命名空间

Python包区别于普通目录的关键：

Python包里有__init__.py 文件

包： Package:由一组模块构成，有层次命名空间的程序功能

>每个包需要包含一个__init__.py 文件表达包的组织

>__init__.py 可以是空文件，即，文件存在即可

>每个包可以嵌套包含更多子包

例子：

　　　　　 所对应的命名空间：

小结：

包是一个有层次的命名空间：

>通过包的组织可以形成由英文句号（点）. 分隔的层次化命名空间

>__init__.py 用来构成包的定义，区分于包含.py 文件的普通目录

>包，子包和模块可以用import进行导入或单独导入

(4),模块的名称属性：

名称属性是表达模块名称的预定义变量

属性 描述

__name__ 模块或包的名字，例：m.__name__

你可能会问：模块的名字不就是文件的名字吗，为何还定义个__name__？

不完全是

看例子:

m.py 中：

def _module_func():

print("Module Fucntion")

module_var = 1

print("Module Statement")

print(__name__)

输出是：

Module Statement

__main__ (自己内部使用)

a.py 中：

import m

输出是：

Module Statement

m (外面的文件引用)

总结：

>当程序以脚本方式直接执行时，__name__的值为‘__main__‘

>当程序以模块方式被引用执行时，__name__的值为模块名称

>作用： 区分程序以何种方式执行

一句话：自己用，__name__是__main__ ,别人用是模块名

我们经常看到在一些程序中用if __name__ == "__main__": 来表达，

它其实就是为了方便在自己本身内部调试，外部调时不会被执行

总之：

作用1：作为模块主体功能的单元测试部分

作用2：作为模块内部保留的额外功能部分（暂时没有完成的项目代码）

Make a script both importable and executable!

unit2:模块和包的构建：

(1),模块的构建 :

模块的构建原则：如何编写好一个.py 文件呢？

>功能闭包：单一.py 文件实现单一且完整的功能

>抽象适度：用函数或类进行抽象，结合功能选择合适抽象

具体抽象级别，要看需求，简单的抽象用函数，复杂的抽象用类

>操作闭包：模块无顶层可执行语句，导入时无输出

不规范的模块：

规范之后：

还有要注意的是：顶层尽可能都是函数或都是类，尽量不要顶层的类和函数的混合使用

>功能闭包：功能定义要清晰，设计要合理(紧耦合，松耦合)

在模块内部，功能之间是紧耦合的，

模块之间，尽量使松耦合

>抽象湿度：采用类或函数，尽量选择一种；多种也无妨

>操作闭包：采用__name__,无全局可执行语句，尽量无顶层全局变量

实例：

"这是模块的秒数"

class module_class:

mc_classattr = 1

def __init__(self,mc_instattr = 1):

self.mc_instattr = mc_instattr

def mc_func(self):

return "Method with a count of {}".format(self.mc_classattr)

def module_func():

print("Module Function")

if __name__ == "__main__":

import sys #如果引入是为了测试用，最好放在这

module_var = 1

print("Moudle Statement")

还要： dir() 函数：以列表形式返回模块所使用的命名

a.py :

import m

print(dir(m))

[‘__builtins__‘, ‘__cached__‘, ‘__doc__‘, ‘__file__‘, ‘__loader__‘, ‘__name__‘, ‘__package__‘, ‘__spec__‘, ‘module_class‘]

用dir() 查看，我们能使用的命名，这样对于我们使用模块更加简单，

====Python包分为常规包和命名空间包====

>常规包：Regular Packages ，通过__init__.py 对文件和目录组织形参的包（在目录上连续的）

>命名空间包：Namespace Packages,由更分散子包组成的包

>子包的位置可以在文件系统中不连续

>子包也可以是压缩文件后网络连接或其他系统资源

(2),常规包的构建：

常规包：Regular Packages

>连续目录空间表达的，有层次的命名空间

>每个目录中包含一个__init__.py 文件，可以是空文件

>当 包/子包 被导入时，对应目录的__init__.py 文件将被执行

我们发现，三行import 语句分别引入m1,m2,m1

我们头两行都导入了pck包，但是包只运行了一次

即是每个包仅被导入一次，且包导入按照层次结构进行

导入的时候，只能导入模块，不能导入包

这时可以用from pkg.pkg1 import m1,m2

通过from ..import 直接导入具体模块，可以简化调用时命名空间的表达

再看用from ..import * :

结果是错的 ,使用它是需要额外写代码的，

这就要用到__all__属性，

>from ..import *形式需要在__init__.py 文件中增加__all__属性赋值

>__all__需要被赋值为列表对象，包含当前包下所有希望被导入的模块名称

>__all__ 用来辅助导入模块，但不能辅助导入列表

常规包的构建流程：

>设计好包层次结构(命名空间)，每个目录配置一个__init__.Python文件

>完善__init__.py 文件，并酌情赋值__all__属性

>再次理解包和模块的不同，模块提供功能，包提供命名空间

小结：

>每个包仅被导入一次，且包导入按照层次结构进行

>直接导入包不能调用功能，需要导入到模块层次

>from ..import 直接导入具体模块，可以简化调用时命名空间的表达

>__init__.py 文件中通过__all__ 属性支持 from..import *功能

(3),命名空间包的构建：

常规包需要用__init__.py 辅助构建，命名空间包是不需要的，

命名空间包：表达命名空间层次结构的一种逻辑包形式

>命名空间中各部分可以在不同的文件系统位置

>命名空间中各子包并不包含__init__.py (是个普通目录)

要把目录加到sys.path 中，

>Python 解释器通过sys.path 变量来 隐式 维护命名空间包

现在的问题是如何将这样的命名空间聚合？

注：project1 和project2 可以在不同的路径中（只不过它们中的pkg1和pkg2要相同）

import sys

sys.path += [‘project1‘,‘project2‘] #首先是将最顶层目录加入到sys.path变量中，

import pkg1.m1

import pkg1.m3 #两个不同 的pak1 成为一个命名空间

pkg1.m1.mecho(123)

pkg1.m3.mecho("Python")

print(pkg1.__path__) # 输出是：_NamesapcePath([‘project1\\pkg1‘,‘project2\\pkg1‘])

sys.path :指定搜索路径的字符串列表：

>指定import 时搜索模块或包的路径列表，路径是相对或绝对路径

>sys.path 是个列表类型，可以用sys.path.append(p)增加新路径p

>载入后，根据其中包的名称和层次结构自然组成了命名空间包

__path__属性：

>记录了某个包(命名空间) 的绝对/相对路径，列表类型

>常规包：路径是单一的，列表中只有一个元素

>命名空间包：路径是多元的，列表中可能有多个元素

unit3:实例1：矩阵乘法模块的构建

矩阵乘法：

>人工智能算法的核心运算之一

>数据分析的数据表达及运算之一

>大规模科学计算的核心操作之一

需求分析：

矩阵乘法模块：

>输入：两个矩阵及行列值

>处理：矩阵乘法运算，矩阵各元素求和运算

>输出：一个采用Python语言开发的Python模块

例子：

 1 mxmul.py 模块 2 "mx 为matrix 矩阵" 3 def mxmul(mx1,mx2,mx1_row,mx1_col,mx2_col): 4     rst = [[0 for y in range(mx2_col)] for x in range(mx1_row)] 5     for i in range(mx1_row):  #mx1行 6         for j in range(mx1_col): # mx1列 mx2行 7             for k in range(mx2_col): #mx2列 8                 rst[i][k] += mx1[i][j] *mx2[j][k] 9     return rst10 11 def mxsum(mx,mx_row,mx_col):12     s = 013     for i in range(mx_row):14         for j  in range(mx_col):15             s += mx[i][j]16     return s17 18 if __name__ =="__main__":19     mx1 = [[1,2,3],[7,8,2],[4,2,5]]20     mx2 = [[1,2],[9,8],[11,7]]21     mx1_row = len(mx1)22     mx1_col = len(mx1[0])23     mx2_row = len(mx2)24     mx2_col = len(mx2[0])25 26     rst = mxmul(mx1,mx2,mx1_row,mx1_col,mx2_col)27     sum1 = mxsum(mx1,mx1_row,mx1_col)28     sum2 = mxsum(mx2,mx2_row,mx2_col)29     print(rst)30     print(sum1,sum2)

输出：

[[52, 39], [101, 92], [77, 59]]

34 38

后面会用c语言来改写它，对于成千上万，几十万的矩阵，用c语言才是最佳的

上面模块的使用：

 1 import mxmul 2  3 mx1 = [[1,2,3,4],[1,2,3,4],[1,2,3,4],[1,5,9,7]] 4 mx2 = [[1,5],[2,6],[7,8],[9,5]] 5  6 mx1_row = len(mx1) 7 mx1_col = len(mx1[0]) 8 mx2_row = len(mx2) 9 mx2_col = len(mx2[0])10 11 rst = mxmul.mxmul(mx1,mx2,mx1_row,mx1_col,mx2_col)12 13 print(rst)

输出：

[[62, 61], [62, 61], [62, 61], [137, 142]]

unit4:深入理解import系统（理解）

(1),import系统:

import系统：扩展命名空间及功能的方法

>构成（3部分）：import保留字，__import__()函数 和 importlib 标准库

这三者都可启动import系统

>步骤：模块的查找，模块的加载

>价值：import系统是Python代码复用和命名空间管理的精髓

>import保留字：调用__import__() 进行模块查找，以及模块的加载

它同时完成了查找和加载两个功能

>__import__() 函数：模块的查找，建立模块对象

>importlib标准库：与import 系统相关的丰富API

如果未查找到，会返回ImportError 的错误

万物皆对象：模块被导入后成为了对象

>模块的对象形式：模块在程序中使用都是以对象形式体现

>类似 类对象 ，模块对象只有一个

>模块对象生产时，模块中代码会被执行，因此会有类对象产生

(2),模块的查找：

模块的查找是import系统中第一部分，

查找的开始：

>输入参数：模块的名字，例如：pkg.pkg1.m1

>输入方式：import保留字，__import__（），importlib标准库

>基本行为：按层次结构逐层查找，例如:pkg -> pkg1-> m1

查找路径：

第一步：

>第一步查找sys.modules,之前 被引入的模块 会在缓存中(cache)

>sys.modules是个字典，<模块名/对象引用>:<加载路径>

>如果模块不在sys.modules中，则进入下一步

第二步：

查找策略

>用户通过 注册import 钩子扩展的查找模式

>内置模块的路径

>sys.path(列表变量)提供的加载路径，可以是zip或url

improt钩子：import hook

>扩展查找模块的方式:meta_path 方式和import路径方式

>meta_path:将查找方法增加到sys.meta_path列表变量中

>Import路径：将查找方法注册到sys.path_hooks 列表变量中

如果这四个步骤都没有找到就会返回ImportError

(3),模块的加载:

在模块查找到以后，

从模块对象的生成到命名空间的使用是模块的加载，

建立模块对象的过程：

>1，找到模块后，如果模块对象存在，则使用现有模块对象

>2，创建一个新的模块对象，将其加入到sys.modules

>3,在程序当前命名空间执行模块代码

简单说，建立模块对象的过程：不只是创建对象，还有执行对象

>创建对象：importlib.abc.Loader.create_module()

>执行对象：importlib.abc.Loader.exec_module()

模块对象的命名空间：

因为import是可以在任何命名空间使用的：

>模块的命名空间与import 的位置有直接关系

>如果import引用位置在文件顶层，则使用文件顶层命名空间访问模块

>如果import引用位置在非顶层，则使用局部命名空间访问模块

(4),import的使用方式:

import的三种使用方式：

>import <模块名>

>from <模块名> import <类/函数名/*>

>import <模块名> as <别名>

import <模块名>

>当前命名空间下的一个子命名空间

>成功加载后，产生一个与<模块名>同名的<模块对象名>

>实际上：<模块对象名>.<子命名空间内元素>方式访问

from <模块名> import <类/函数名/*>

>将导入元素加载到当前命名空间

>成功加载后，产生类对象或函数对象，覆盖同名对象

>实际上： <类对象名> 或 <函数对象名> 方式访问

import <模块名> as <别名>

>当前命名空间下的一个子命名空间

>成功加载后，产生一个与<别名>同名的<模块对象名>

>实际： <模块对象名>.<子命名空间内元素>方式访问

unit5:Python第三方库的发布：

(1),发布前的准备:

>PyPI : Python Package Index ,用来登记第三方库信息

>Github,bitbucket :存储第三方库源代码及文档

>目标：通过pip 进行安装和管理，源代码和文档网络可管理

一些基本概念：

>项目： project:PyPI 上一组发布和文件的统称

>发布：release :项目的一个特定版本，每个发布有一个确定的版本号

>文件file: 即package ,一次发布包含的具体文件

发布流程：

工具的更新：

注册账号：

(2),第三方库的发布流程:

1，整理目录结构

2，创建其他相关文件，主要是setup.py

3，执行打包命令 :python setup.py ...

4，执行发布命令 : twine upload dist/*

(3),第三方库的发布概念:

略

第二部分的内容：

unit1:c语言精简概述：

(1),c语言概述

c语言与Python语言：

>Python解释器采用c语言编写，被称为:cpython

>Python从未视图替换过c语言，而是通过扩展与c语言并存，各展所长

>c和python 都将是不可超越的经典

c语言的精髓：

>c语言精髓在于灵活语法下的内存有效管理

>无论何种语法形态，最终体现为数据在内存中栈和堆的存储和操作

>c语言可以直接精细到操作每一个比特和字节，充分发挥计算机效率

(2),c语言语法：

略

(3),c开发环境配置：

略

(4),c语言实例：

略

(5),编译与解释

略

unit2:Python与C的交互方法：

Python与c/c++及交互的三种方式：

>Python扩展：在Python程序中调用c/c++编写的库

>Python嵌入：在c/c++中调用python程序

>Python调用： Pythonhe c间以程序级别互相调用

Python和c/c++交互的价值

>整合Python高产和c/c++高效的优势

>利用c或python 已有功能服务彼此的程序

>Python作为粘性脚本语言整合或被整合到各类独立程序

第一：Python扩展：在Python程序中调用c/c++编写的库 ：

>目的：提升关键代码性能，引入c语言成熟功能库

>方式：Cython,SWIG,ctypes,CFFI

>形式：Python为主程序，C通过.dll/.so 形式使用

第二：Python嵌入：在Python程序中调用c/c++编写的库 ：

>目的：在c/c++中调用python程序

>方式：Python/C API

>形式：c/c++为主程序，Python通过源文件形式使用

第三：Python 和 c互相调用：在Pythonhe c间以程序级别互相调用

>目的：模块间功能互用，以功能使用为目标

>方式：子进程/线程方式，即subprocess

>形式：c/c++ 和python都是独立程序

总结：

>Python扩展： 十分重要，Python程序员必会 （提高计算性能）

>Python嵌入：一般重要，Python程序员可以掌握

>Python调用：比较重要，Python程序员应该掌握

(1),Python的扩展方法：

>目的：提升关键代码性能，引入c语言成熟功能库

>方式：Cython,SWIG,ctypes,CFFI

>形式：Python为主程序，C通过.dll/.so 形式使用

1,Cython:实现python扩展的一种语言，第三方库

>思路：通过一种简单的语言实现Python和c的接口

>方式：采用了Pyrex语法形式

>结果：采用c数据类型的python编程，实现混合编程

more:http://cython.org/

2,SWIG :一个将c/c++与脚本语言相整合的编译器，独立工具

>思路：通过一个编译器来实现Python和c的接口

>方式：纯c/c++编程，通过编写接口变成Python模块

>结果：独立c和python编程，重点在于编写接口(描述)

more:http://www.swig.org

3,ctypes:调用DLL 或共享的Python功能函数库，标准库API

>思路：通过一个python标准库实现python扩展

>方式：c语言功能编为.dll 或 .so ,加载库及调用函数，API

>结果：c语言独立编程，Python使用库调用接口函数

more:http://docs.python.org/3.7/library/ctypes.html

4,CFFI: 在python中直接使用c函数的方式，第三方库 (最有效)

>思路：类似于ctypes,使用API 扩展c程序，也可以直接混合编程

>方式：关注c函数的访问接口，而不是库函数，构建API

>结果：c语言独立编程，Python使用CFFI扩展，最小学习代价

more:http://cffi.readthedocs.io/

小结：

>Cython:采用c数据类型的Python编程

>SWIG：将c转变为Python模块的接口编译工具

>ctypes:调用.dll/.so 的标准库API

>CFFI:调用c函数及混合编程的第三方库API (推荐使用)

(2),Python的嵌入方法：

Python嵌入：在Python程序中调用c/c++编写的库 ：

>目的：在c/c++中调用python程序

>方式：Python/C API

>形式：c/c++为主程序，Python通过源文件形式使用

Python/C API: python嵌入的主要接口

>嵌入Python语句：嵌入一个或多个Python语句

>嵌入Python脚本：嵌入一个或多个Python文件

Python/C API需要加载Python解释器及加载Python语句和脚本

Python/C API 是一组能够在c语言下执行的类型定义和函数

它需要头文件： Python.h

函数：加载Python解释器，嵌入python的语句/脚本/数据类型转换

加载Python解释器：

Py_Initialize() 初始化Python解释器，加载builtins,__main__,sys等

Py_Finalize() 终结化Python解释器，释放解释器占用内存

PyRun_SimpleString(const char *cmd) 在__main__模块中执行一条语句，如果__main__不存在则创建

PyRun_SimpleFile(FILE *fp ,const char *fname) 在c中调用一个Python文件

例子：

more function:https://docs.python.org/3/c-api/

(3),Python的调用方法:

Python 和 c互相调用：在Pythonhe c间以程序级别互相调用

>目的：模块间功能互用，以功能使用为目标

>方式：子进程/线程方式，即subprocess

>形式：c/c++ 和python都是独立程序

1，在python中调用c程序：

subprocess模块：

函数： 描述

subprocess.run(args) 执行args指定的一个程序，args可以是一个字符串/列表，

字符串：一个程序的名称，如a.exe

列表: 程序名称和参数的列表，如[‘a.exe‘,‘9‘]

2，在c中调用python程序：

system(char* cmd) c/c++ 下的标准函数，c89定义，将指令和参数以字符串形式作为参数传递执行程序

python 调c : subprocess模块

c调Python: system() 函数

unit3:Python扩展的CFFI 方法

(0),CFFI概述：

CFFI: C Foreign Fucntion Interface for Python

>它是第三方库，需要安装：pip install cffi

>查阅文档：CFFI是一种流程或机制，只要按流程就能实现c语言的扩展

>平台相关：windows平台的.dll ,Linux平台的.so ,32位/64位

CFFI: 在python中直接使用c函数的方式，第三方库 (最有效)

>思路：类似于ctypes,使用API 扩展c程序，也可以直接混合编程

>方式：关注c函数的访问接口，而不是库函数，构建API

>结果：c语言独立编程，Python使用CFFI扩展，最小学习代价

more:http://cffi.readthedocs.io/

>库扩展：对已经编译的c语言.dll 或 .so 库调用并使用

>标准库：c语言标准库的调用及使用

>数据类型：c语言和python数据类型的转换

(1),CFFI的功能接口：

这些都是写在python文件中，

函数 描述

ffi.NULL 相当于常量值NULL

ffi.new(cdecl) 数组/指针的生成，new(‘x*‘)或 new (‘x[n]‘)

ffi.cast(ctype,value) c数据类型声明，ctype是类型名，value是变量名 cast(‘int‘,x)

ffi.string(cdata) 从cdata类型中返回一个Python字符串

ffi.unpack(cdata,length)从cdata数组中获取特定长度，返回一个Python字符串或列表

与数据大小相关的接口：

ffi.typeof(ctype) 返回ctype的长度

ffi.sizeof(object) 返回object对象的长度

ffi.alignof(ctype) 返回ctype或对象的长度

与调用相关的接口：

ffi.dlopen(libpath) 打开动态链接库并建立一个句柄

ffi.dlclose(lib) 关闭动态链接库并释放句柄

ffi.cdef(str) str指明python中需要使用c类型，函数等声明

与内存操作相关的接口：

ffi.memmove(dst,src,n) 从src 向dst 拷贝n字节内容，注意src和dst都是python变量

(2),CFFI 库的应用：

Python计算生态：>15万个，每个都不一样

那么该怎么学？

>阅读 + 理解 + 实践

>阅读官方文档，理解设计及应用理念，实践典型及拓展案例

一起来学习CFFI库：

>阅读： https://cffi.readthedocs.io 文档不长

>理解：理解设计及应用理念

>实践：典型案例参考实例2，扩展案例请结合工作需求完成

unit4:实例2：矩阵乘法的c语言加速

需求分析：

关键计算部分使用c语言实现

文件结构：

>可编译为.dll的c语言代码： mxmul.h mxmul.c

>用来封装.dll的python模块：cmxmul.py

>用来测试效果的python程序 :test.py

mxmul.h :

#ifndef _DLL_H_

#define _DLL_H_

#if BUILDING_DLL

#define DLLIMPORT __declspec(dllexport)

#else

#define DLLIMPORT __declspec(dllimport)

#endif

DLLIMPORT int* mxmul(int mx1_row, int mx1_col, int mx2_col, int mx1[][mx1_col], int mx2[][mx2_col]);

#endif

mxmul.c :

#include "mxmul.h"

#include <windows.h>

#include <stdlib.h>

DLLIMPORT int* mxmul(int mx1_row, int mx1_col, int mx2_col, int mx1[][mx1_col], int mx2[][mx2_col])

{

int x,i,j;

int * rst;

rst = malloc(sizeof(int) * mx1_row * mx2_col);

for (int i = 0; i < mx1_row; i++){ //mx1行

for (int j = 0; j < mx2_col; j++){ //mx2列

rst[i * mx2_col + j] = 0;

for (int k = 0; k < mx1_col; k++){ //mx1列 mx2行

rst[i * mx2_col + j] += *((mx1 + i) + k) *

*(*(mx2 + k) + j);

}

}

}

return rst;

}

BOOL WINAPI DLLMain(HINSTANCE hinstDLL,DWORD fdwReason,LPVOID lpvReserved){

switch(fdwReason){

case DLL_PROCESS_ATTACH:{

break;

}

case DLL_PROCESS_DETACH:{

break;

}

case DLL_THREAD_ATTACH:{

break;

}

case DLL_THREAD_DETACH:{

break;

}

}

}

将mxmul.h 和mxmul.c 做成dll库

cmxmul.py

import array #引入array 标准库，形成数组的标准库

from cffi import FFI

def cmxmul(mx1_row,mx1_col,mx2_col,mx1,mx2):

ffi = FFI()

c_mx1_row = ffi.cast(‘int‘,mx1_row)

c_mx1_col = ffi.cast(‘int‘,mx1_col)

c_mx2_col = ffi.cast(‘int‘,mx2_col)

_mx1 = array.array(‘|‘)

_mx2 = array.array(‘|‘)

[_mx1.fromlist(x) for x in mx1]

[_mx2.fromlist(x) for x in mx2]

c_mx1 = ffi.new(‘int[]‘,len(_mx1))

c_mx2 = ffi.new(‘int[]‘,len(_mx2))

ffi.memmove(c_mx1,_mx1,ffi.sizeof(c_mx1))

ffi.memmove(c_mx2,_mx2,ffi.sizeof(c_mx2))

ffi.cdef(‘‘‘

int * mxmul(int mx1_row,int mx1_col,int mx2_col,int *mx1,int *mx2);

‘‘‘)

try:

C = ffi.dlopen(‘mxmul.dll‘)

except:

C = ffi.dlopen(‘mxmul32.dll‘)

c_res = C.mxmul(c_mx1_row,c_mx1_col,c_mx2_col,c_mx1,c_mx2)

return ffi.unpack(c_res,c_mx1_row*c_mx2_col)

test.py

略

Python计算生态的构建