转载：你需要知道的、有用的 Python 功能和特点

文章出处：http://www.oschina.net/translate/python-functions

在使用Python多年以后，我偶然发现了一些我们过去不知道的功能和特性。一些可以说是非常有用，但却没有充分利用。考虑到这一点，我编辑了一些你应该了解的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 arguments into a 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()查找文件

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

你可以像下面这样查找多个文件类型：

 1 import itertools 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"): # add as many filetype arguements
 7     print filename
 8
 9 # output
10 #=========#
11 # test.txt
12 # arg.py
13 # g.py
14 # shut.py
15 # test.py

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

 1 import itertools 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"): # add as many filetype arguements
 7     realpath = os.path.realpath(filename)
 8     print realpath
 9
10 # output
11 #=========#
12 # C:\xxx\pyfunc\test.txt
13 # C:\xxx\pyfunc\arg.py
14 # C:\xxx\pyfunc\g.py
15 # C:\xxx\pyfunc\shut.py
16 # C:\xxx\pyfunc\test.py

调试

这篇文章不会覆盖这个模块的每个细节，但会展示给你一些用例。

 1 import logging, inspect
 2
 3 logging.basicConfig(level=logging.INFO,
 4     format=‘%(asctime)s %(levelname)-8s %(filename)s:%(lineno)-4d: %(message)s‘,
 5     datefmt=‘%m-%d %H:%M‘,
 6     )
 7 logging.debug(‘A debug message‘)
 8 logging.info(‘Some information‘)
 9 logging.warning(‘A shot across the bow‘)
10
11 def test():
12     frame,filename,line_number,function_name,lines,index=13         inspect.getouterframes(inspect.currentframe())[1]
14     print(frame,filename,line_number,function_name,lines,index)
15
16 test()
17
18 # Should print the following (with current date/time of course)
19 #10-19 19:57 INFO     test.py:9   : Some information
20 #10-19 19:57 WARNING  test.py:10  : A shot across the bow
21 #(, ‘C:/xxx/pyfunc/magic.py‘, 16, ‘‘, [‘test()\n‘], 0)

生成唯一ID

1 import uuid
2
3 result = uuid.uuid1()
4 print result
5
6 # output => various attempts
7 # 9e177ec0-65b6-11e3-b2d0-e4d53dfcf61b
8 # be57b880-65b6-11e3-a04d-e4d53dfcf61b
9 # c3b2b90f-65b6-11e3-8c86-e4d53dfcf61b

你可能会注意到，即使字符串是唯一的，但它们后边的几个字符看起来很相似。这是因为生成的字符串与电脑的MAC地址是相联系的。

为了减少重复的情况，你可以使用这两个函数。

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

序列化

 1 import pickle
 2
 3 variable = [‘hello‘, 42, [1,‘two‘],‘apple‘]
 4
 5 # serialize content
 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
17
18 #output
19 # (lp0
20 # S‘hello‘
21 # p1
22 # aI42
23 # a(lp2
24 # I1
25 # aS‘two‘
26 # p3
27 # aaS‘apple‘
28 # p4
29 # a.
30 # [‘hello‘, 42, [1, ‘two‘], ‘apple‘]

这是一个原生的Python序列化方法。然而近几年来JSON变得流行起来，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 "Encoded {0} - {1}".format(encode,type(encode))
 9
10 #deccoding
11 decoded = json.loads(encode)
12 print "Decoded {0} - {1}".format(decoded,type(decoded))
13
14 # output
15
16 # Original [‘hello‘, 42, [1, ‘two‘], ‘apple‘] - <type ‘list‘="">
17 # Encoded ["hello", 42, [1, "two"], "apple"] - <type ‘str‘="">
18 # Decoded [u‘hello‘, 42, [1, u‘two‘], u‘apple‘] - <type ‘list‘="">

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

压缩字符

 1 import zlib
 2
 3 string =  """   Lorem ipsum dolor sit amet, consectetur
 4                 adipiscing elit. Nunc ut elit id mi ultricies
 5                 adipiscing. Nulla facilisi. Praesent pulvinar,
 6                 sapien vel feugiat vestibulum, nulla dui pretium orci,
 7                 non ultricies elit lacus quis ante. Lorem ipsum dolor
 8                 sit amet, consectetur adipiscing elit. Aliquam
 9                 pretium ullamcorper urna quis iaculis. Etiam ac massa
10                 sed turpis tempor luctus. Curabitur sed nibh eu elit
11                 mollis congue. Praesent ipsum diam, consectetur vitae
12                 ornare a, aliquam a nunc. In id magna pellentesque
13                 tellus posuere adipiscing. Sed non mi metus, at lacinia
14                 augue. Sed magna nisi, ornare in mollis in, mollis
15                 sed nunc. Etiam at justo in leo congue mollis.
16                 Nullam in neque eget metus hendrerit scelerisque
17                 eu non enim. Ut malesuada lacus eu nulla bibendum
18                 id euismod urna sodales. """
19
20 print "Original Size: {0}".format(len(string))
21
22 compressed = zlib.compress(string)
23 print "Compressed Size: {0}".format(len(compressed))
24
25 decompressed = zlib.decompress(compressed)
26 print "Decompressed Size: {0}".format(len(decompressed))
27
28 # output
29
30 # Original Size: 1022
31 # Compressed Size: 423
32 # Decompressed Size: 1022

注册Shutdown函数

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

 1 import atexit
 2 import time
 3 import math
 4
 5 def microtime(get_as_float = False) :
 6     if get_as_float:
 7         return time.time()
 8     else:
 9         return ‘%f %d‘ % math.modf(time.time())
10 start_time = microtime(False)
11 atexit.register(start_time)
12
13 def shutdown():
14     global start_time
15     print "Execution took: {0} seconds".format(start_time)
16
17 atexit.register(shutdown)
18
19 # Execution took: 0.297000 1387135607 seconds
20 # Error in atexit._run_exitfuncs:
21 # Traceback (most recent call last):
22 #   File "C:\Python27\lib\atexit.py", line 24, in _run_exitfuncs
23 #     func(*targs, **kargs)
24 # TypeError: ‘str‘ object is not callable
25 # Error in sys.exitfunc:
26 # Traceback (most recent call last):
27 #   File "C:\Python27\lib\atexit.py", line 24, in _run_exitfuncs
28 #     func(*targs, **kargs)
29 # TypeError: ‘str‘ object is not callable

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

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

结论

你是否意识到那些不是广为人知Python特性很有用？请在评论处与我们分享。谢谢你的阅读！