python常用模块整理[持续更新]

1. doctest

作用：我的理解就是编写一个类或方法的时候可以在注释里面将单元测试写进去。

看下例子：

def is_between(v, lower, higher):
# Last Change:  2012-07-21 11:07:50
    """
     >>> is_between(5, 1, 9)
     True
     >>> is_between(3, 3, 9)
     False
    """
    return lower < v < higher

if __name__  ==  "__main__":
    import doctest
    doctest.testmod()

执行:python test.py -v

Trying:
    is_between(5, 1, 9)
Expecting:              --这个是作者期望的输出
    True
ok
Trying:
    is_between(3, 3, 9)
Expecting:
    False
ok
1 items had no tests:
    __main__
1 items passed all tests:
   2 tests in __main__.is_between
2 tests in 2 items.
2 passed and 0 failed.
Test passed.

这样的话就可以不用单独编写单元测试了。直接写到方法的docstring里面.

2. namedtuple模块

>>> from collections import namedtuple
>>> Point=namedtuple('Point','x y',verbose=True)
class Point(tuple):
        'Point(x, y)'

        __slots__ = ()

        _fields = ('x', 'y')

        def __new__(_cls, x, y):
            'Create new instance of Point(x, y)'
            return _tuple.__new__(_cls, (x, y))

        @classmethod
        def _make(cls, iterable, new=tuple.__new__, len=len):
            'Make a new Point object from a sequence or iterable'
            result = new(cls, iterable)
            if len(result) != 2:
                raise TypeError('Expected 2 arguments, got %d' % len(result))
            return result

        def __repr__(self):
            'Return a nicely formatted representation string'
            return 'Point(x=%r, y=%r)' % self

        def _asdict(self):
            'Return a new OrderedDict which maps field names to their values'
            return OrderedDict(zip(self._fields, self))

        def _replace(_self, **kwds):
            'Return a new Point object replacing specified fields with new values'
            result = _self._make(map(kwds.pop, ('x', 'y'), _self))
            if kwds:
                raise ValueError('Got unexpected field names: %r' % kwds.keys())
            return result

        def __getnewargs__(self):
            'Return self as a plain tuple.  Used by copy and pickle.'
            return tuple(self)

        x = _property(_itemgetter(0), doc='Alias for field number 0')
        y = _property(_itemgetter(1), doc='Alias for field number 1')

>>> point=Point(1,2)
>>> print point.x
1
可以看到就是生成一个subclass它里面的属性为这两个值x,y。

3. shlex 模块

>>> import shlex
>>> text="""a b c"""
>>> print 'original:',repr(text)
original: 'a b c'
>>> lexer=shlex.shlex(text)
>>> for token in lexer:
...     print repr(token)
...
'a'
'b'
'c'

可以进行字符串分割处理

4. 处理命令行的参数列表

parser.add_argument("--foo",nargs="*")

会将参数拼成一个list里面比如

>>> parser = argparse.ArgumentParser()

>>> parser.add_argument("--foo",nargs="*")

>>> parser.parse_args('a b --foo x y '.split())

Namespace(foo=['x','y'])

拼成一个参数列表

parser.add_argument("--foo",nargs="+")

这个效果其实跟*效果差不多也是拼成一个列表，但是如果没有传一个参数进去的话那就返回一个空的错误信息。必须要有一个元素才行的

parser.add_argument("--foo",nargs=N)

表示接收的参数个数然后输入到一个列表

const 这个参数用来存储常量值（不是来自命令行输入但是又必须）

Action支持如下几种action

store 将会存储参数的值，这个是默认的action如下：

>>> parser=argparse.ArgumentParser()

>>> parser.add_argument('--foo')

>>> parser.parse_args('--foo 1'.split())

Namespace(foo='1')

store_const 这将会存储这个值到const的常量里面.

>>> parser = argparse.ArgumentParser()

>>> parser.add_argument('--foo',action='store_const',const=42)

>>> parser.parse_args('--foo 1'.split())

Namespace(foo=42)

store_true与store_false存储的值为True与False

>>> parser = argparse.ArgumentParser()

>>> parser.add_argument('--foo',action='store_true')

>>> parser.add_argument('--bar',action='store_false')

>>> parser.parse_args('--foo --bar'.split())

Namespace(bar=False,foo=True)

append 将元素的值append到一个list里面

>>>parser = argparse.ArgumentParser()

>>> parser.add_argument('--foo',action='append')

>>> parser.parse_args('--foo 1 --foo 2'.split())

Namespace(foo=['1','2'])

append_const 将元素的值append到一个list里面

还可以实现自定义的API。支持__call__：

option_string 将会调用这个API。

>>> class FooAction(argparse.Action):

        def __call__(self,parser,namespace,values,option_string=None):

            print ('%r %r %r' % (namespace,values,option_string))

    setattr(namespace,self.dest,values)

>>>parser = argparse.ArgumentParser()

>>> parser.add_argument('--foo',action=FooAction)

>>> parser.add_argument('bar',action=FooAction)

>>> parser.parse_args('1 --foo 2'.split())

Namespace(bar=None,foo=None)  '1',None

Namespace(bar='1',foo=None)   '2','--foo'

>>>args

Namespace(bar='1',foo='2')