2015/10/9 Python基础(21)：可调用和可执行对象

在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
>>> int('')
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

代码并不难理解，但其所做的事的确很有趣不是么？