当前位置：首页 » 编程语言 » python封装调用

python封装调用

发布时间: 2021-03-14 05:02:27

㈠我想自己写一个python函数封装成SDK方便以后调用，但是在这个函数编写引入了不少import包，该怎么操作

写最上面。写里面有可能会重复import同一个包，浪费内存

㈡ Python如何把一段代码封装起来重复使用

你可以用类或者函数将其封装一下，将需要后期变动的变量作为参数放在其中，可以使用默认值传参。

举个简单函数和类的栗子：

#函数封装
defsum(a,b=3):
returna+b
#类封装
classS(object):
def__init__(self,a=2,b=3)
self.a=a
self.b=b
defsum(self):
returnself.a+self.b

㈢ python封装调用问题，求解，一直显示找不到元素

python封装调用问题，求解，一直显示找不到元素？
他日相逢与

㈣ Python写好的算法代码，下一步用C还是C++进行重写封装给别人调用比较好

底层都用py了，上面还管什么效率
用什么都一样
c/c++/py随你喜欢了

㈤如何将C++的API封装成python可调用形式

在C++的库上面套一层就可以了。
可以包装成CPython模块，也可以包装成C库然后用ctypes、cffi调用。
要对付主要是是C++的函数命名和类型。
包装CPython模块可以看手册里「Extending and Embedding」的部分。只要保证initMODULENAME（2.x）或PyInit_MODULENAME（3.x）是extern "C"的就行，手册里的例子用了PyMODINIT_FUNC这个宏，已经自动给加好了。
包装C库就是把所有函数都声明成extern "C"的，把传递的C++类型以C类型替代。举个例子

namespace enemy {

void first_blood(int id);

} // namespace enemy

void double_kill();
void double_kill(int killer);

class Silencer
{
public:
std::string watch_and_learn();
};

包装之后大概是这样的：

extern "C" {

void enemy_first_blood(int id)
{
enemy::first_blood(id);
}

void double_kill_by_roshan()
{
double_kill();
}

void double_kill_by_hero(int killer)
{
double_kill(killer);
}

void* new_silencer()
{
return new Sliencer;
}

void silencer_watch_and_learn(void *instacne, char *buffer)
{
std::string what = reinterpret_cast<Silencer*>(instance)->watch_and_learn();
strcpy(buffer, what.c_str());
}

void release_silencer(void *instacne)
{
delete reinterpret_cast<Silencer*>(instance);
}

} // extern "C"

㈥我现在想把自己写的python模块源代码封装成dll，然后在别的python脚本里调用，可以吗

可以的，只要把python模块转换成dll模块，利用Python自带的ctypes模块加载调用就行。

ctypes 是Python的外部函数库。它提供了与 C语言兼容的数据类型，并允许调用 DLL 或共享库中的函数。可使用该模块以纯 Python 形式对这些库进行封装。

ctypes导出了cdll对象，在 Windows 系统中还导出了windll和oledll对象用于载入动态链接库。通过操作这些对象的属性，你可以载入外部的动态链接库。cdll载入按标准的cdecl调用协议导出的函数，而windll导入的库按stdcall调用协议调用其中的函数。

(6)python封装调用扩展阅读：

加载调用DLL的相关方法：

1、加载DLL

加载的时候要根据你将要调用的函数是符合什么调用约定的。

stdcall调用约定：两种加载方式

Objdll = ctypes.windll.LoadLibrary("dllpath")

Objdll = ctypes.WinDLL("dllpath")

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

Objdll = ctypes.cdll.LoadLibrary("dllpath")

Objdll = ctypes.CDLL("dllpath")

其实windll和cdll分别是WinDLL类和CDll类的对象。

2、调用dll中的方法

加载dll的时候会返回一个DLL对象（假设名字叫Objdll），利用该对象就可以调用dll中的方法。 e.g.如果dll中有个方法名字叫Add（注意如果经过stdcall声明的方法，如果不是用def文件声明的导出函数或者extern “C” 声明的话，编译器会对函数名进行修改，这个要注意。）

调用：nRet = Objdll.Add(12, 15) 即完成一次调用。

㈦ java 做的 api 通过那种语言能封装成 python 能调用的动态链接库

解析器使用Jython, 可以直接调用java api

㈧ Python中的封装有什么作用

日常生活中可以看到很多的汽车，汽车包括车轮、发动机、车架等零部件。可以在车架上安装车轮，然后安装发动机，最后安装其他零件，刷漆。就形成了汽车。这个过程，是把各种零件放到车架上的过程。但思考一下，对于开车的人，需要关注车的内部结构吗?答案显然是否定的。汽车对外提供了方向盘、油门等去调用内部结构从而进行行驶。由这个例子可以总结出，汽车就是各种零件经过封装得到的产物，同时提供给驾驶人操控汽车需要的接口设备。这就是生活中的封装。

我们可以看到生活中的封装有很多好处。具体有如下的几条好处：

①隐藏了实现细节，在使用时没必要关注具体实现。

②安全性好，内部细节隐藏了，就不能随意破坏。

③对外提供接口方便使用。

④可维护性好，方便修改实现，修改完成后，对外接口不变，对用户使用无影响。

⑤方便重用，任何一个会开车的人都可以驾驶汽车，只要对外的接口相同就行了。

总之，封装就是将抽象得到的属性和方法形成“类”，并将类内部信息进行隐藏，对外公开接口的机制。封装限制从类外访问，从而提升代码安全性和可维护性。

封装的内涵是把抽象得到的属性和方法进行了封装，对于方法，隐藏了具体的实现，提供了方法名供使用者调用。对于成员变量也进行隐藏，通过方法对外提供访问接口。通过封装，限制了直接访问成员变量，通过方法，增加验证逻辑，提高了安全性和可维护性。

封装的外延是按照内聚性、一致性、封装性、清晰性、完整性进行类的封装。

内聚性就是类应该描述一个单一的实体。例如，学生姓名和教师所带班级不是单一实体的属性，不能组合在一个类中。

一致性就是类、成员变量、方法名要有意义，并且顺序是成员变量、构造方法、普通方法。

封装性就是类中成员变量是私有属性，通过getter/setter访问。

清晰性是指类的结构应该是易于解释和理解的。

完整性是需要充分考虑多种不同用户设计，应该能通过属性和方法提供多种方案以适应用户不同需求。例如，字符串中有很多方法，同时这些方法可以组合完成各种任务。

关于Python的基础问题可以看下这个网页的视频教程，网页链接，希望我的回答能帮到你。

㈨测试新人如何使用Python代码封装自动化测试的用例

如何使用Python和实现自动化测试？
本文我将详细介绍使用Appium下的Python编写的测试的例子代码对一个iOS的样例应用进行测试所涉及的各个步骤，而对Android应用进行测试所需的步骤与此非常类似。
然后按照安装指南，在你的机器上安装好Appium。
我还需要安装Appium的所有依赖并对样例apps进行编译。在Appium的工作目录下运行下列命令即可完成此任务：
$ ./reset.sh --ios
编译完成后，就可以运行下面的命令启动Appium了：
$ grunt appium
现在，Appium已经运行起来了，然后就切换当前目录到sample-code/examples/python。接着使用pip命令安装所有依赖库(如果不是在虚拟环境virtualenv之下，你就需要使用sudo命令)：
$ pip install -r requirements.txt
接下来运行样例测试：
$ nosetests simple.py
既然安装完所需软件并运行了测试代码，大致了解了Appium的工作过程，现在让我们进一步详细看看刚才运行的样例测试代码。该测试先是启动了样例应用，然后在几个输入框中填写了一些内容，最后对运行结果和所期望的结果进行了比对。首先，我们创建了测试类及其setUp方法：
classTestSequenceFunctions(unittest.TestCase):

defsetUp(self):
app=os.path.join(os.path.dirname(__file__),
'../../apps/TestApp/build/Release-iphonesimulator',
'TestApp.app')
app=os.path.abspath(app)
self.driver=webdriver.Remote(
command_executor='127.0.0.1:4723/wd/hub',
desired_capabilities={
'browserName':'iOS',
'platform':'Mac',
'version':'6.0',
'app': app
})
self._values=[]
“desired_capabilities”参数用来指定运行平台(iOS 6.0)以及我们想测试的应用。接下来我们还添加了一个tearDown方法，在每个测试完成后发送了退出命令：
deftearDown(self):
self.driver.quit()
最后，我们定义了用于填写form的辅助方法和主测试方法：
def_populate(self):
# populate text fields with two random number
elems=self.driver.find_elements_by_tag_name('textField')
foreleminelems:
rndNum=randint(0,10)
elem.send_keys(rndNum)
self._values.append(rndNum)
deftest_ui_computation(self):
# populate text fields with values
self._populate()
# trigger computation by using the button
buttons=self.driver.find_elements_by_tag_name("button")
buttons[0].click()
# is sum equal ?
texts=self.driver.find_elements_by_tag_name("staticText")
self.assertEqual(int(texts[0].text),self._values[0]+self._values[1])
本文介绍到此，相信很多朋友都已经明白了。但是如果你对Nose和Python来运行Appium测试有任何问题或看法，可以给我留言，我们可以继续交流。

㈩如何用Python封装C语言的字符串处理函数

在C语言中，字符串处理是每天都要面对的问题。我们都知道C语言中其实并没有一种原生的字符串类型，‘字符串’在C语言里只是一种特殊的以''结尾的字符数组。因此，如何将C语言与更高层次的Python语言在‘字符串’处理这个问题上对接是一个有难度的问题。所幸有swig这种强大的工具。

如何封装一个函数，它修改参数字符串的内容

假如有这样一个C语言的函数，

void FillZero(char* pc,size_t * piLen)
{
size_t i=0;
while(i++<*piLen/2 )
*pc++ = '0';
*pc = 0;
*piLen = i+1;
}

这个函数的功能是把字符串变成n个0。不过我们更关注函数的形式。这样的函数，表面上看char* pc是函数的参数，可是实际上它才是函数的返回值和执行的结果。piLen这个参数既是pc的最大长度，也是新的字符串的长度。我们直接用python封装，看看运行结果。

Type "help", "right", "credits" or "license" for more information.
>>> import cchar
>>> s='123456'
>>> cchar.FillZero(s,6)
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
TypeError: in method 'FillZero', argument 2 of type 'size_t *'

结果差强人意，不是我们想要得到的结果。函数的第二个参数为size_t* 我们很难用python来表示，而且python中也不存在既是输入，也是输出的参数。

swig有一个标准库，其中有一个cstring.i文件就是用来解决C语言字符串类型的问题。

我们在.i文件中加入这样几行

%include "cstring.i"
%cstring_output_withsize(char* pc,size_t* pi)
void FillZero(char* pc, size_t* pi);

然后运行看结果

Type "help", "right", "credits" or "license" for more information.
>>> import cchar
>>> cchar.FillZero(10)
'00000\x00'
>>> s=cchar.FillZero(10)
>>> print s
00000

我们看函数的变化。首先在python里， FillZero变成了只有一个参数的函数。然后函数的返回值变成了一个字符串。其实cstring_output_size其实是一个宏，通过这个宏的定义改变了函数的形式，直接在Python中得到我们想要的结果。

其实类似cstring_output_size的宏还有好几个，我列举一下:

cstring_output_allocate(char *s,free($1));
第一个参数是指向字符串地址的指针，第二个参数为释放空间的方法。
大家考虑这一下这样的函数：
void foo(char* & s)
{

s = (char*)malloc(10);
memcpy(s,"123456789",9);

}

s这个参数表面上看是输入，实际上是函数真正的输出。函数中真正改变的东西是char&s指向的字符串的值。而且char&这个类型,

python或者其他脚本语言里应该都没有对应的类型。那么我们用cstring_output_allocate将这个函数转换成另外一个形式的python或者其他脚本语言的函数。转换后的函数其实是这样的，以python为例str
foo()。

%mole a
%include "cstring.i"
%{
void foo(char*& s);
%}
%cstring_output_allocate(char *&s, free(*$1));
void foo(char *&s);

在python中的调用：


>>> import a
>>> a.foo()
'123456789'
>>>

cstring_output_maxsize(char *path, int maxpath);
第一个参数也是可以改变的字符串首地址，第二个参数为字符串的最大长度。在Python中调用的时候，只有maxpath这个参数，返回字符串。
cstring_output_allocate(char *s, free($1));
第一个参数为指向字符串首地址的指针，第二个参数为释放指针的方法。这个宏主要是封装一种直接在函数内部malloc空间的函数。在Python中调用时没有参数，直接返回字符串。
cstring_output_allocate_size(char *s, int slen, free(*$1));
这个相当于前面两个函数的组合。在函数内部malloc空间，然后将字符串长度通过slen返回。其实在调用的时候非常简单，没有参数，直接返回字符串。

如何处理c++的std::string

std::string是C++标准类库STL中常见的类。在平时工作中大家肯定是没少用。在python中如何封装std::string? swig提供了标准库

例如函数:

string Repeat(const string& s)
{
return s+s;
}

只要在swig中加入这样几行：

%include "std_string.i"
using namespace std;
string Repeat(const string& s);

运行结果：

Python 2.6.6 (r266:84292, Dec 27 2010, 00:02:40)
[GCC 4.4.5] on linux2
Type "help", "right", "credits" or "license" for more information.
>>> import cchar
>>> cchar.Repeat('123')
'123123'

使用起来很方便，但需要注意的是，假如函数的参数的内容是可以被修改，就不能用这种方式封装。
例如:

void repeat(string s)
{
s+=s;
}

这样的函数直接使用 'std_string.i' 就是无效的。遇到这种函数，只能用C语言封装成 void repeat(chars, int maxsize), 再用swig调用 'cstring_output_withsize' 这个宏再封装一次了。

阅读全文

python封装调用

与python封装调用相关的阅读推荐