在Python中有多种运行外部程序的方法,比如,运行操作系统命令或另外的Python脚本,或执行一个磁盘上的文件,或通过网络来运行文件。这完全取决于想要干什么。特定的环境包括:
在当前脚本继续运行
创建和管理子进程
执行外部命令或程序
执行需要输入的命令
通过网络来调用命令
执行命令来创建需要处理的输出
执行其他的Python脚本
执行一系列动态生成的Python语句
导入Python模块
Python中,内建和外部模块都可以提供上述各种功能。程序员得根据实现的需要,从这些模块中选择合适的处理方法。
可调用对象
许多Python对象都是我们所说的可调用的,即是任何通过函数操作符()来调用的对象。Python有4中可调用对象:函数,方法,类,以及一些类的实例。
1.函数
Python有3中不同类型的函数对象,第一种是内建函数。
内建函数(BIFs)
BIF是用C/CPP写的,编译过后放入Python解释器,然后把它们作为第一(内建)名字空间的一部分加载进系统。这些函数在_builtin_模块里,并作为__builtins__模块导入到解释器中。
可以用dir()列出函数的所有属性:
>>> dir(type) [‘__abstractmethods__‘, ‘__base__‘, ‘__bases__‘, ‘__basicsize__‘, ‘__call__‘, ‘__class__‘, ‘__delattr__‘, ‘__dict__‘, ‘__dictoffset__‘, ‘__doc__‘, ‘__eq__‘, ‘__flags__‘, ‘__format__‘, ‘__ge__‘, ‘__getattribute__‘, ‘__gt__‘, ‘__hash__‘, ‘__init__‘, ‘__instancecheck__‘, ‘__itemsize__‘, ‘__le__‘, ‘__lt__‘, ‘__module__‘, ‘__mro__‘, ‘__name__‘, ‘__ne__‘, ‘__new__‘, ‘__reduce__‘, ‘__reduce_ex__‘, ‘__repr__‘, ‘__setattr__‘, ‘__sizeof__‘, ‘__str__‘, ‘__subclasscheck__‘, ‘__subclasses__‘, ‘__subclasshook__‘, ‘__weakrefoffset__‘, ‘mro‘]
从内部机制来看,因为BIFs和内建方法(BIMs)属于相同类型,所以对BIF或者BIM调用type()的结果是:
>>> type(dir) <type ‘builtin_function_or_method‘>
用户定义的函数(UDF)
UDF通常是用Python写的,定义在模块的最高级,因此会作为全局名字空间的一部分装置到系统中。函数也可以在其他函数体内定义,我们可以对多重嵌套作用域中的属性进行访问。
从内部机制来看,用户自定义的函数是“函数”类型的:
>>> def foo():pass >>> type(foo) <type ‘function‘>
lambda表达式
lambda表达式和用户自定义函数相比,略有不同。虽然它们也是返回一个函数对象,但是不是用def语句创建的,而是用lambda关键字:
因为lambda表达式没有给命名绑定的代码提供基础结构,所以要通过函数式编程接口来调用,或把它们的引用赋值给一个变量,然后就可以直接调用或者再通过函数来调用。变量仅是个别名,并不是函数对象的名字。
通过lambda来创建函数的对象除了没有命名之外,和UDF有相同的属性;__name__或者func_name属性给定位字符串"<lambda>"
>>> lambdaFunc = lambda x: x * 2 >>> lambdaFunc(12) 24 >>> type(lambdaFunc) <type ‘function‘> >>> lambdaFunc.__name__ ‘<lambda>‘
如果是UDF的名字,则是这样:
>>> def foo():pass >>> foo.__name__ ‘foo‘
以上是三种函数对象
2.方法
用户自定义方法是被定义为类的一部分的函数。许多Python的数据类型,比如列表和字典,也有方法,被称为内建方法。为了说明所有权的类型,方法通过对象的名字和句点属性标识符命名。
内建方法(BIMs)
刚刚我们说了BIF和BIM的类似之处。只有内建类型有内建方法。对于内建方法,type()工厂函数给出了和BIF一样的输出。
>>> type([].append) <type ‘builtin_function_or_method‘>
此外BIM和BIF两者有相同属性。不同之处在于BIM的__self__属性指向一个Python对象,BIF指向None。
用户定义的方法(UDM)
UDM包含在类定义之中,只是拥有标准函数的包装,仅有定义他们的类可以使用。如果没有在子类定义中被覆盖,也可以通过子类实例来调用它们。
3.类
调用类的结果就是创建了实例,也就是实例化。
4.类的实例
Python给类提供了名为__call__的特别方法,该方法允许程序员创建可调用的对象(实例)。默认情况下,__call__()方法是没有实现的,这意味着大多数情况下实例是不可调用的。然而,如果在类中覆盖了这个方法,那么这个类的实例就成为可调用的了。调用这样的实例对象等同于调用__call__()方法。如:foo()和foo.__call__(foo)的效果相同,这里的foo也作为参数出现,因为是对自己的引用,实例将自动成为每次方法调用的第一个参数,如果__call__()有参数,那么foo(arg)就和foo.__call__(foo, arg)一样。
代码对象
可调用对象是Python执行环境里最重要的部分,然而这并不是全部。Python语句,赋值,表达式,甚至还有模块构成了更宏大的场面。这些可执行对象无法像可调用物那样被调用。这些代码块被称为代码对象。
每个可调用物的核心都是代码对象,由语句,赋值,表达式,以及其他可调用物组成。查看一个模块意味着观察一个较大的、包含了模块中所有代码的对象。然后代码分成语句,赋值,表达式,以及可调用物。可调用物又可以递归分解到下一层,那里有它自己的代码对象。
一般来说,代码对象可以作为函数或者方法调用的一部分来执行,也可用exec语句或内建函数eval()来执行。从整体上看,一个Python模块的代码对象是构成该模块的全部代码。
如果要执行Python代码,那么该代码必须先要转换成字节编译的代码(又称字节码)。这才是真正的代码对象。然而,它们不包含任何关于它们执行环境的信息,这便是可调用物存在的原因,它被用来包装一个代码对象并提供额外的信息。
UDF有 udf.func_code 属性就是代码对象。UDM的udm.im_func也是一个函数对象,他同样有它自己的udm.im_func.func_code代码对象。这样的话,你会发现,函数对象仅是代码对象的包装,方法则是给函数对象的包装。当研究到最底层,便是一个代码对象。
可执行的对象声明和内建函数
Python提供了大量的BIF来支持可调用/可执行对象。
1.callable()
callable()是一个布尔函数,确定一个对象是否可以用函数操作符()来调用。如果可调用便返回True,否则便是False。
2.compile()
compile()函数允许程序员在运行时刻迅速生成代码对象,然后就可以用exec语句或者内建函数eval()来执行这些对象或者他们进行求值。
compile的三个参数都是必需的,第一参数代表了要编译的Python代码。第二个参数是字符串,虽然是必需的,但通常被置为空串,该参数代表了存放代码对象的文件的名字(字符串类型)。compile的通常用法是动态生成字符串形式的Python代码,然后生成一个代码对象——代码显然没有存放在任何文件。最后的参数是个字符串,用来表明代码的类型。有三个可能值:
‘eval‘ 可求值的表达式[和eval()一起使用]
‘single‘ 单一可执行语句[和exec一起使用]
‘exec‘ 可执行与剧组[和exec一起使用]
可求值表达式
>>> eval_code = compile(‘10-2‘,‘‘,‘eval‘) >>> eval(eval_code) 8
单一可执行语句
>>> single_code = compile(‘print "Hello world"‘,‘‘,‘single‘) >>> single_code <code object <module> at 024DC698, file "", line 1> >>> exec single_code Hello world
可执行语句组
>>> exec_code = compile(""" req = input(‘Count how many numbers?‘) for eachNum in range(req): print eachNum """,‘‘,‘exec‘) >>> exec exec_code Count how many numbers?6 0 1 2 3 4 5
3.eval()
eval()对表达式求值,表达式可以为字符串或内建函数compile()创建的预编译代码对象。这个对象是第一个也是最重要的参数。第二个和第三个参数是可选的,分别代表了全局和局部名称空间中的对象。如果给出了这两个参数,全局必须是个字典,局部可以是任意的映射对象。如果没有给出这两个参数,分别默认为globals()和locals()返回的对象。如果只传入了一个全局字典,那么该字典也作为局部参数传入。
这是eval()的一个例子。
>>> eval(‘123‘) 123 >>> int(‘123‘) 123 >>> eval(‘123+234‘) 357 >>> int(‘123+234‘) Traceback (most recent call last): File "<pyshell#10>", line 1, in <module> int(‘123+234‘) ValueError: invalid literal for int() with base 10: ‘123+234‘
开始,我们传入‘123‘给eval()和int()的时候,返回了相同的结果,但是方式是不尽相同的,eval()接受引号内的字符串把它作为Python表达式求值,int()接受代表整数的字符串并把它转换为整数。而当我们输入‘123+234‘时,情况就不一样了。int()调用就失败了。可以认为eval()函数对表达式两端的引号视而不见,将它执行在解释器上,返回结果。
4.exec
和eval()相似,exec语句执行代码对象或字符串形式的Python代码。类似地,用compile()预编译重复代码有助于改善性能,因为在调用时不必经过字节编译处理。exec只接受一个参数,语法是:
exec obj
obj可以是原始的字符串,比如单一语句或语句组,也可以预编译层一个代码对象。
>>> exec """ x = 0 print ‘x is currently:‘,x while x < 5: x += 1 print ‘incrementing x to:‘,x """ x is currently: 0 incrementing x to: 1 incrementing x to: 2 incrementing x to: 3 incrementing x to: 4 incrementing x to: 5
exec还可以接受有效的Python文件对象。如果我们用上面的多行代码创建一个xcount.py的文件,那么也可以这样执行相同代码:
>>> f = open(‘xcount.py‘) # open the file >>> exec f # execute the file x is currently: 0 incrementing x to: 1 incrementing x to: 2 incrementing x to: 3 incrementing x to: 4 incrementing x to: 5
上面我们调用了文件f,如果在完成后继续调用它
>>> exec f >>>
调用会失败。并不是真正的失败,只是不再做任何事。事实上,exec已从文件中读取了全部数据且停留在文件末尾(EOF)。当用相同的文件对象对exec进行调用的时候,没有可执行的代码了,所以exec什么都不做。
我们可以用tell()方法来告诉我们处于文件的何处,然后用os.path.getsize()来告诉我们脚本由多大。然后就会发现,这两个数字完全一样:
>>> f.tell() 116 >>> f.close() >>> from os.path import getsize >>> getsize(‘xcount.py‘) 116
如果想在不关闭和重新打开文件的情况下再次运行它,可以用seek()到文件最开头并再次调用exec。假定我们还没有调用f.close(),那么:
>>> f.seek(0) >>> exec f x is currently: 0 incrementing x to: 1 incrementing x to: 2 incrementing x to: 3 incrementing x to: 4 incrementing x to: 5 >>> f.close()
5.input()
之前用到的内建函数input()是eval()和raw_input()的组合,等价于eval(raw_input()),input()和raw_input()一样有一个可选的参数给用户字符串提示。
input不同于raw_input(),input()返回的数据是对输入表达式求值的结果,是一个Python对象。
6.使用Python在运行时生成和执行Python代码
书上提供了两个例子,这两个例子在运行时吧Python代码作为字符串并执行。
第一个例子是loopmake.py脚本。一个简单迅速和执行循环的计算机辅助软件工程。提示用户给出各种参数,生成代码字符串,并执行它。
dashes = ‘\n‘ + ‘-‘ * 50 exec_dict = { ‘f‘:‘‘‘ #for loop for %s in %s: print %s ‘‘‘, ‘s‘:‘‘‘ # sequence while loop %s = 0 %s = %s while %s < len(%s): print %s[%s] %s = %s + 1 ‘‘‘, ‘n‘:‘‘‘ # counting while loop %s = %d while %s < %d: print %s %s = %s + %d ‘‘‘ } def main(): ltype = raw_input(‘Loop type? (For/While)‘) dtype = raw_input(‘Data type? (Number/Sequence)‘) if dtype == ‘n‘: start = input(‘Starting value? ‘) stop = input(‘Ending value (non-inclusive)? ‘) step = input(‘Stepping value? ‘) seq = str(range(start, stop, step)) else: seq = raw_input(‘Enter sequence:‘) var = raw_input(‘Iterative variable name?‘) if ltype == ‘f‘: exec_str = exec_dict[‘f‘] % (var, seq, var) elif ltype == ‘w‘: if dtype == ‘s‘: svar = raw_input(‘Enter sequence name? ‘) exec_str = exec_dict[‘s‘] % (var, svar, seq, var, svar, svar, var, var, var) elif dtype == ‘n‘: exec_str = exec_dict[‘n‘] % (var, start, var, stop, var, var, var, step) print dashes print ‘The custom-generated code for you is:‘ + dashes print exec_str + dashes print ‘The execution of the code:‘ + dashes exec exec_str print dashes if __name__ == ‘__main__‘: main()
有兴趣的人可以执行一下这段代码,十分有趣,可以帮助你生成代码并执行。反正我写这段代码的时候感觉到了exec和input的强大。
第二个例子是有条件地执行代码
这是代码:
def foo(): return True def bar(): ‘bar() does not do much‘ return True foo.__doc__ = ‘foo() does not do much‘ foo.tester = ‘‘‘ if foo(): print ‘PASSED‘ else: print ‘FAILED‘ ‘‘‘ for eachAttr in dir(): obj = eval(eachAttr) if isinstance(obj, type(foo)): if hasattr(obj, ‘__doc__‘): print ‘\nFunction "%s" has a doc string:\n\t%s‘ % (eachAttr, obj.__doc__) if hasattr(obj, ‘tester‘): print ‘Function "%s" has a tester... executing‘ % eachAttr exec obj.tester else: print ‘Function "%s" has no tester... skipping‘ % eachAttr else: print ‘"%s" is not a function‘ % eachAttr
下面是执行后的结果:
>>> "__builtins__" is not a function "__doc__" is not a function "__file__" is not a function "__name__" is not a function "__package__" is not a function Function "bar" has a doc string: bar() does not do much Function "bar" has no tester... skipping Function "foo" has a doc string: foo() does not do much Function "foo" has a tester... executing PASSED
代码并不难理解,但其所做的事的确很有趣不是么?