Python3的一些特性、函数分析

一.@装饰器 

Python中，将函数传递给另外一个函数的方式有两种，第一种采用直接传递函数名，第二种使用@符号。

如：@A def B:pass 等价于 def B:pass B=A(B) 即将函数B作为参数传给参数A

 

 源代码：

 >>> #测试程序： >>> #（注意：@cost_time可代替方式为show1 = cost_time(show1)） >>> from time import time >>> def cost_time(func): def result(*args, **dic): beign = time() func(*args,**dic) print ("cost time : ", time() - beign) return result >>> @cost_time def show(n): for x in range(n):print (x) >>> show(10) 0 1 2 3 4 5 6 7 8 9 cost time : 0.125 >>> def show1(n): for x in range(n):print (x) >>> show1 = cost_time(show1) >>> show1(10) 0 1 2 3 4 5 6 7 8 9 cost time : 0.125 >>> show(10) 0 1 2 3 4 5 6 7 8 9 cost time : 0.108999967575 >>> show(11) 0 1 2 3 4 5 6 7 8 9 10 cost time : 0.141000032425

 

二. 不定长参数 *para,**para

参数格式为 *para 表示接受一个元组,  **para 表示接受一个字典, *para要在**para之前。

如下源代码：

>>> def Test(*args, **dic): for arg in args: print(arg) for k,v in dic.items(): print("%s : %s" % (k,v)) >>> Test("Hello",1,2,a="张三",b="李四")#"Hello",1,2传递给元组，而a="张三",b="李四"传递给字典 Hello 1 2 a : 张三 b : 李四 >>> def Test(*args, **dic): for arg in args: print(arg) for k,v in dic.items(): print("%a : %a" % (k,v)) >>> Test("Hello",1,2,a="张三",b="李四")#"Hello",1,2传递给元组，而a="张三",b="李四"传递给字典,同时格式化字符串 Hello 1 2 'a' : '/u5f20/u4e09' 'b' : '/u674e/u56db' >>>

注意：源代码中用到了%s %a这两种格式化字符串的方式，得到的结果是不同的。

参考：

格式符号		表示类型
%s		字符串
%d/%i		十进制整数
%u		十进制整数
%o		八进制整数
%x/%X   		十六进制整数         
%e/%E		科学计数
%f/%F		浮点数
%%		输出%
%a                          中文编码（官方帮助文档中没有给出，但是通过与assii()函数对比就会发现，%a就是中文编码字符串）

 

继续测试，我们传递进去的是指定了的变量与值，那如果传递进去的是元组变量与字典变量呢？答案就是直接使用(args,dic)参数，不使用不定长参数*、**符号。

源代码：

 >>> #测试程序： >>> #(注意：当传递的为对象的时候，请直接使用test1(args, dic);test1(*args, **dic)的方式主要用在直接在参数内构造元素组与字典的方式。) >>> a = range(5) >>> d = {'aa':123,'bb':456} >>> a range(0, 5) >>> d {'aa': 123, 'bb': 456} >>> list(a),d ([0, 1, 2, 3, 4], {'aa': 123, 'bb': 456}) >>> def test1(*args, **dic): print("-----") for arg in args: print(">>>") print (arg) for k,v in dic.items(): print("))))") print (k, '+:+', v) print("-----") >>> test1(list(a),d) ----- >>> [0, 1, 2, 3, 4] >>> {'aa': 123, 'bb': 456} ----- >>> for arg in list(a): print(arg) 0 1 2 3 4 >>> def test1(args, dic): print("-----") for arg in args: print(">>>") print (arg) for k,v in dic.items(): print("))))") print (k, '+:+', v) print("-----") >>> test1(list(a),d) ----- >>> 0 >>> 1 >>> 2 >>> 3 >>> 4 )))) aa +:+ 123 )))) bb +:+ 456 ----- >>>

在官方文档中，有这么一句话：

write the function call with the *-operator to unpack the arguments out of a list or tuple。

那么也就是说，我们可以将列表直接传递到函数里面去，让他自己解析，而不用给参数逐个传递值，这对于动态构成列表之后，传递到某个方法中计算尤其有用。

如下：

>>> def test(*a): #构造不定参数的函数，并打印参数值 for i in a: print(i) >>> test(1,2)#方式一 1 2 >>> test(*[1,2])#方式二 1 2 >>> a=[1,2,3] #先构造列表 >>> type(a) <class 'list'> >>> test(*a) #传递已存在的列表 1 2 3 >>> import operator >>> operator.sub(2,1) #相减 逐个给参数赋值 1 >>> operator.sub(1,2) -1 >>> operator.sub(*[2,1]) #传递列表 整体赋值 1 >>> operator.truediv(2,4) #相除 0.5 >>> operator.truediv(*[2,4]) 0.5

 

三.生成器表达式

生成器表达式:类似于没有中括号的列表推导式,可用在参数中 。

>>> data = "abcd" >>> data 'abcd' >>> sum(i*i for i in range(10)) #统计求和 285 >>> list(data[i] for i in range(len(data)-1,-1,-1)) #倒序 注：list(x)如果x是迭代器的话，则list函数可以自动计算出结果，而[]需要使用[i for i in x]来迭代计算。 ['d', 'c', 'b', 'a'] >>> list(data[i] for i in range(0,len(data))) #顺序 ['a', 'b', 'c', 'd'] >>> [data[i] for i in range(0,len(data))] #顺序， list与[]在内部是数组得到结果一样。如果内部是单个值，如：'abc'，则list等于字符列表。['abc']：['abc']，list('abc')：['a', 'b', 'c']。 ['a', 'b', 'c', 'd'] >>> set(data) #set为无序可变集合，frozenset为无序不可变集合。他们的元素都是唯一的。如：set("abb"):{'a','b'} {'a', 'c', 'b', 'd'} >>> list(set(data)) #集合转列表 ['a', 'c', 'b', 'd'] >>> set(list(data)) #列表转集合 {'a', 'c', 'b', 'd'} >>> #测试用生成器表达式读取文本 >>> openTxt = open("c:/test.txt") #注意需要用斜杠(不区分操作系统) >>> set(word for line in openTxt for word in line.split())#默认split()会按/n、/t来分割字符串 {'11', '-dddddok', 'aa-bb-', 'STOP', 'stop'} >>> set(word for line in openTxt for word in line.split('/n')) {'aa-bb- 11 -dddddok/tSTOP', '', 'stop', 'STOP'} >>> openTxt.read() #read()方法直接读取文本，作为字符串返回 'aa-bb- 11 -dddddok/tSTOP/n/nstop/n/nSTOP' >>> openTxt.closed #判断文件流是否已经关闭 False >>> openTxt.close()#关闭文件流 >>> openTxt.closed True

注：这样我就发现可以用for的方式很轻松的处理和分析文本字符串。这种方式漂亮。但是需要记得每次打开文本之后，要关闭。

 

扩展：虽然close()方法调用了，但是流对对象openTxt并没有真正的销毁。不过此时已经不能再执行其他的如读取等的操作，也就是说，这是需要等待垃圾回收机制来回收吧。如下继续调用close()，则并不引发异常。其实那只是一个空操作(no-op)而已：

>>> openTxt.close() >>> openTxt.closed True >>> openTxt.read() Traceback (most recent call last): File "<pyshell#116>", line 1, in <module> openTxt.read() ValueError: I/O operation on closed file. >>> openTxt.close() >>> openTxt.closed True >>>

另外，如果在遇到异常的情况下，要确保文件关闭呢，那么我们可以使用一贯常用的try..catch...finally块来处理。而python里面提供了一种更加轻便的操作方式，使用with语句，with语句引出一个代码块，无论你想要调用什么，当with结束的时候，将自动调用close()。如下：

>>> with open("c:/test.txt") as openTxt1: openTxt1.seek(5) aa = openTxt1.read(1) print(aa) 5 - >>> openTxt1.closed True

 

四.Sort函数

python对List进行排序给予了比较大的支持，无论list里面是单个元素列表，还是元组列表都可以进行排序。但注意，如果是元组，他们的数目需要一样。

Python提供了两个函数:

第一种，使用list列表对象的sort()函数。

第二种，直接使用sorted(list列表对象)函数。

他们都有两个参数:

key：用列表元素的某个属性和函数进行作为关键字，有默认值，迭代集合中的一项;
reverse：排序规则. reverse = True 或者 reverse = False，有默认值。

sort()与sorted()的不同在于：sort是在原位重新排列列表，而sorted()是产生一个新的列表。sort()是list对象的函数，sorted()是全局存在的。

sort()函数排序效果如下：

>>> L = [('b',1),('a',2),('c',3),('d',4)] >>> L.sort(key=lambda x:x[0])#按元组中的第一个元素排序元组列表 >>> L [('a', 2), ('b', 1), ('c', 3), ('d', 4)] >>> L = [('b',1,1),('a',2,3),('c',3,4),('d',4,0)] >>> L.sort(key=lambda x:x[2])#按元组中的第三个元素排序元组列表 >>> L [('d', 4, 0), ('b', 1, 1), ('a', 2, 3), ('c', 3, 4)] >>> L = [('ab', 2), ('ba', 1), ('cd', 3), ('dc',4)] >>> L [('ab', 2), ('ba', 1), ('cd', 3), ('dc', 4)] >>> L.sort(key=lambda x:x[0][1])#按元组中的第一个元素的第二个字符排序元组列表 >>> L [('ba', 1), ('ab', 2), ('dc', 4), ('cd', 3)]

 

sorted()函数排序方式相似,如下:

>>> L = [('ab', 2), ('ba', 1), ('cd', 3), ('dc',4)] >>> sorted(L,key=lambda x:x[0][1]) [('ba', 1), ('ab', 2), ('dc', 4), ('cd', 3)]  

 

五.对象序列化

python里面对对象序列化的支持可谓是很便捷。一种是专注于内部使用的pickle协议序列化，另外一种是使用跨语言的json结构序列化。

pickle序列化：支持所有的python的所有对象序列。二进制方式存取。速度快。最新版本的pickle协议是二进制格式的。

json序列化：文本方式存取，支持字符串、数字、布尔值、列表等但是不支持python 字节组、集合、元组。因为json跨语言，在数据集合这一块只支持数组。当然我们可以使用其他的方式来处理。

他们的处理的方法都是dump()或者dumps()。参数除开dump中存入的file对象，其他都一样。

dump():主要针对文件读写，没有返回值。

dumps():主要针对数据结构对象的直接读写到变量，代替读写文件操作。

1.pickle序列化源代码：

>>> entry = {} >>> entry['title'] = 'Welcome to here!' >>> entry['pblished_date']=time.strptime('Fri Mar 27 22:20:42 2009') >>> entry['pblished_date'] time.struct_time(tm_year=2009, tm_mon=3, tm_mday=27, tm_hour=22, tm_min=20, tm_sec=42, tm_wday=4, tm_yday=86, tm_isdst=-1) >>> import pickle >>> with open('D:/entry.pickle','wb') as f: pickle.dump(entry,f) #第二个参数需要二进制文件流对象 >>> with open('D:/entry.pickle','rb') as f: entry1 = pickle.load(f) #读取pickle文件内容 >>> entry1 {'pblished_date': time.struct_time(tm_year=2009, tm_mon=3, tm_mday=27, tm_hour=22, tm_min=20, tm_sec=42, tm_wday=4, tm_yday=86, tm_isdst=-1), 'title': 'Welcome to here!'} >>> b = pickle.dumps(entry)#dumps方法可以不用保存文件而直接进行二进制序列化，返回一个二进制对象 >>> type(b) <class 'bytes'> >>> b b'/x80/x03}q/x00(X/r/x00/x00/x00pblished_dateq/x01ctime/nstruct_time/nq/x02(M/xd9/x07K/x03K/x1bK/x16K/x14K*K/x04KVJ/xff/xff/xff/xfftq/x03}q/x04/x86q/x05Rq/x06X/x05/x00/x00/x00titleq/x07X/x10/x00/x00/x00Welcome to here!q/x08u.' >>> entry3=pickle.loads(b)#直接读取二进制pickle对象 >>> entry3 {'pblished_date': time.struct_time(tm_year=2009, tm_mon=3, tm_mday=27, tm_hour=22, tm_min=20, tm_sec=42, tm_wday=4, tm_yday=86, tm_isdst=-1), 'title': 'Welcome to here!'} >>> entry3 is entry #entry3只是entry的一个拷贝，但是并不是同一对象，所以不相等 False >>> entry3 == entry#他们的数据结构一样，所以相等 True

pickletools可以用来反编译二进制pickle对象(或者二进制文件流)

 >>> with open('D:/entry.pickle', 'rb') as f: pickletools.dis(f) 0: /x80 PROTO 3 2: } EMPTY_DICT 3: q BINPUT 0 5: ( MARK 6: X BINUNICODE 'pblished_date' 24: q BINPUT 1 26: c GLOBAL 'time struct_time' 44: q BINPUT 2 46: ( MARK 47: M BININT2 2009 50: K BININT1 3 52: K BININT1 27 54: K BININT1 22 56: K BININT1 20 58: K BININT1 42 60: K BININT1 4 62: K BININT1 86 64: J BININT -1 69: t TUPLE (MARK at 46) 70: q BINPUT 3 72: } EMPTY_DICT 73: q BINPUT 4 75: /x86 TUPLE2 76: q BINPUT 5 78: R REDUCE 79: q BINPUT 6 81: X BINUNICODE 'title' 91: q BINPUT 7 93: X BINUNICODE 'Welcome to here!' 114: q BINPUT 8 116: u SETITEMS (MARK at 5) 117: . STOP highest protocol among opcodes = 2

2.json序列化源代码：

>>> import json >>> test = {"a":1,"中文":2} >>> with open("D:/test.json", mode = 'w') as f: json.dump(test,f) #写入json文件 >>> with open("D:/test.json", mode = 'w') as f: json.dump({"a":1,"中文":2,"c":4,"b":0},f,indent=2)#缩进2列 >>> with open("D:/test.json", mode = 'w') as f: json.dump({"a":1,"中文":2,"c":4,"b":0},f,indent=2,sort_keys = True) #按键排序、缩进两列并写入D:/test.json文件。注意:sort_keys参数在官方帮助文档中，并没有提到，但是在例子中确可以发现足迹。 >>> with open("D:/test.json", mode = 'r') as f: test = json.load(f) >>> test {'a': 1, 'c': 4, 'b': 0, '中文': 2} >>> with open("D:/test.json", mode = 'w') as f: json.dump({"a":1,"中文":2,"c":4,"b":0,"z":["h","l"]},f,indent=2,sort_keys = True)#写入带有列表的json结构 >>> with open("D:/test.josn",mode="r") as f: test = json.load(f) >>> test {'a': 1, 'c': 4, 'b': 0, 'z': ['h', 'l'], '中文': 2} >>> with open("D:/test.josn", mode = 'w') as f: json.dump({"a":1,"中文":2,"c":4,"b":{"g","o"},"z":["h","l"]},f,indent=2,sort_keys = True)#写入带有集合的json结构，此时会报错，我们需要转换一下。 Traceback (most recent call last): File "<pyshell#73>", line 2, in <module> json.dump({"a":1,"中文":2,"c":4,"b":{"g","o"},"z":["h","l"]},f,indent=2,sort_keys = True) File "C:/Python31/lib/json/__init__.py", line 178, in dump for chunk in iterable: File "C:/Python31/lib/json/encoder.py", line 408, in _iterencode for chunk in _iterencode_dict(o, _current_indent_level): File "C:/Python31/lib/json/encoder.py", line 382, in _iterencode_dict for chunk in chunks: File "C:/Python31/lib/json/encoder.py", line 416, in _iterencode o = _default(o) File "C:/Python31/lib/json/encoder.py", line 170, in default raise TypeError(repr(o) + " is not JSON serializable") TypeError: {'g', 'o'} is not JSON serializable >>> def to_json(obj): #转换集合为列表 if isinstance(obj,set): return {'__class__': 'set', '__value__':list(obj)} raise TypeError(repr(obj) + 'is not json serializable') >>> with open("D:/test.josn", mode = 'w') as f: json.dump({"a":1,"中文":2,"c":4,"b":{"g","o"},"z":["h","l"]},f,indent=2,sort_keys = True,default=to_json) >>> with open("D:/test.josn",mode="r") as f: test = json.load(f) >>> test {'a': 1, 'c': 4, 'b': {'__class__': 'set', '__value__': ['g', 'o']}, 'z': ['h', 'l'], '中文': 2}

这里要注意两点：

第一：sortkeys参数排序之后，在json文件中存取确实是排好序的结构：

如json.dump({"a":1,"中文":2,"c":4,"b":0},f,indent=2,sort_keys = True)得到的结果是：

{
  "a": 1,
  "b": 0,
  "c": 4,
  "/u4e2d/u6587": 2
}

第二：to_json函数处理之后，得到的结果是：'b': {'__class__': 'set', '__value__': ['g', 'o']}。这个需要我们在python或者其他语言中调用的手动处理。

 

扩展：

1.json.dump()或者json.dumps()可以直接将字符串写入字符串流里面。

>>> from io import StringIO >>> io = StringIO() >>> json.dump(['streaming API'], io) >>> io.getvalue() #从字符串流中取得写入的字符串 '["streaming API"]' >>> json.dumps(['streaming API'], io) '["streaming API"]' >>> b1 = json.dumps(['streaming API'], io)#有返回值 >>> b1 '["streaming API"]' >>> a = json.dump(['streaming API'], io)#没有返回值 >>> a

 2.time.strptime()主要针对将格式化的日期字符串转化为time.struct_time日期结构。time.asctime()用来反向解析，即将日期结构转化为日期字符串。(这将在序列化的时候比较有用，譬如:

if isinstance(obj, time.struct_time):

    return {'__class__': 'time.asctime',

                 '__value__': time.asctime(obj)})

>>> import time >>> time.time() 1294671382.609 >>> time.struct_time <class 'time.struct_time'> >>> time.localtime()#获得本地时间 time.struct_time(tm_year=2011, tm_mon=1, tm_mday=10, tm_hour=22, tm_min=56, tm_sec=47, tm_wday=0, tm_yday=10, tm_isdst=0) >>> time.asctime(time.localtime()) #转为日期字符串 'Mon Jan 10 22:57:53 2011' >>> time.strptime('Mon Jan 10 22:57:53 2011')#转为日期结构 time.struct_time(tm_year=2011, tm_mon=1, tm_mday=10, tm_hour=22, tm_min=57, tm_sec=53, tm_wday=0, tm_yday=10, tm_isdst=-1)

 

参考资料:

Python绝对简明手册

深入Python 3