python 学习笔记 函数和类

与java类似 python的函数也是出于可以复用才使用的 如果一段代码没有复用的价值就可以不用函数

一般的函数可以定义成这样：

def func(a,b=123,*arg,**args):
    for x in arg:#arg是一个list
        print x
    for x,y in args.items():#args是一个dict
        print x,y
    print ‘a:‘,a
    print ‘b:‘,b

func(1,1,2,3,4,c=1,d=2)
结果:
2
3
4
c 1
d 2
a: 1
b: 1   

其中a是位置(必选)参数,b是可选参数

arg是接受不限个的参数，arg在接受后会成为一个list

args则是接受a=1,b=2...这种参数，接收之后args会成为一个dict

下面是一些函数相关练习题(包含一些文件操作)，

‘‘‘定义一个函数xulie(dirname,info) 参数：dirname:路径名，
info:需要序列化的数据，功能：
将info数据序列化存储到dirname路径下随机的文件里。 ‘‘‘
#调用系统函数os.listdir获取相应路径的所有文件名，将这些文件名存储在一个list中
#然后使用random随机获取该list中的一个文件名，更改该文件
import random
def xulie(dirname,info):
    list_dir_name=[]
    for x in os.listdir(dirname):
        list_dir_name.append(x)
    temp_name=list_dir_name[random.randint(0, len(list_dir_name)-1)]
    f=open(dirname+temp_name,‘ab‘)
    f.write(info)
    f.close()
xulie(‘d:\\test\\‘, ‘this is a test‘)

def func_3(name=None,**kargs):
    result=[]
    if len(kargs)>0:
        for x,y in kargs.items():
            result.append((x+‘:‘+y))
    result.insert(0, name)
    return result
print func_3(name=‘lilei‘,age=‘20‘,city=‘hk‘)结果 [‘lilei‘, ‘city:hk‘, ‘age:20‘]

类：类与java类似 自身也存在有构造函数(__init__,类实例化时候调用)，析构函数(__exit__,退出上下文时候调用，一般与__enter__方法合用),有一个   __del__的魔术方法，在调用del删掉类的实例时调用。此外还有静态方法 是直接通过类调用，而不是类的实例调用。

class text_sort(object):
    def __init__(self):
        print ‘this is init‘
    def __enter__(self):
        print ‘this is enter‘
    def __exit__(self,type,value,traceback):
        # pass
        if type!= None:
            pass
        else :
            pass
        print ‘this is exit‘

    def __del__(self):
        print ‘this is del‘
    @staticmethod
    def staticMethod():
        print ‘this is staticMethod‘

text_sort.staticMethod()
test1=text_sort()
with test1 as d:
    del d

结果:
this is staticMethod
this is init
this is enter
this is exit
this is del

类的练习题，包含类中值得传递等：

‘‘‘Listinfo 包括的方法:
1 列表元素添加: add_key(keyname)  [keyname:字符串或者整数类型]
2 列表元素取值：get_key(num) [num:整数类型]
3 列表合并：update_list(list)      [list:列表类型]
4 删除并且返回最后一个元素：del_key() ‘‘‘
class listinfo(object):
    def __init__(self,*lists):
        #不使用魔术参数  self.args=args处理
        #使用用魔术参数 如何处理(直接写参数 不加括号)
        self.args=[]
        for x in lists:
            self.args.append(x)
    def add_key(self,keyname):
        if isinstance(keyname, str) or isinstance(keyname, int):
            self.args.append(keyname)
            return True
        else:
            return False
    def get_key(self,num):
        result =[]
        if isinstance(num, int):
            for x in self.args:
                if len(result) <= num-1 :
                    result.append(x)
                else:
                    pass
        return result
    def update_list(self,list_in):
        if isinstance(list_in, list):
            self.args.extend(list_in)
            return self.args
        else:
            return ‘not list type‘
        self.args
    def del_key(self):
        return self.args.pop()
    def get_all(self):
        return self.args
listtest=listinfo(4,222,111,33,4545,‘sss‘,‘332‘)
listtest.add_key(9999)
print listtest.get_key(3)
print listtest.update_list([1])
print listtest.del_key()
结果
[4, 222, 111]
[4, 222, 111, 33, 4545, ‘sss‘, ‘332‘, 9999, 1]
1 

python的高级函数map,reduce和filter:它们都是对一个literable的对象进行处理。lambda类似于匿名函数，在一些地方可以和列表生成式互换。

foo=[12,24,36,48,11,33,55,77]
map(lambda x:x*2+5,foo)#将第一个函数分别作用于后面的literable对象，并返回一个list
结果:[29, 53, 77, 101, 27, 71, 115, 159]
filter(lambda x:x%2==0,foo)#将第一个函数分别作用于后面的literable对象，符合结果的返回list
结果:[12, 24, 36, 48]
reduce(lambda x,y:x+y,foo)#将literable中的元素两两运算，且每一次运算之后的结果作为下次运算的第一个参数
结果:296[x for x in foo if x %2 == 0]#结果与filter一样