python调用dll文件接口

发布时间：2019-07-30 10:28:30编辑：auto阅读（1435）

转载




在Python中某些时候需要C做效率上的补充，在实际应用中，需要做部分数据的交互。使用python中的ctypes模块可以很方便的调用windows的dll（也包括linux下的so等文件），下面将详细的讲解这个模块（以windows平台为例子），当然我假设你们已经对windows下怎么写一个DLL是没有问题的。
  
引入ctypes库 


[python] view plain copy

1. from ctypes import *   

假设你已经有了一个的DLL（名字是add.dll)，且该DLL有一个符合cdecl（这里强调调用约定是因为，stdcall调用约定和cdecl调用约定声明的导出函数，在使用python加载时使用的加载函数是不同的，后面会有说明）调用约定的导出函数Add。
建立一个Python文件DllCall.py测试： 


[python] view plain copy

1. from ctypes import *  
2. dll = CDLL("add.dll")  
3. print dll.Add(1, 102)  

结果：103 
  
上面是一个简单的例子。下面简单聊一下调用流程： 
1、加载DLL 
上面已经说过，加载的时候要根据你将要调用的函数是符合什么调用约定的。 
stdcall调用约定：两种加载方式 


[python] view plain copy

1. Objdll = ctypes.windll.LoadLibrary("dllpath")  
2. Objdll = ctypes.WinDLL("dllpath")   

cdecl调用约定：也有两种加载方式 


[python] view plain copy

1. Objdll = ctypes.cdll.LoadLibrary("dllpath")  
2. Objdll = ctypes.CDLL("dllpath")  
3. <span style="font-family:Microsoft YaHei;">其实windll和cdll分别是WinDLL类和CDll类的对象。</span>  

dll函数的_stdcall 和 _cdecl， stdcall是被调用者来进行栈的处理， cdecl是调用者进行栈的处理。

cdecl中每个调用者都要嵌入处理的代码，所以代码量会大一些。

但为什么不都用stdcall。像printf这样的函数，事先不知道需要的栈大小，需要用cdecl来处理

所以需要使用cdecl来调用  







2、调用dll中的方法 
在1中加载dll的时候会返回一个DLL对象（假设名字叫Objdll），利用该对象就可以调用dll中的方法。 
e.g.如果dll中有个方法名字叫Add（注意如果经过stdcall声明的方法，如果不是用def文件声明的导出函数或者extern “C” 声明的话，编译器会对函数名进行修改，这个要注意，我想你们懂的。）
调用：nRet = Objdll.Add(12, 15) 即完成一次调用。 
  
看起来调用似乎很简单，不要只看表象，呵呵，这是因为Add这个函数太简单了，现在假设函数需要你传入一个int类型的指针（int*），可以通过库中的byref关键字来实现，假设现在调用的函数的第三个参数是个int类型的指针。


[python] view plain copy

1. intPara = c_int(9)  
2. dll.sub(23, 102, byref(intPara))  
3. print intPara.value  

如果是要传入一个char缓冲区指针，和缓冲区长度，方法至少有四种： 


[python] view plain copy

1. # 方法1  
2. szPara = create_string_buffer('/0'*100)  
3. dll.PrintInfo(byref(szPara), 100);  
4. print szPara.value  
5.   
6. # 方法2  
7. sBuf = 'aaaaaaaaaabbbbbbbbbbbbbb'  
8. pStr = c_char_p( )  
9. pStr.value = sBuf  
10. #pVoid = ctypes.cast( pStr, ctypes.c_void_p ).value  
11. dll.PrintInfo(pStr, len(pStr.value))  
12. print pStr.value  
13.   
14. # 方法3  
15. strMa = "/0"*20  
16. FunPrint  = dll.PrintInfo  
17. FunPrint.argtypes = [c_char_p, c_int]  
18. #FunPrint.restypes = c_void_p  
19. nRst = FunPrint(strMa, len(strMa))  
20. print strMa,len(strMa)  
21.   
22. # 方法4  
23. pStr2 = c_char_p("/0")  
24. print pStr2.value  
25. #pVoid = ctypes.cast( pStr, ctypes.c_void_p ).value  
26. dll.PrintInfo(pStr2, len(pStr.value))  
27. print pStr2.value  

  
3、C基本类型和ctypes中实现的类型映射表 
ctypes数据类型          C数据类型 
c_char                          char 
c_short                         short 
c_int                             int 
c_long                          long 
c_ulong                        unsign long 
c_float                          float 
c_double                      double 
c_void_p                       void 
对应的指针类型是在后面加上"_p"，如int*是c_int_p等等。 
在python中要实现c语言中的结构，需要用到类。 
  
4、DLL中的函数返回一个指针。 
虽然这不是个好的编程方法，不过这种情况的处理方法也很简单，其实返回的都是地址，把他们转换相应的python类型，再通过value属性访问。 


[python] view plain copy

1. pchar = dll.getbuffer()  
2. szbuffer = c_char_p(pchar)  
3. print szbuffer.value  

  
5、处理C中的结构体类型 
为什么把这个单独提出来说呢，因为这个是最麻烦也是最复杂的，在python里面申明一个类似c的结构体，要用到类，并且这个类必须继承自Structure。 
先看一个简单的例子： 
C里面dll的定义如下： 


[cpp] view plain copy

1. typedef struct _SimpleStruct  
2. {  
3.     int    nNo;  
4.     float  fVirus;  
5.     char   szBuffer[512];  
6. } SimpleStruct, *PSimpleStruct;  
7. typedef const SimpleStruct*  PCSimpleStruct;  
8.   
9. extern "C"int  __declspec(dllexport) PrintStruct(PSimpleStruct simp);  
10. int PrintStruct(PSimpleStruct simp)  
11. {  
12.     printf ("nMaxNum=%f, szContent=%s", simp->fVirus, simp->szBuffer);  
13. return simp->nNo;  
14. }  

  
Python的定义： 


[python] view plain copy

1. from ctypes import *  
2. class SimpStruct(Structure):  
3.     _fields_ = [ ("nNo", c_int),  
4.               ("fVirus", c_float),  
5.               ("szBuffer", c_char * 512)]  
6.   
7. dll = CDLL("AddDll.dll")  
8. simple = SimpStruct();  
9. simple.nNo = 16  
10. simple.fVirus = 3.1415926  
11. simple.szBuffer = "magicTong/0"  
12. print dll.PrintStruct(byref(simple))  


上面例子结构体很简单，但是如果结构体里面有指针，甚至是指向结构体的指针，处理起来会复杂很多，不过Python里面也有相应的处理方法，下面这个例子来自网上，本来想自己写个，懒得写了，能说明问题就行：
C代码如下： 


[cpp] view plain copy

1. typedef struct   
2.   
3. {  
4.   
5. char words[10];  
6.   
7. }keywords;  
8.   
9.    
10.   
11. typedef struct   
12.   
13. {  
14.   
15. keywords *kws;  
16.   
17. unsigned int len;  
18.   
19. }outStruct;  
20.   
21. extern "C"int __declspec(dllexport) test(outStruct *o);  
22.   
23. int test(outStruct *o)  
24.   
25. {  
26.   
27. unsigned int i = 4;  
28.   
29. o->kws = (keywords *)malloc(sizeof(unsigned char) * 10 * i);  
30.   
31. strcpy(o->kws[0].words, "The First Data");  
32.   
33. strcpy(o->kws[1].words, "The Second Data");  
34.   
35.    
36.   
37. o->len = i;  
38.   
39. return 1;  
40.   
41. }  

Python代码如下： 


[python] view plain copy

1. class keywords(Structure):  
2.   
3.         _fields_ = [('words', c_char *10),]  
4.   
5.    
6.   
7. class outStruct(Structure):  
8.   
9.         _fields_ = [('kws', POINTER(keywords)),  
10.   
11.                     ('len', c_int),]  
12.   
13. o = outStruct()  
14.   
15. dll.test(byref(o))  
16.   
17.    
18.   
19. print o.kws[0].words;  
20.   
21. print o.kws[1].words;  
22.   
23. print o.len  

  
6、例子 
说得天花乱坠，嘿嘿，还是看两个实际的例子。 
例子1： 
这是一个GUID生成器，其实很多第三方的python库已经有封装好的库可以调用，不过这得装了那个库才行，如果想直接调用一些API，对于python来说，也要借助一个第三方库才行，这个例子比较简单，就是用C++调用win32 API来产生GUID，然后python通过调用C++写的dll来获得这个GUID。
C++代码如下： 


[cpp] view plain copy

1. extern "C"__declspec(dllexport) char* newGUID();   
2.   
3. char* newGUID()   
4.   
5. {  
6.   
7.      static char buf[64] = {0};  
8.   
9.      statc GUID guid;  
10.   
11.      if (S_OK == ::CoCreateGuid(&guid))   
12.   
13.      {  
14.   
15.        _snprintf(buf, sizeof(buf),  
16.   
17. "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X",   
18.   
19. guid.Data1,  
20.   
21. guid.Data2,  
22.   
23. guid.Data3,  
24.   
25. guid.Data4[0], guid.Data4[1],  
26.   
27. guid.Data4[2], guid.Data4[3],  
28.   
29. guid.Data4[4], guid.Data4[5],  
30.   
31. guid.Data4[6], guid.Data4[7]  
32.   
33. );   
34.   
35.        ::MessageBox(NULL, buf, "GUID", MB_OK);   
36.   
37.       }  
38.   
39.      return (char*)buf;  
40.   
41. }  

Python代码如下： 


[python] view plain copy

1. def CreateGUID():  
2.   
3.     """ 
4.  
5.     创建一个全局唯一标识符 
6.  
7.     类似：E06093E2-699A-4BF2-A325-4F1EADB50E18 
8.  
9.     NewVersion 
10.  
11.     """  
12.   
13.     try:  
14.   
15.         # dll path  
16.   
17.         strDllPath = sys.path[0] + str(os.sep) + "createguid.dll"  
18.   
19.         dll = CDLL(strDllPath)  
20.   
21.         b = dll.newGUID()  
22.   
23.         a = c_char_p(b)  
24.   
25.     except Exception, error:  
26.   
27.         print error  
28.   
29.         return ""  
30.   
31.     return a.value  

  
例子2： 
这个例子是调用kernel32.dll中的createprocessA函数来启动一个记事本进程 


[python] view plain copy

1. #  -*- coding:utf-8 -*-   
2.   
3. from ctypes import *   
4.   
5.    
6.   
7. # 定义_PROCESS_INFORMATION结构体  
8.   
9. class _PROCESS_INFORMATION(Structure):  
10.   
11.     _fields_ = [('hProcess', c_void_p),  
12.   
13.                 ('hThread', c_void_p),  
14.   
15.                 ('dwProcessId', c_ulong),  
16.   
17.                 ('dwThreadId', c_ulong)]  
18.   
19.    
20.   
21. # 定义_STARTUPINFO结构体  
22.   
23. class _STARTUPINFO(Structure):  
24.   
25.     _fields_ = [('cb',c_ulong),  
26.   
27.                 ('lpReserved', c_char_p),  
28.   
29.                 ('lpDesktop', c_char_p),  
30.   
31.                 ('lpTitle', c_char_p),  
32.   
33.                 ('dwX', c_ulong),  
34.   
35.                 ('dwY', c_ulong),  
36.   
37.                 ('dwXSize', c_ulong),  
38.   
39.                 ('dwYSize', c_ulong),  
40.   
41.                 ('dwXCountChars', c_ulong),  
42.   
43.                 ('dwYCountChars', c_ulong),  
44.   
45.                 ('dwFillAttribute', c_ulong),  
46.   
47.                 ('dwFlags', c_ulong),  
48.   
49.                 ('wShowWindow', c_ushort),  
50.   
51.                 ('cbReserved2', c_ushort),  
52.   
53.                 ('lpReserved2', c_char_p),  
54.   
55.                 ('hStdInput', c_ulong),  
56.   
57.                 ('hStdOutput', c_ulong),  
58.   
59.                 ('hStdError', c_ulong)]  
60.   
61.    
62.   
63. NORMAL_PRIORITY_CLASS = 0x00000020 #定义NORMAL_PRIORITY_CLASS  
64.   
65. kernel32 = windll.LoadLibrary("kernel32.dll")  #加载kernel32.dll  
66.   
67. CreateProcess = kernel32.CreateProcessA   #获得CreateProcess函数地址  
68.   
69. ReadProcessMemory = kernel32.ReadProcessMemory #获得ReadProcessMemory函数地址  
70.   
71. WriteProcessMemory = kernel32.WriteProcessMemory #获得WriteProcessMemory函数地址  
72.   
73. TerminateProcess = kernel32.TerminateProcess  
74.   
75.    
76.   
77. # 声明结构体  
78.   
79. ProcessInfo = _PROCESS_INFORMATION()  
80.   
81. StartupInfo = _STARTUPINFO()  
82.   
83. fileName = 'c:/windows/notepad.exe'       # 要进行修改的文件  
84.   
85. address = 0x0040103c        # 要修改的内存地址  
86.   
87. strbuf = c_char_p("_")        # 缓冲区地址  
88.   
89. bytesRead = c_ulong(0)       # 读入的字节数  
90.   
91. bufferSize =  len(strbuf.value)     # 缓冲区大小  
92.   
93.    
94.   
95. # 创建进程   
96.   
97. CreateProcess(fileName, 0, 0, 0, 0, NORMAL_PRIORITY_CLASS,0, 0, byref(StartupInfo), byref(ProcessInfo))  

  

关键字：