python封装函数填写,python所有功能代码都应该封装到函数

将下面Python代码封装成函数

Python：常用函数封装：

网站建设哪家好，找创新互联公司！专注于网页设计、网站建设、微信开发、微信小程序、集团企业网站建设等服务项目。为回馈新老客户创新互联还提供了新源免费建站欢迎大家使用！

def is_chinese(uchar):

"""判断一个unicode是否是汉字"""

if uchar = u'\u4e00' and uchar=u'\u9fa5':

return True

else:

return False

def is_number(uchar):

"""判断一个unicode是否是数字"""

if uchar = u'\u0030' and uchar=u'\u0039':

return True

else:

return False

def is_alphabet(uchar):

"""判断一个unicode是否是英文字母"""

if (uchar = u'\u0041' and uchar=u'\u005a') or (uchar = u'\u0061' and uchar=u'\u007a'):

return True

else:

return False

def is_other(uchar):

"""判断是否非汉字，数字和英文字符"""

if not (is_chinese(uchar) or is_number(uchar) or is_alphabet(uchar)):

return True

else:

return False

def B2Q(uchar):

"""半角转全角"""

inside_code=ord(uchar)

if inside_code0x0020 or inside_code0x7e: #不是半角字符就返回原来的字符

return uchar

if inside_code==0x0020: #除了空格其他的全角半角的公式为:半角=全角-0xfee0

inside_code=0x3000

else:

inside_code+=0xfee0

return unichr(inside_code)

def Q2B(uchar):

"""全角转半角"""

inside_code=ord(uchar)

if inside_code==0x3000:

inside_code=0x0020

else:

inside_code-=0xfee0

if inside_code0x0020 or inside_code0x7e: #转完之后不是半角字符返回原来的字符

return uchar

return unichr(inside_code)

def stringQ2B(ustring):

"""把字符串全角转半角"""

return "".join([Q2B(uchar) for uchar in ustring])

def uniform(ustring):

"""格式化字符串，完成全角转半角，大写转小写的工作"""

return stringQ2B(ustring).lower()

def string2List(ustring):

"""将ustring按照中文，字母，数字分开"""

retList=[]

utmp=[]

for uchar in ustring:

if is_other(uchar):

if len(utmp)==0:

continue

else:

retList.append("".join(utmp))

utmp=[]

else:

utmp.append(uchar)

if len(utmp)!=0:

retList.append("".join(utmp))

return retList

python如何封装函数

可以定义一个类，类里定义很多函数(主要用它做什么)或直接定义函数在一个py文件中

在另一个文件中导入这个那个py包，调用类和方法

就是封装了

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

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

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

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

!-- lang: cpp --

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", "copyright", "credits" or "license" for more information.

import cchar

s='123456'

cchar.FillZero(s,6)

Traceback (most recent call last):

File "stdin", line 1, in module

TypeError: in method 'FillZero', argument 2 of type 'size_t *'

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

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

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

!-- lang: cpp --

%include "cstring.i"

%cstring_output_withsize(char* pc,size_t* pi)

void FillZero(char* pc, size_t* pi);

然后运行看结果

Type "help", "copyright", "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这个参数表面上看是输入，实际上是函数真正的输出。 函数中真正改变的东西是chars指向的字符串的值。而且char这个类型,

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

foo()。

!-- lang: cpp --

%module a

%include "cstring.i"

%{

void foo(char* s);

%}

%cstring_output_allocate(char *s, free(*$1));

void foo(char *s);

在python中的调用：

!-- lang: 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提供了标准库

例如函数:

!-- lang: cpp --

string Repeat(const string s)

{

return s+s;

}

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

!-- lang: cpp --

%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", "copyright", "credits" or "license" for more information.

import cchar

cchar.Repeat('123')

'123123'

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

例如:

!-- lang: cpp --

void repeat(string s)

{

s+=s;

}

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

使用python简单封装selenium常用函数

年前走查脚本代码时，发现大家对selenium功能都在重复造轮子，而且容易出现一些常见低级bug。于是在闲暇之余，封装一些常用的selenium功能。

在某些网页中，存在多个frame嵌套。而selenium提供的find_element函数只能在当前frame中查找，不能切换到其他frame中，需要从最上级frame中逐步切换（当然也可以指定xpath的绝对路径，但是一般没人这么做）。在我们写代码过程中，需要明确知道当前frame位置和需要寻找元素的frame位置。在frame切换过程中，容易因为疏忽导致frame切换错误导致元素无法找到的bug。

页面中分布的frame，可以理解为树状结构。因此我们可以采用递归的方式， 沿着某条搜索路线frame节点，依次对树中每个节点均做一次访问。

我们以163网址上的登录框为例：点击登录按钮，弹出登录iframe页面。输入框位置在iframe中，因此我们不能使用xpath获取元素位置，需要进入iframe中，然后获取元素。

手动切换ifame可能会产生bug，因此需要一套自动切换和检索frame的机制。具体代码如下：

需要注意的是：如果页面中多个frame中，存在相同的xpath元素。还是需要指定frame的路径，否则会返回搜索到的第一个元素。

强制等待

直接调用系统time.sleep函数，不管页面加载情况一定会等待指定的时间， 即使元素已被加载 。

1.如果设置的时间较长，会浪费时间

2.如果设置的时间较短，元素可能没有加载。

页面中某元素如果未能立即加载，隐式等待告诉WebDriver需等待一定的时间，然后去查找元素。默认不等待，隐式等待作用于整个WebDriver周期，只需设置一次即可。

1.在上文的find_element函数中，采用递归方式在所有frame寻找元素。若采用隐式等待，则在每个frame中都需要等待设定的时间，耗时非常长。

2.某些页面我们想要的元素已经加载完毕，但是部分其他资源未加载。隐式等待必须等待所有元素加载完毕，增加额外等待时间。

显示等待一般作用于某一个元素，在设定的时间范围内，默认每间隔0.5秒查找元素。返回被加载的元素，若超过设定的时间范围未能查找则报错。显示等待作为selenium常用的等待机制，我们来看下他的源码和机制。

driver 注释中解释为WebDriver实例，但是代码中并未有相关检测，因此可以传入任何对象

但是__repr__函数中使用到session_id属性，如果需要显示属性或者转为str对象，最好在driver对象中添加session_id属性

在until函数中，我们可以看到driver对象传入method函数。在计时结束前，在不断循环执行method函数，如果method函数有正常返回值则退出循环，否则报TimeoutException错误。

可以采用装饰器对隐式等待进行封装，这样代码更加精简

同样的，采用装饰器对其他常用的函数进行封装,例如强制等待、点击、输入文本等。

装饰器虽然很方便，但也会产生一些麻烦。例如在find_element函数递归调用过程中，理应只要执行一次装饰器函数。但因为装饰器已经装饰完毕，导致每次递归都会执行。例如强制等待的sleep函数，如果递归次数越多等待时间越长。

解除装饰器一般有两种做法：一是约定参数，当递归第二次调用时则不生效。例如

这种方式实现简单，容易理解。但是增加了参数限制，在fun函数中就不能使用first_sleep参数。

二是采用装饰器采用wrapped实现，通过访问wrapped属性获得原始函数。例如

但是某一个函数被多个装饰器装饰时，需要递归解除装饰器。例如

最后整体代码如下

这次的封装其实还存在很多问题

1.find_element函数不仅仅只是提供查找元素功能，还提供一些其他功能，因此叫element_operation更为合适。

2.find_element函数的参数过多，并且很多参数的使用并不在函数本身中，对代码阅读很不友好。

3.得小心避免参数重复问题，假设装饰器sleep和装饰器wait_time都使用time这个参数，将无法区分具体是哪个函数使用。

4.不利于扩展和维护，当功能过多时find_element的参数过于庞大。

如果只是简单地封装和使用，上面这种方式也能达到较好的效果。如果想进一步封装，建议采用链式调用方式，装饰器辅助封装。例如

这样函数的扩展性和可阅读性有较大的提升