python技巧

带任意参数的函数

  1 def function(arg1="",arg2=""):                                             
  2     print "arg1:{0}".format(arg1)
  3     print "arg2:{0}".format(arg2)
  4 
  5 function("Hello", "World")
  6 #prints args1:Hello
  7 #prints args2:World
  8 
  9 function()
 10 #prints args1:
 11 #prints args2:

元组实现：

  1 def foo(*args):#just use "*" to collect all remaining argument into tuple  
  2     numargs = len(args)
  3     print "Number of arguments:{0}".format(numargs)
  4     for i, x in enumerate(args):
  5         print "Argument {0} is :{1}".format(i,x)
  6 
  7 foo()
  8 #Number of arguments:0
  9 
 10 foo("hello")
 11 #Number of arguments:1
 12 #Argument 0 is :hello
 13 
 14 foo("hello", "world", "again")
 15 #Number of arguments:3
 16 #Argument 0 is :hello
 17 #Argument 1 is :world
 18 #Argument 2 is :again

使用Glob（）查找文件

类似于增强版的 listdir（）函数：

  1 import glob                                                                
  2 
  3 #get all files
  4 files = glob.glob('*.py')
  5 print files
  6 
  7 #Output
  8 #['1.py','2.py','3.py']

查多个文件类型：

  1 import intertools as it,glob                                               
  2 
  3 def multiple_file_types(*patterns):
  4     return it.chain.from_iterable(glob.glob(pattern) for pattern in patterns)
  5 
  6 for filename in multiple_file_types("*.txt", "*.py"):
  7     print filename
 #output
#1.py
#2.py
#test.txt

如果想的到每个文件的绝对路径，可以在返回值上调用realpath（）函数：

  1 import intertools as it,glob，os                                               
  2 
  3 def multiple_file_types(*patterns):
  4     return it.chain.from_iterable(glob.glob(pattern) for pattern in patterns)
  5
  6 for filename in multiple_file_types("*.txt", "*.py"):
  7    realpath=os.path.realpath(filename)
  8    print realpath
 #output
#C:\xxx\1.py
#C:\xxx\2.py
#C:\xxx\test.txt

调试

inspect模块用于调试

  1 import logging,inspect
  2 logging.basicConfig(level=logging.INFO,
  3         format='%(asctime)s %(levelname)-8s %(filename)s:%(lineno)-4d:         %(message)s',
  4         datefmt='%m-%d %H:%M',
  5         )
  6 logging.debug('A debug message')
  7 logging.info('Some information')
  8 logging.warning('A shot across the bow')
  9                                                                            
 10 def test():
 11     frame,filename,line_number,function_name,lines,index=\
 12             inspect.getouterframes(inspect.currentframe())[1]
 13     print (frame,filename,line_number,function_name,lines,index)
 14 
 15 test()
#output
03-14 15:00 INFO     5.py:7   :Some information
03-14 15:00 WARNING  5.py:8   :A shot across the bow
(<frame object at 0x7fd0e56117b0>, '5.py', 15, '<module>', ['test()\n'], 0)

生成唯一ID

生成唯一字符串使用md5（）函数可以达到目的，其实有一个uuid（）函数用于它

  1 import uuid                                                                
  2 
  3 result = uuid.uuid1()
  4 print result

#output --->various attempts
0a8ff230-e9b3-11e5-82db-b8ac6f2e8f72
0b8e2fc6-e9b3-11e5-a391-b8ac6f2e8f72
0cc3db0c-e9b3-11e5-a11a-b8ac6f2e8f72

即使字符串是唯一的，但他们后面的几个字符看起来相似，这是因为生成的字符串与电脑的MAC地址相联系。
为了减少重复的情况，可以用如下的函数。

  1 import hmac,hashlib                                                        
  2 
  3 key='1'
  4 data='a'
  5 print hmac.new(key,data,hashlib.sha256).hexdigest()
  6 
  7 m=hashlib.sha1()
  8 m.update("The quick brown fox jumps over the lazy dog")
  9 print m.hexdigest()

#output
 c6e693d0b35805080632bc2469e1154a8d1072a86557778c27a01329630f8917
2fd4e1c67a2d28fced849ee1bb76e7391b93eb12

序列化

字符串存储在数据库或者文本中，格式化的存入，取出

  1 import pickle
  2 
  3 variable=['hello',42,[1,'two'],'apple']
  4 
  5 #searialize conten
  6 file=open('serial.txt','w')
  7 serialized_obj=pickle.dumps(variable)
  8 file.write(serialized_obj)
  9 file.close()
 10 
 11 #unserialize to produce original content
 12 target=open('serial.txt', 'r')                                             
 13 myObj=pickle.load(target)
 14 
 15 print serialized_obj
 16 print myObj

#output
 (lp0
S'hello'<pre name="code" class="python"> p1

aI42
a(lp2
I1
aS'two'
p3
aaS'apple'
p4
a.
['hello', 42, [1, 'two'], 'apple']

这是个原生的Python序列化方法。也可以用JSON实现

  1 import json
  2 
  3 variable=['hello',42,[1,'two'],'apple']
  4 print "Original {0}-{1}".format(variable,type(variable))
  5 
  6 #encoding
  7 encode=json.dumps(variable)
  8 print "Encode {0}-{1}".format(encode,type(encode))
  9 
 10 #deccoding
 11 decoded=json.loads(encode)                                                 
 12 print "Decoded {0}-{1}".format(decoded,type(decoded))

#ouput
Original ['hello', 42, [1, 'two'], 'apple']-<type 'list'>
Encode ["hello", 42, [1, "two"], "apple"]-<type 'str'>
Decoded [u'hello', 42, [1, u'two'], u'apple']-<type 'list'> 

这样更紧凑，而且最重要的是这样与JavaScript和许多其他语言兼容。然而对于复杂的对象其中一些信息可能丢失

压缩字符

python可以压缩字符，不涉及任何档案文件

  1 #!/usr/bin/python
  2 import zlib
  3 string="qwdsaiiiiiiiiiiii\
  4 iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiuewqyrpiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii\
  5 iiiifdssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssvccccccccccccccccccccccccccccccccccccce\
  6 qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\
  7 wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww\
  8 eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"
  9 
 10 print "Original Size:{0}".format(len(string))                                                                                            
 11 
 12 compressed=zlib.compress(string)
 13 print "Compressed Size:{0}".format(len(compressed))
 14 
 15 decompressed=zlib.decompress(compressed)
 16 print "Decompressed Size:{0}".format(len(decompressed))

#output
Original Size:534
Compressed Size:44
Decompressed Size:534 

注册Shutdown函数

有个atexit的模块，它可以让你在脚本运行完后立马执行一些代码。

假如想在脚本执行结束时测量一些基准数据，比如运行了多长时间：

  1 import atexit,time,math                                                    
  2 def microtime(get_as_float = False):
  3     if get_as_float:
  4         return time.time()
  5     else:
  6         return '%f%d'%math.modf(time.time())
  7 
  8 start_time=microtime(False)
  9 atexit.register(start_time)
 10 
 11 def shutdown():
 12     global start_time
 13     print "Execution took:{0} seconds".format(start_time)
 14 
 15 atexit.register(shutdown)

#output
Execution took:0.7384021457940357 seconds
Error in atexit._run_exitfuncs:
Traceback (most recent call last):
  File "/usr/lib/python2.7/atexit.py", line 24, in _run_exitfuncs
    func(*targs, **kargs)
TypeError: 'str' object is not callable
Error in sys.exitfunc:
Traceback (most recent call last):
  File "/usr/lib/python2.7/atexit.py", line 24, in _run_exitfuncs
    func(*targs, **kargs)
TypeError: 'str' object is not callable 

大眼看起来很简单。只需要将代码添加到脚本的最底层，他将在脚本结束前运行。但是如果脚本中有一个致命错误或者脚本被用户终止，它可能就不运行了。

当你使用atexit.register()时，你的代码都将执行，不论脚本因为什么原因停止运行。