python函数插件 python调用乐玩插件

5框酷毙的python插件工具

工欲善其事必先利其器，一个好的工具能让起到事半功倍的效果，Python社区提供了足够多的优秀工具来帮助开发者更方便的实现某些想法，下面这几个工具给我的工作也带来了很多便利，推荐给追求美好事物的你。

创新互联从2013年成立，先为罗湖等服务建站，罗湖等地企业，进行企业商务咨询服务。为罗湖企业网站制作PC+手机+微官网三网同步一站式服务解决您的所有建站问题。

5框酷毙的python插件工具

1、Python Tutor

Python Tutor 是由 Philip Guo 开发的一个免费教育工具，可帮助学生攻克编程学习中的基础障碍，理解每一行源代码在程序执行时在计算机中的过程。通过这个工具，教师或学生可以直接在 Web 浏览器中编写 Python 代码，并逐步可视化地运行程序。如果你不知道代码在内存中是如何运行的，不妨把它拷贝到Tutor里可视化执行一遍，加深理解。

地址：

2、IPython

IPython 是一个 for Humans 的 Python 交互式 shell，用了它之后你就不想再用自带的 Python shell 了，IPython 支持变量自动补全，自动缩进，支持 bash shell 命令，内置了许多实用功能和函数，同时它也是科学计算和交互可视化的最佳平台。在公众号【Pyhon之禅】回复 “ipython” 获取《IPython交互式编程和数据可视化教程》。

地址：

3、Jupyter Notebook

Jupyter Notebook 就像一个草稿本，能将文本注释、数学方程、代码和可视化内容全部组合到一个易于共享的文档中，以 Web 页面的方式展示。它是数据分析、机器学习的必备工具。在公众号【Pyhon之禅】回复 “jupyter” 给你看一个基于 jupyter 写的 Python 教程。

地址：

4、Anaconda

Python 虽好，可总是会遇到各种包管理和 Python 版本问题，特别是 Windows 平台很多包无法正常安装，为了解决这些问题，Anoconda 出现了，Anoconda 包含了一个包管理工具和一个Python管理环境，同时附带了一大批常用数据科学包，也是数据分析的标配。之前在公众号有介绍过 Anaconda

地址：

6、Skulpt

Skulpt 是一个用 Javascript 实现的在线 Python 执行环境，它可以让你轻松在浏览器中运行 Python 代码。使用 skulpt 结合 CodeMirror 编辑器即可实现一个基本的在线Python编辑和运行环境。

地址：

sublime python 代码提示插件哪个好？是否冲突

前言

之前安装sublimeCodeIntel插件后一直使用默认配置,总觉得很鸡肋,代码提示和sublime自带的没什么两样.恰巧最近换电脑在犹豫要不要装这个插件,一番思索后决定再试试(毕竟记不住系统函数=.=!!),Google后发现很少中文资料说明怎么配置,于是折腾了一番,记录下来供有需求的同学.

SublimeCodeIntel代码自动补全配置

作者主要使用python,所有配置以python为例.其他语言同理.利用sublimeCodeIntel插件可以实现自动提示python代码、跳转追踪自定义函数、查看系统函数等.功能还是相当强大的.

自动提示/补全python代码

选择 Perference-Package Settings-SublimeCodeIntel-Settings-User,复制以下配置:

{

"codeintel_language_settings": {

"Python3": {

"python3": "C:\\Python36\\python.exe",

"codeintel_scan_extra_dir": [

"C:\\Python36\\DLLs",

"C:\\Python36\\Lib",

"C:\\Python36\\Lib\\site-packages",

"C:\\Python36\\Lib\\idlelib",

"C:\\Python36\\python36.zip",

"C:\\Python36",

"C:\\Python36\\Lib\\*",

],

"codeintel_scan_files_in_project": true,

"codeintel_selected_catalogs": []

},

}

}

这里python路径需要根据自己的安装路径定义,其中codeintel_scan_extra_dir包含的目录可以在python IDLE中sys.path查看.

参考:戳我戳我戳我…

追踪函数、查看系统函数

配置快捷键使其同eclipse,实现ctrl+鼠标左键追踪函数,alt+left/right跳转,alt+/自动提示代码

选择 Perference-package Settings-SublimeCodeIntel-Key Bindings-User

//自动提示代码

{ "keys": ["alt+/"], "command": "code_intel_auto_complete" },

//跳转到函数定义

{ "keys": ["alt+right"], "command": "goto_python_definition"},

//返回到跳转位置

{ "keys": ["alt+left"], "command": "back_to_python_definition"}

选择 Perference-package Settings-SublimeCodeIntel-Mouse Bindings - User

[

//ctrl+鼠标左键跳转函数

{ "button": "button1", "modifiers": ["ctrl"], "command": "goto_python_definition", "press_command": "drag_select" }

]

如何设计插件式结构的程序，兼谈Python语言

为了扩充软件的功能，通常我们会把软件设计成插件式结构。Python这样的动态语言天生就支持插件式编程。与C++相比，Python已经定义好模块的接口，想要载入一个插件，一个__import__()就能很轻松地搞定。不需要特定的底层知识。而且与C++等静态语言相比，Python的插件式结构更显灵活。因为插件载入后，可以利用Python语言的动态性，充分地修改核心的逻辑。

简单地说一个__import__()可能不大清楚。现在就来看一个最简单的插件式结构程序。它会扫描plugins文件夹下的所有.py文件。然后把它们载入。

#-*- encoding: utf-8 -*-#main1.pyimport osclass Platform:

def __init__(self):

self.loadPlugins()

def sayHello(self, from_):

print "hello from %s." % from_

def loadPlugins(self):

for filename in os.listdir("plugins"):

if not filename.endswith(".py") or filename.startswith("_"):

continue

self.runPlugin(filename)

def runPlugin(self, filename):

pluginName=os.path.splitext(filename)[0]

plugin=__import__("plugins."+pluginName, fromlist=[pluginName])

#Errors may be occured. Handle it yourself.

plugin.run(self)if __name__=="__main__":

platform=Platform()

然后在plugins子目录里面放入两个文件：

#plugins1.pydef run(platform):

platform.sayHello("plugin1")#plugins2.pydef run(platform):

platform.sayHello("plugin2")

再创建一个空的__init__.py在plugins文件夹里面。从package里面导入模块的时候，Python要求一个__init__.py。

运行main1.py，看一下运行的结果。首先是打印一下文件夹结构方便大家理解：

h:\projects\workon\testpluginstree /f /a

卷 Data 的文件夹 PATH 列表

卷序列号为 ****-****

H:.

| main1.py

|

\---plugins

plugin1.py

plugin2.py

__init__.py

h:\projects\workon\testpluginsmain1.py

hello from plugin1.

hello from plugin2.

一般地，载入插件前要首先扫描插件，然后依次载入并运行插件。我们上面的示例程序main1.py也是如此，分为两个函数。第一个loadPlugins()扫描插件。它把plugins目录下面所有.py的文件除了__init__.py都当成插件。runPlugin()载入并运行插件。其中两个关键：使用__import__()函数把插件当成模块导入，它要求所有的插件都定义一个run()函数。各种语言实现的插件式结构其实也基本上分为这两个步骤。所不同的是，Python语言实现起来更加的简洁。

或许听起来还有点玄奥。详细地说一下__import__()。它和常见的import语句很相似，只不过换成函数形式并且返回模块以供调用。import module相当于__import__("module")，from module import func相当于__import__("module", fromlist=["func"])，不过与想象有点不同，import package.module相当于__import__("package.module", fromlist=["module"])。

如何调用插件一般有个约定。像我们这里就约定每个插件都实现一个run()。有时候还可以约定实现一个类，并且要求这个类实现某个管理接口，以方便核心随时启动、停止插件。要求所有的插件都有这几个接口方法：

#interfaces.pyclass Plugin:

def setPlatform(self, platform):

self.platform=platform

def start(self):

pass

def stop(self):

pass

想要运行这个插件，我们的runPlugin()要改一改，另外增加一个shutdown()来停止插件:

class Platform:

def __init__(self):

self.plugins=[]

self.loadPlugins()

def sayHello(self, from_):

print "hello from %s." % from_

def loadPlugins(self):

for filename in os.listdir("plugins"):

if not filename.endswith(".py") or filename.startswith("_"):

continue

self.runPlugin(filename)

def runPlugin(self, filename):

pluginName=os.path.splitext(filename)[0]

plugin=__import__("plugins."+pluginName, fromlist=[pluginName])

clazz=plugin.getPluginClass()

o=clazz()

o.setPlatform(self)

o.start()

self.plugins.append(o)

def shutdown(self):

for o in self.plugins:

o.stop()

o.setPlatform(None)

self.plugins=[]if __name__=="__main__":

platform=Platform()

platform.shutdown()

插件改成这样：

#plugins1.pyclass Plugin1:

def setPlatform(self, platform):

self.platform=platform

def start(self):

self.platform.sayHello("plugin1")

def stop(self):

self.platform.sayGoodbye("plugin1")def getPluginClass():

return Plugin1#plugins2.pydef sayGoodbye(self, from_):

print "goodbye from %s." % from_class Plugin2:

def setPlatform(self, platform):

self.platform=platform

if platform is not None:

platform.__class__.sayGoodbye=sayGoodbye

def start(self):

self.platform.sayHello("plugin2")

def stop(self):

self.platform.sayGoodbye("plugin2")def getPluginClass():

return Plugin2

运行结果：

h:\projects\workon\testpluginsmain.py

hello from plugin1.

hello from plugin2.

goodbye from plugin1.

goodbye from plugin2.

详细观察的朋友们可能会发现，上面的main.py,plugin1.py, plugin2.py干了好几件令人惊奇的事。

首先，plugin1.py和plugin2.py里面的插件类并没有继承自interfaces.Plugin，而platform仍然可以直接调用它们的start()和stop()方法。这件事在Java、C++里面可能是件麻烦的事情，但是在Python里面却是件稀疏平常的事，仿佛吃饭喝水一般正常。事实上，这正是Python鼓励的约定编程。Python的文件接口协议就只规定了read(), write(), close()少数几个方法。多数以文件作为参数的函数都可以传入自定义的文件对象，只要实现其中一两个方法就行了，而不必实现一个什么FileInterface。如果那样的话，需要实现的函数就多了，可能要有十几个。

再仔细看下来，getPluginClass()可以把类型当成值返回。其实不止是类型，Python的函数、模块都可以被当成普通的对象使用。从类型生成一个实例也很简单，直接调用clazz()就创建一个对象。不仅如此，Python还能够修改类型。上面的例子我们就演示了如何给Platform增加一个方法。在两个插件的stop()里面我们都调用了sayGoodbye()，但是仔细观察Platform的定义，里面并没有定义。原理就在这里：

#plugins2.pydef sayGoodbye(self, from_):

print "goodbye from %s." % from_class Plugin2:

def setPlatform(self, platform):

self.platform=platform

if platform is not None:

platform.__class__.sayGoodbye=sayGoodbye

这里首先通过platform.__class__得到Platform类型，然后Platform.sayGoodbye=sayGoodbye新增了一个方法。使用这种方法，我们可以让插件任意修改核心的逻辑。这正在文首所说的Python实现插件式结构的灵活性，是静态语言如C++、Java等无法比拟的。当然，这只是演示，我不大建议使用这种方式，它改变了核心的API，可能会给其它程序员造成困惑。但是可以采用这种方式替换原来的方法，还可以利用“面向切面编程”，增强系统的功能。

接下来我们还要再改进一下载入插件的方法，或者说插件的布署方法。前面我们实现的插件体系主要的缺点是每个插件只能有一个源代码。如果想附带一些图片、声音数据，又怕它们会和其它的插件冲突。即使不冲突，下载时分成单独的文件也不方便。最好是把一个插件压缩成一个文件供下载安装。

Firefox是一个支持插件的著名软件。它的插件以.xpi作为扩展名，实际上是一个.zip文件，里面包含了javascript代码、数据文件等很多内容。它会把插件包下载复制并解压到%APPDATA%\Mozilla\Firefox\Profiles\XXXX.default\extensions里面，然后调用其中的install.js安装。与此类似，实用的Python程序也不大可能只有一个源代码，也要像Firefox那样支持.zip包格式。

实现一个类似于Firefox那样的插件布署体系并不会很难，因为Python支持读写.zip文件，只要写几行代码来做压缩与解压缩就行了。首先要看一下zipfile这个模块。用它解压缩的代码如下：

import zipfile, osdef installPlugin(filename):

with zipfile.ZipFile(filename) as pluginzip:

subdir=os.path.splitext(filename)[0]

topath=os.path.join("plugins", subdir)

pluginzip.extractall(topath)

ZipFile.extractall()是Python 2.6后新增的函数。它直接解压所有压缩包内的文件。不过这个函数只能用于受信任的压缩包。如果压缩包内包含了以/或者盘符开始的绝对路径，很有可能会损坏系统。推荐看一下zipfile模块的说明文档，事先过滤非法的路径名。

这里只有解压缩的一小段代码，安装过程的界面交互相关的代码很多，不可能在这里举例说明。我觉得UI是非常考验软件设计师的部分。常见的软件会要求用户到网站上查找并下载插件。而Firefox和KDE提供了一个“组件(部件)管理界面”，用户可以直接在界面内查找插件，查看它的描述，然后直接点击安装。安装后，我们的程序遍历插件目录，载入所有的插件。一般地，软件还需要向用户提供插件的启用、禁用、依赖等功能，甚至可以让用户直接在软件界面上给插件评分，这里就不再详述了。

有个小技巧，安装到plugins/subdir下的插件可以通过__file__得到它自己的绝对路径。如果这个插件带有图片、声音等数据的时候，可以利用这个功能载入它们。比如上面的plugin1.py这个插件，如果它想在启动的时候播放同目录的message.wav，可以这样子：

#plugins1.pyimport osdef alert():

soundFile=os.path.join(os.path.dirname(__file__), "message.wav")

try:

import winsound

winsound.PlaySound(soundFile, winsound.SND_FILENAME)

except (ImportError, RuntimeError):

passclass Plugin1:

def setPlatform(self, platform):

self.platform=platform

def start(self):

self.platform.sayHello("plugin1")

alert()

def stop(self):

self.platform.sayGoodbye("plugin1")def getPluginClass():

return Plugin1

接下来我们再介绍一种Python/Java语言常用的插件管理方式。它不需要事先有一个插件解压过程，因为Python支持从.zp文件导入模块，很类似于Java直接从.jar文件载入代码。所谓安装，只要简单地把插件复制到特定的目录即可，Python代码自动扫描并从.zip文件内载入代码。下面是一个最简单的例子，它和上面的几个例子一样，包含一个main.py，这是主程序，一个plugins子目录，用于存放插件。我们这里只有一个插件，名为plugin1.zip。plugin1.zip有以下两个文件，其中description.txt保存了插件内的入口函数和插件的名字等信息，而plugin1.py是插件的主要代码:

description.txt

plugin1.py

其中description.txt的内容是:

[general]name=plugin1description=Just a test code=plugin1.Plugin1

plugin1.py与前面的例子类似，为了省事，我们去掉了stop()方法，它的内容是:

class Plugin1:

def setPlatform(self, platform):

self.platform=platform

def start(self):

self.platform.sayHello("plugin1")

重写的main.py的内容是:

# -*- coding: utf-8 -*-import os, zipfile, sys, ConfigParserclass Platform:

def __init__(self):

self.loadPlugins()

def sayHello(self, from_):

print "hello from %s." % from_

def loadPlugins(self):

for filename in os.listdir("plugins"):

if not filename.endswith(".zip"):

continue

self.runPlugin(filename)

def runPlugin(self, filename):

pluginPath=os.path.join("plugins", filename)

pluginInfo, plugin = self.getPlugin(pluginPath)

print "loading plugin: %s, description: %s" % \ (pluginInfo["name"], pluginInfo["description"])

plugin.setPlatform(self)

plugin.start()

def getPlugin(self, pluginPath):

pluginzip=zipfile.ZipFile(pluginPath, "r")

description_txt=pluginzip.open("description.txt")

parser=ConfigParser.ConfigParser()

parser.readfp(description_txt)

pluginInfo={}

pluginInfo["name"]=parser.get("general", "name")

pluginInfo["description"]=parser.get("general", "description")

pluginInfo["code"]=parser.get("general", "code")

sys.path.append(pluginPath)

moduleName, pluginClassName=pluginInfo["code"].rsplit(".", 1)

module=__import__(moduleName, fromlist=[pluginClassName, ])

pluginClass=getattr(module, pluginClassName)

plugin=pluginClass()

return pluginInfo, pluginif __name__=="__main__":

platform=Platform()

与前一个例子的主要不同之处是getPlugin()。它首先从.zip文件内读取描述信息，然后把这个.zip文件添加到sys.path里面。最后与前面类似地导入模块并执行。

解压还是不解压，两种方案各有优劣。一般地，把.zip文件解压到独立的文件夹内需要一个解压缩过程，或者是人工解压，或者是由软件解压。解压后的运行效率会高一些。而直接使用.zip包的话，只需要让用户把插件复制到特定的位置即可，但是每次运行的时候都需要在内存里面解压缩，效率降低。另外，从.zip文件读取数据总是比较麻烦。推荐不包含没有数据文件的时候使用。

阅读全文

C程序用Python做插件该怎么实现

Python 是一种用于快速开发软件的编程语言，它的语法比较简单，易于掌握，但存在执行速度慢的问题，并且在处理某些问题时存在不足，如对计算机硬件系统的访问，对媒体文件的访问等。而作为软件开发的传统编程语言 C 语言，却能在这些问题上很好地弥补 Python 语言的不足。因此，本文通过实例研究如何在 Python 程序中整合既有的 C 语言模块，包括用 C 语言编写的源程序和动态链接库等，从而充分发挥 Python 语言和 C 语言各自的优势。

概览

背景知识介绍

Python 语言的特点

Python 作为一门程序开发语言，被越来越多地运用到快速程序开发。Python 是一种解释型的，互动的，面向对象的编程语言，它包含了模块化的操作，异常处理，动态资料形态，以及类型的使用。它的语法表达优美易读，具有很多优秀的脚本语言的特点：解释的，面向对象的，内建的高级数据结构，支持模块和包，支持多种平台，可扩展。而且它还支持交互式方式运行，图形方式运行。它拥有众多的编程界面支持各种操作系统平台以及众多的各类函数库，利用 C 和 C++ 可以对它进行扩充。

C 语言的特点

C 语言作为最受人们欢迎的语言之一，有广泛的发展基础。简洁紧凑、灵活方便，功能强大是其特点。另外，C 语言是一门中级语言。它把高级语言的基本结构和语句与低级语言的实用性结合起来。由于可以直接访问物理地址，可以方便的对硬件进行操作。因此，很多的系统软件都是由 C 语言编写。

Python 语言与 C 语言的交互

为了节省软件开发成本，软件开发人员希望能够缩短的软件的开发时间，希望能够在短时间内开发出稳定的产品。Python 功能强大，简单易用，能够快速开发应用软件。但是由于 Python 自身执行速度的局限性，对性能要求比较高的模块需要使用效率更高的程序语言进行开发，例如 C 语言，系统的其他模块运用 Python 进行快速开发，最后将 C 语言开发的模块与 Python 开发的模块进行整合。在此背景下，基于 Python 语言与 C 语言的各自特点，用 C 语言来扩展现有的 Python 程序，显得很有意义。本文首先介绍几种常用的整合 Python 程序与 C 语言程序的方法，最后给出相应的实例。

利用 ctypes 模块整合 Python 程序和 C 程序

ctypes 模块

ctypes 是 Python 的一个标准模块，它包含在 Python2.3 及以上的版本里。ctypes 是一个 Python 的高级外部函数接口，它使得 Python 程序可以调用 C 语言编译的静态链接库和动态链接库。运用 ctypes 模块，能够在 Python 源程序中创建，访问和操作简单的或复杂的 C 语言数据类型。最为重要的是 ctypes 模块能够在多个平台上工作，包括 Windows，Windows CE，Mac OS X，Linux，Solaris，FreeBSD，OpenBSD。

接下来通过几个简单的例子来看一下 ctypes 模块如何整合 Python 程序和 C 程序。

源代码层面上的整合

利用 Python 本身提供的 ctypes 模块可以使 Python 语言和 C 语言在源代码层面上进行整合。本节介绍了如何通过使用 ctypes 库，在 Python 程序中可以定义类似 C 语言的变量。

下表列出了 ctypes 变量类型，C 语言变量类型和 Python 语言变量类型之间的关系：

表 1. ctypes，c 语言和 Python 语言变量类型关系

表 1 中的第一列是在 ctypes 库中定义的变量类型，第二列是 C 语言定义的变量类型，第三列是 Python 语言在不使用 ctypes 时定义的变量类型。

举例：

清单 1. ctypes 简单使用

from ctypes import *        # 导入 ctypes 库中所有模块

i = c_int(45)            # 定义一个 int 型变量，值为 45

i.value                # 打印变量的值

45

i.value = 56             # 改变该变量的值为 56

i.value                # 打印变量的新值

56

从下面的例子可以更明显地看出 ctypes 里的变量类型和 C 语言变量类型的相似性：

清单 2. ctypes 使用 C 语言变量

p = create_string_buffer(10)   # 定义一个可变字符串变量，长度为 10

p.raw                 # 初始值是全 0，即 C 语言中的字符串结束符' \0 '

'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'

p.value = "Student"         # 字符串赋值

p.raw                 # 后三个字符仍是' \0 '

'Student\x00\x00\x00'

p.value = "Big"           # 再次赋值

p.raw                  # 只有前三个字符被修改，第四个字符被修改为' \0 '

'Big\x00ent\x00\x00\x00'

下面例子说明了指针操作：

清单 3. ctypes 使用 C 语言指针

i = c_int(999)                 # 定义 int 类型变量 i，值为 999

pi = pointer(i)                # 定义指针，指向变量 i

pi.contents                   # 打印指针所指的内容

c_long(999)

pi.contents = c_long(1000)          # 通过指针改变变量 i 的值

pi.contents                   # 打印指针所指的内容

c_long(1000)

下面例子说明了结构和数组的操作：

清单 4. ctypes 使用 C 语言数组和结构体

class POINT(Structure):         # 定义一个结构，内含两个成员变量 x，y，均为 int 型

...   _fields_ = [("x", c_int),

...         ("y", c_int)]

...

point = POINT(2,5)           # 定义一个 POINT 类型的变量，初始值为 x=2, y=5

print point.x, point.y           # 打印变量

2 5

point = POINT(y=5)              # 重新定义一个 POINT 类型变量，x 取默认值

print point.x, point.y           # 打印变量

0 5

POINT_ARRAY = POINT * 3          # 定义 POINT_ARRAY 为 POINT 的数组类型

# 定义一个 POINT 数组，内含三个 POINT 变量

pa = POINT_ARRAY(POINT(7, 7), POINT(8, 8), POINT(9, 9))

for p in pa: print p.x, p.y        # 打印 POINT 数组中每个成员的值

...

7 7

8 8

9 9

Python 访问 C 语言 dll

通过 ctypes 模块，Python 程序可以访问 C 语言编译的 dll，本节通过一个简单的例子，Python 程序 helloworld.py 中调用 some.dll 中的 helloworld 函数，来介绍 Python 程序如何调用 windows 平台上的 dll。

导入动态链接库

清单 5. ctypes 导入 dll

from ctypes import windll # 首先导入 ctypes 模块的 windll 子模块

somelibc = windll.LoadLibrary(some.dll) # 使用 windll 模块的 LoadLibrary 导入动态链接库

访问动态链接库中的函数

清单 6. ctypes 使用 dll 中的函数

somelibc. helloworld() # 这样就可以得到 some.dll 的 helloworld 的返回值。

整个 helloworld.py 是这样的：

清单 7. Python hellpworld 代码

from ctypes import windll

def callc():

# load the some.dll

somelibc = windll.LoadLibrary(some.dll)

print somelibc. helloworld()

if __name__== “__main__”:

callc()

在命令行运行 helloworld.py，在 console 上可以看到 some.dll 中 helloworld 的输出。

清单 8. Python hellpworld Windows command console 运行输出

C:\python C:\python\test\helloworld.py

Hello World! Just a simple test.

Python 调用 C 语言 so

通过 ctypes 模块，Python 程序也可以访问 C 语言编译的 so 文件。与 Python 调用 C 的 dll 的方法基本相同，本节通过一个简单的例子，Python 程序 helloworld.py 中调用 some.so 中的 helloworld 函数，来介绍 Python 程序如何调用 linux 平台上的 so。

导入动态链接库

清单 9. ctypes 导入 so

from ctypes import cdll

# 首先导入 ctypes 模块的 cdll 子模块，注意 linux 平台上使用 cdll 的，而不是 windll。

somelibc = cdll.LoadLibrary(“./some.so”)

# 使用 cdll 模块的 LoadLibrary 导入动态链接库

访问动态链接库中的函数

清单 10. ctypes 使用 so 中的函数

somelibc. helloworld() # 使用方法与 windows 平台上是一样的。

整个 helloworld.py 是这样的：

清单 11. Python helloworld 代码

from ctypes import cdll

def callc():

# load the some.so

somelibc = cdll.LoadLibrary(some.so)

print somelibc. helloworld()

if __name__== “__main__”:

callc()

在命令行运行 helloworld.py，在 linux 标准输出上可以看到 some.so 中 helloworld 的输出。

清单 12. Python hellpworld Linux shell 运行输出

[root@linux-790t] python ./helloworld.py

Hello World! Just a simple test.

Python 程序和 C 程序整合实例

以下我们举例用 Python 来实现一个小工具，用来实现 hash 算法，查看文件的校验和（MD5,CRC,SHA1 等等）。通过查看文件的校验和，可以知道文件在传输过程中是否被破坏或篡改。

Hash，一般翻译做“散列”，也有直接音译为"哈希"的，就是把任意长度的输入（又叫做预映射，pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，而不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。

由于相对 C 语言来说，Python 的运行效率较低，因此我们的 Python 小工具利用一个已有的 C 语言的动态链接库 (hashtcalc.dll) 来实现我们的程序。本例中，我们运用 wxPython 编写简单的 GUI 界面，通过 python 调用 hashtcalc.dll 的接口计算文件的校验和，然后输出在界面上。

架构图

图 1. 工具的架构图

hashcalc.dll 接口描述

函数名：calc_CRC32

函数：char* calc_CRC32(char *filename);

参数：文件名

返回值：字符串

说明：该函数对输入的文件内容进行计算，并且返回它的 CRC32

函数名：calc_MD5

函数：char* calc_MD5(char *filename);

参数：文件名

返回值：字符串

说明：该函数对输入的文件内容进行计算，并且返回它的 MD5

函数名：calc_SHA1

函数：char* calc_SHA1 (char *filename);

参数：文件名

返回值：字符串

说明：该函数对输入的文件内容进行计算，并且返回它的 SHA1

HashcalcAdapter 代码

HashcalcAdapter.py 实现了一个 python 的 class HashcalcAdapter，HashcalcAdapter 对 hashtcalc.dl 的 C 语言接口进行了封装，使得其他 python 模块可以直接通过 HashcalcAdapter 使用 hashtcalc.dll 中实现的 hash 算法。具体的代码如下：

清单 13. HashcalcAdapter.py 代码

from ctypes import windll

from ctypes import *

class HashcalcAdapter(object):

def __init__(self, dllpath):

self._dllpath = dllpath

self._libc = windll.LoadLibrary(self._dllpath)

def calc_CRC32(self, filename):

new_filename = c_char_p(filename)

return self._libc.calc_CRC32(new_filename)

def calc_MD5(self, filename):

new_filename = c_char_p(filename)

return self._libc.calc_MD5(new_filename)

def calc_SHA1(self, filename):

new_filename = c_char_p(filename)

return self._libc.calc_SHA1(new_filename)

运行界面

图 2. 工具的运行界面

vim有python函数参数自动提示的插件么

Pythonomnicomplete,安装启用之后，是这个样子的：1.如何安装'Pythonomnicomplete'plugin.如果是VIM7.3，不需要再下载pythoncomplete.vim这个插件，因为安装时自带了。但是，必须保证编译安装VIM的时候启用了Python特性，即

新闻标题：python函数插件 python调用乐玩插件
分享地址：http://6mz.cn/article/dososdc.html