Python回顾与整理12:执行环境

0.说明

    

    作为《Python核心编程》核心部分的最后一章,这篇的内容也相当重要。对于高级部分的整理,将采用《Python核心编程》第三版,但是,方式会以之前的完全不一样了。




1.可调用对象


    可调用对象即可通过函数操作符“()”来调用的对象,也可以通过函数式编程接口来进行调用,如apply()、filter()、map()和reduce()。Python有4种可调用对象:函数、方法、类和一些类的实例。


(1)函数

    Python中有三种不同类型的函数:内建函数(BIF)、用户定义的函数(UDF)和lambda表达式。

  • 内建函数(BIF)

    用C/C++写的,编译过后放入Python解释器中,然后把它们作为第一(内建)名称空间的一部分加载进系统,这些函数在__builtin__模块里,并作为__builtins__模块导入到解释器中。

    可以使用dir()来列出函数的所有属性,另外从内部机制来看,BIF和内建方法属于相同的类型,所以全长type()调用的结果是:

>>> type(dir)
<type 'builtin_function_or_method'>
>>> 
>>> type('xpleaf'.upper)
<type 'builtin_function_or_method'>

    但是应用于工厂函数,得到的结果是不一样的,虽然这些工厂函数本身是内建函数:

>>> type(int)
<type 'type'>

    那是因为,本质上这些工厂函数是类。

  • 用户定义的函数(UDF)

    用户定义的函数通常是用Python写的,调用type()的结果如下:

>>> def foo():pass
... 
>>> type(foo)
<type 'function'>

    UDF本身也有很多属性:

>>> dir(foo)
['__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__doc__', '__format__', '__get__', '__getattribute__', '__globals__', '__hash__', '__init__', '__module__', '__name__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'func_closure', 'func_code', 'func_defaults', 'func_dict', 'func_doc', 'func_globals', 'func_name']
  • lambda表达式(名为“<lambdda>”的函数)

    lambda返回一个函数对象,只是lambda表达式没有给命令绑定的代码提供基础结构,所以要通过函数式编程接口来调用,或把它们的引用赋值给一个变量,通过该变量来进行调用,只是需要注意的是,这个变量仅仅是个别名,并不是函数对象的名字。

    通过lambda来创建的函数对象除了没有命名外,和用户定义的函数是有相同的属性的,当然,对于__name__属性,值为"<lambda>":

>>> lambdaFunc = lambda x: x*2
>>> lambdaFunc(100)
200
>>> type(lambdaFunc)
<type 'function'>
>>> 
>>> lambdaFunc.__name__
'<lambda>'
>>> 
>>> foo.__name__
'foo'


(2)方法

    用户自定义方法是被定义为类的一部分函数,而许多Python数据类型本身也有方法,这些方法被称为内建方法。

  • 内建方法(BIM)

    只有内建类型有内建方法,如下:

>>> type([].append)
<type 'builtin_function_or_method'>

    BIM和BIF两者享有相同的属性,只是不同的是,BIM的__self__属性指向一个Python对象,而BIF指向None:

>>> dir([].append)
['__call__', '__class__', '__cmp__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
>>> [].append.__self__
[]
>>> dir.__self__
>>> print [].append.__self__
[]
>>> print dir.__self__
None
  • 用户定义的方法(UDM)

    所有的UDM都是相同的类型,即“实例方法”,无论该方法是否有绑定的实例:

>>> class C(object):
...     def foo(self):
...             pass
... 
>>> c = C()
>>> 
>>> type(C.foo)
<type 'instancemethod'>
>>> type(c.foo)
<type 'instancemethod'>

    只是访问对象本身会揭示该方法是否绑定:

>>> c.foo
<bound method C.foo of <__main__.C object at 0x7f37a3c45810>>
>>> C.foo
<unbound method C.foo>


(3)类

    调用类,其实就是创建一个实例对象。类有默认构造器,但是这个函数什么都不做,可以通过实现__init__()方法来自定义实例化过程。


(4)类的实例

    Python给类提供了名为__call__的特别方法,该方法允许程序创建可调用的对象(实例)。默认情况下没有实现该方法,因此实例是不可调用的。

    在定义类时覆盖__call__方法即可达到实例可调用的效果,这样,调用实例对象就等同于调用__call__()方法,参数的设置跟类的构造器原理是一样的:

>>> class C(object):
...   def __call__(self, *args):
...     print "I'm callable! Called with args:\n", args
... 
>>> c = C()
>>> c
<__main__.C object at 0x7f37a3c2d090>
>>> callable(c)    # 实例是可调用的
True
>>> c()    # 调用实例
I'm callable! Called with args:
()
>>> c(3)    # 传入参数
I'm callable! Called with args:
(3,)
>>> c(3, 'no more , no less')
I'm callable! Called with args:
(3, 'no more , no less')
>>> 
>>> c.__call__(3)    # 与c(3)的调用原理是一样的
I'm callable! Called with args:
(3,)
>>> c.__call__(3, 'no more, no less')
I'm callable! Called with args:
(3, 'no more, no less')




2.代码对象


    每个可调用物的核心都是代码对象,由语句、赋值、表达式和其他可调用物组成。查看一个模块意味着观察一个较大的、包含了模块中所有代码的对象。然后代码可以分成语句、赋值、表达式,以及可调用物。可调用物又可以递归分解到下一层,那儿有自己的代码对象。

    一般来说,代码对象可以作为函数或者方法调用的一部分来执行(比如语句或赋值等),也可用exec语句或内建函数eval()来执行。从整体上看,一个Python模块的代码对象是构成该模块的全部代码。

    如果要执行Python代码,那么该代码必须先要转换成字节编译的代码(又称字节码)。这才是真正的代码对象。然而,它们不包含任何关于它们执行环境的信息,这便是可调用物存在的原因,它被用来包装一个代码对象并提供额外的信息(如属性等相关信息)。

    函数对象仅是代码对象的包装,方法则是给函数对象的包装,只是不同於单纯的代码对象,它们还提供了一些额外的信息。当研究到最底层,便会发现这是一个代码对象。

    在函数对象中,有一个func_code属性,其实就是指代码对象:

>>> def foo(): pass
... 
>>> foo.func_code
<code object foo at 0x7f37a5daceb0, file "<stdin>", line 1>




3.可执行的对象声明和内建函数


    常见的相关函数如下:

可执行的对象声明和内建函数
内建函数和语句描述
callable(obj)如果obj可调用,返回True,否则返回False
compile(string, file, type)从type类型中创建代码对象;file是代码存放的地方(通常设为"")
eval(obj, globals=globals(), locals=locals())对obj进行求值,obj是已编译为代码对象的表达式,或是一个字符串表达式;可以给出全局或者/和局部的名称空间
exec obj执行obj、单一的Python语句或者语句的集合,也就是说格式是代码对象或者字符串;obj也可以是一个文件对象(已经打开的有效的Python脚本中)
input(prompt='')等同于eval(raw_input(prompt=''))


(1)callable()

    callable()是一个布尔函数,确定一个对象是否可以通过函数操作符(())来调用:

>>> callable(dir)
True
>>> callable(1)
False
>>> def foo(): pass
... 
>>> callable(foo)
True


(2)compile()

    compile()函数允许程序员在运行时刻迅速生成代码对象,然后就可以用exec语句或者内建函数eval()来执行这些代码对象或者对它们进行求值。一个很重要的观点是:exec和eval()都可以执行字符串格式的Python代码。当执行字符串形式的代码时,每次都必须对这些代码进行字节编译处理。compile()函数提供了一次性字节代码预编译,以后每次调用的时候,就不用编译了。

    compile的三个参数都是必需的,第一参数借助了要编译的Python代码。第二个字符串,虽然是必需的,但通常被设置为空串。该参数代表了存放代码对象的文件的名字(字符串类型)。compile的通常用法是动态生成字符串形式的Python代码,然后生成一个代码对象——代码显然没有存放在任何文件,所以文件名就通常设置为空了。

    最后的参数是个字符串,它用来表明代码对象的类型,有三个可能值:

'eval'可求值的表达式,和eval()一起使用
'single'单一可执行语句,和exec一起使用
'exec'可执行语句组,和exec一起使用
  • 可求值表达式

>>> eval_code = compile('100+200', '', 'eval')
>>> eval_code
<code object <module> at 0x7f37a5db3cb0, file "", line 1>
>>> eval(eval_code)
300
  • 单一可执行语句

>>> single_code = compile('print "Hello world!"', '', 'single')
>>> single_code
<code object <module> at 0x7f37a3c2a0b0, 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()返回的对象:

>>> a = 3
>>> eval('a')
3
>>> def test_eval():
...   a = 6
...   print eval('a')
... 
>>> test_eval()
6
>>
>>> scope={}
>>> scope['a'] = 3
>>> scope['b'] = 4
>>> result = eval('a+b',scope)
>>> result
7


(4)exec

    exec语句只接受一个参数,即exec obj,obj除了可以是原始的字符串(单一语句或语句组)或是compile()编译的代码对象外,也可以是文件对象:

>>> f = open('xcount.py')
>>> for eachLine in f:
...   print eachLine,
... 
x = 0
print 'x is currently:', x
while x < 5:
	x += 1
	print 'incrementing x to:', x

>>> 
>>> f.tell()
86
>>> 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.tell()    # 执行完之后,就指针就停留在文件末尾(end-of-line,EOF)
86


(5)input()

    内建函数input()是eval()和raw_input()的组合,等价于eval(raw_input()),这说明input()和raw_input()本身还是有区别的。

    从功能上看,input不同于raw_input(),因为raw_input()总是以字符串的形式返回用户的输入;input()履行相同的任务,而且它还把输入作为Python表达式进行求值。这意味着input()返回的数据是对输入表达式求值的结果:一个Python对象。

    举例如下:

>>> aString = raw_input('Enter a list: ')
Enter a list: ['xpleaf', 'clyyh']
>>> aString
"['xpleaf', 'clyyh']"
>>> type(aString)
<type 'str'>
>>> 
>>> aList = input('Enter a list: ')
Enter a list: ['xpleaf', 'clyyh']
>>> aList
['xpleaf', 'clyyh']
>>> type(aList)
<type 'list'>


(6)使用Python在运行时生成和执行Python代码

    有需要时可以参考书本上的例子。






發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章