python执行外部程序模块pyshell

　　写python程序的时候需要用到调用外部命令的模块，看了一下，还真不少，头疼，用着不顺手。根据官网推荐，我根据官网的subprocess模块定制了一个自己的shell，同时借鉴了github上面的shellpy模块，而且我觉得go语言的go-sh确实令人喜欢，所以我觉得基于流操作将会改变我们的很多工作。

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import shlex
from subprocess import Popen
from subprocess import PIPE

def py_ver():
    '''
    判断python的版本
    '''
    import sys
    return sys.version_info[0]

if py_ver() == 2:
    builtin_str = str
    bytes = str
    str = unicode
    basestring = basestring
    numeric_types = (int, long, float)

elif py_ver() == 3:
    builtin_str = str
    str = str
    bytes = bytes
    basestring = (str, bytes)
    numeric_types = (int, float)
else:
    raise ValueError(u'python 版本不正确')

def parse_shell_token(t):
    import os
    # handle '~'
    t = os.path.expanduser(t)
    # handle env var
    t = os.path.expandvars(t)
    return t

def pipe_to_tmp(data):
    '''
    把管道或者内存中的数据缓存到临时文件
    '''
    if isinstance(data, (unicode, str)):
        data = data.encode('utf-8')

    import tempfile
    stdin_tmp = tempfile.SpooledTemporaryFile()
    stdin_tmp.write(data)
    stdin_tmp.seek(0)
    return stdin_tmp

class Shell(object):

    def __init__(self, cmd_str, input_pipe=None):
        self.cmd_str = cmd_str
        self.popen = None
        self.input_pipe = input_pipe
        self.std = {'out': None, 'err': None}

    def __getPopen(self):
        if self.popen is None:
            self.popen = Popen(
                map(parse_shell_token, shlex.split(self.cmd_str, posix=False)),
                stdin=self.input_pipe, stdout=PIPE, stderr=PIPE)
        return self.popen

    def pipe(self, cmd_str):
        input_pipe = None
        pp = self.__getPopen()
        if pp.stdout.closed:
            # 如果命令已经执行，那么就把标准输出的结果保存到临时文件
            input_pipe = pipe_to_tmp(self.std['out'])
        else:
            input_pipe = pp.stdout
        # print input_pipe.read()
        # pp.stdout.close() # allow pp to receive SIGPIPE?
        return Shell(cmd_str, input_pipe=input_pipe)

    def __communicate(self):
        pp = self.__getPopen()
        if pp.returncode is None:
            self.std['out'], self.std['err'] = pp.communicate()

    def run(self):
        if self.std['out'] is None:
            self.__communicate()
        print self.std['out']

    def stdout(self):
        if self.std['out'] is None:
            self.__communicate()
        return self.std['out']

    def stderr(self):
        if self.std['err'] is None:
            self.__communicate()
        return self.std['err']

cmd = Shell
if __name__ == '__main__':

    # cmd('ls -l').run()
    # cmd('ls -l').pipe('grep Shell.py').run()
    # cmd('cat').pipe('> hello;cat hello').run()

    # cmd('ls ~').run()
    cmd('echo dddd').run()

下面这个是改良版本，参考了python的bash类库的实现，仅用于学习

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 from subprocess import Popen
 from subprocess import PIPE
 import shlex

 def py_ver():
     '''
     得到python的版本
     '''
     import sys
     return sys.version_info[0]
 _ver = py_ver()

 if _ver == 2:
     builtin_str = str
     bytes = str
     str = unicode
     basestring = basestring
     numeric_types = (int, long, float)

 elif _ver == 3:
     builtin_str = str
     str = str
     bytes = bytes
     basestring = (str, bytes)
     numeric_types = (int, float)
 else:
     raise ValueError(u'python 版本不正确')
 del _ver

 #解析字符串中的环境变量
 def parse_shell_token(t):
     import os
     #将～等用用户的家目录进行替换
     t = os.path.expanduser(t)
     #path中可以使用环境变量,'$PATH'...
     t = os.path.expandvars(t)
     return t

 class cmd(object):
     def __init__(self, *args, **kwargs):
         self.stdout = None
         self.cmd(*args, **kwargs)
     def cmd(self, cmd, env=None, stdout=PIPE):
         p = Popen(parse_shell_token(cmd), shell=True,
                   stdout=stdout, stdin=PIPE, stderr=PIPE, env=env)
         self.stdout, self.stderr = p.communicate(input=self.stdout)
         self.code = p.returncode
         return self
     def __repr__(self):
         return self.value()

     def __unicode__(self):
         return self.value()

     def __str__(self):
         return self.value()

     def __nonzero__(self):
         return self.__bool__()

     def __bool__(self):
         return bool(self.value())

     def value(self):
         if not self.stdout:
             return ''
         return self.stdout.strip()

 if __name__ == '__main__':
     #print cmd('ls -l')
     print cmd("ls . | grep 'pyc'")
     #print cmd("konsole --hold -e 'konsole --help'")
     #print cmd('scrapy list')
     print cmd('ls $HOME')
      #print cmd('ls ~')