# -*- coding: utf-8 -*-

# ====================

#File: python

#Author: python

#Date: 2014

#====================

__author__ = ‘Administrator‘

#执行环境

#可调用对象

"""

许多的python 对象都是我们所说的可调用的，即是任何能通过函数操作符“（）”来调用的对象。要调用可调用对象，

函数操作符得紧跟在可调用对象之后。Python 有4 种可调用对象：函数，方法，类，以及一些类的实例。记住这些对象的任何引用或者别名都是可调用的。

"""

#func

#内建函数BIF

"""

BIF 属性 描述

bif.__doc__ 文档字符串（或None)

bif.__name__ 字符串类型的文档名字

bif.__self__ 设置为None（保留给built-in 方法）

bif.__module__ 存放bif 定义的模块名字(或None)

"""

print dir(type)

print type(dir)

#用户定义的函数（UDF）

"""

UDF（User-Defined Function，用户定义的函数）通常是用python 写的，定义在模块的最高级，因此会作为全局名字空间的一部分(一旦创建好内建名字空间）装载到系统中。

"""

"""

udf.__doc__ 文档字符串(也可以用udf.func_doc)

udf.__name__ 字符串类型的函数名字（也可以用 udf.func_name)

udf.func_code 字节编译的代码对象

udf.func_defaults 默认的参数元组

udf.func_globals 全局名字空间字典； 和从函数内部调用globals(x)一样

udf.func_dict 函数属性的名字空间

udf.func_doc (见上面的udf.__doc__)

udf.func_name (见上面的udf.__name__)

udf.func_closure 包含了自由变量的引用的单元对象元组

"""

def foo():

    pass

print type(foo)

#lambda比较特殊

la=lambda x:x*2

print la(2)

print type(la)

#直接调用 type(lambda:1)

print(type(lambda :1))

#看下udf名字中的foo()

print foo.__name__

#方法

#方法即是类的一个属性而已

"""

内建方法（BIM）

BIM 属性 描述

bim.__doc__ 文档字串

bim.__name__ 字符串类型的函数名字

bim.__self__ 绑定的对象

bim.__self__说明了一个非常重要的信息是：内建方法返回的是一个对象！！！！！

"""

print foo.__doc__

#内建方法简单的理解为：内建类型自身所具有的方法，故返回的是一个内建类型！！！

print type([].append)#<type ‘builtin_function_or_method‘>

print dir([].append)

#用户定义的方法（UDM）

"""

UDM（User-defined method，用户定义的方法）包含在类定义之中，只是拥有标准函数的包装，仅有定义它们的类可以使用。

如果没有在子类定义中被覆盖掉，也可以通过子类实例来调用它们。正如在13 章解释的那样，

UDM 与类对象是关联的（非绑定方法），但是只能通过类的实例来调用(绑定方法）。无论UDMs 是否绑定，所有的UMD 都是相同的类型——“实例方法“，

"""

class C(object):

    def foo(self):pass#定义udm

c=C()#实例化

print type(C)#<type ‘type‘>#类的别名

print type(c)#<class ‘__main__.C‘>#实例的类别

print type(C.foo)#<type ‘instancemethod‘>#非绑定方法类别

print type(c.foo)#<type ‘instancemethod‘>#绑定方法类别

print C.foo#<unbound method C.foo>非绑定方法对象

print c.foo#<bound method C.foo of <__main__.C object at 0x0000000001EA5AC8>>绑定方法对象

"""

UDM 属性 描述

udm.__doc__ 文档字符串（与udm.im_fuc.__doc__相同）

udm.__name__ 字符串类型的方法名字（与umd.im_func.__name__相同）

udm.__module__ 定义udm 的模块的名字(或none)

udm.im_class 方法相关联的类（对于绑定的方法；如果是非绑定，那么为要求udm 的类）

udm.im_func 方法的函数对象（见UDFs）

udm.im_self 如果绑定的话为相关联的实例，如果非绑定位为none

"""

"""

 类

我们可以利用类的可调用性来创建实例。“调用”类的结果便是创建了实例，即大家所知道的实例化。类有默认构造函数，

该函数什么都不做，基本上只有一个pass 语句。程序员可以通过实现__int__()方法，来自定义实例化过程。实例化调用的任何参数都会传入到构造函数里。

"""

class C1(object):

    def __init__(self,*arg):

        print ‘\n‘.join(arg)

c1=C1()

print c1

c2=C1(‘hello‘)

"""

 类的实例

python 给类提供了名为__call__的特别方法，该方法允许程序员创建可调用的对象（实例）。默认情况下，__call__()方法是没有实现的，这意味着大多数实例都是不可调用的。然而，如果在类定义中覆盖了这个方法，那么这个类的实例就成为可调用的了。调用这样的实例对象等同于调用__call__()方法。自然地，任何在实例调用中给出的参数都会被传入到__call()__中。……那么foo()就和foo.__call__(foo)的效果相同，

这里foo 也作为参数出现，因为是对自己的引用，实例将自动成为每次方

法调用的第一个参数。如果 ___call___()有参数，比如，(self, arg),那么foo(arg)就和调用foo.__call__(foo, arg)一样

"""

class C2(object):

    def __call__(self, *args):

        print "i am callable! called with args:\n", args

cx=C2()

print cx

print callable(cx)#实例可调用

cx()

cx(3)#一个参数

cx(3,‘python‘,‘not‘)#多个参数

#注意:只要定义类的实现__call__方法，类的实例才能成为可调用

"""

代码对象

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

如果要执行python 代码，那么该代码必须先要转换成字节编译的代码（又称字节码）。

这才是真正的代码对象。然而，它们不包含任何关于它们执行环境的信息，这便是可调用物存在的原因，它被用来包装一个代码对象并提供额外的信息。

"""

#callable(object)

#说明:：检查对象object是否可调用。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。

print callable(1)#数字:False

print callable(int)#内建函数True

#自定义

def foox():pass

print callable(foox)#函数True

print callable(C)#类True

# compile(source, filename, mode[, flags[, dont_inherit]]) -> code object

#将source编译为代码或者AST对象。代码对象能够通过exec语句来执行或者eval()进行求值。

"""

参数source：字符串或者AST（Abstract Syntax Trees）对象。

参数 filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。

参数model：指定编译代码的种类。可以指定为 ‘exec’,’eval’,’single’。

参数flag和dont_inherit：这两个参数暂不介绍，可选参数。

"""

code1=‘for  i in range(10):print i‘

comx=compile(code1,‘‘,‘exec‘)

exec code1

s1=‘3*4*5‘

a=compile(s1,‘‘,‘eval‘)

print eval(a)

"""

eval 求值，与自己使用

single 可执行语句 【与exec一起使用】

exec执行语句组，与自己使用

"""

#求值

print eval(compile(‘100+100‘,‘‘,‘eval‘))

#单一语句

sing_code=compile(‘print " hello world!"‘,‘‘,‘single‘)

exec sing_code

#语句组

# exec_code=compile("""

# req=input(‘num:‘)

# for i in range(req):

#        print i""",‘‘,‘exec‘)

# exec exec_code

# #eval(expression[, globals[, locals]])

"""

如果你省略了一个或者两个名称空间参数,那么当前的全局和局部名称空间就被使用.如果一个函数体内嵌嵌套函数或lambda匿名函数时,同时又在函数主体中使用exec或execfile()函数时， 由于牵到嵌套作用域，会引发一个SyntaxError异常.（此段原文:If you omit one or both namespaces, the current values of the global and local namespaces are used. Also,due to issues related to nested scopes, the use of exec or execfile() inside a function body may result in a SyntaxError exception if that function also contains nested function definitions or uses the lambda operator.）

在Python2.4中俺未发现可以引起异常

注意例子中exec语句的用法和eval(), execfile()是不一样的. exec是一个语句(就象print或while), 而eval()和execfile()则是内建函数.

exec(str) 这种形式也被接受，但是它没有返回值。

当一个字符串被exec,eval(),或execfile()执行时,解释器会先将它们编译为字节代码，然后再执行.这个过程比较耗时,所以如果需要对某段代码执行很多次时,最好还是对该代码先进行预编译,这样就不需要每次都编译一遍代码，可以有效提高程序的执行效率。

compile(str ,filename ,kind )函数将一个字符串编译为字节代码, str是将要被编译的字符串, filename是定义该字符串变量的文件，kind参数指定了代码被编译的类型-- ‘single‘指单个语句, ‘exec‘指多个语句, ‘eval‘指一个表达式. cmpile()函数返回一个代码对象，该对象当然也可以被传递给eval()函数和exec语句来执行

"""

"""

对表达式求值, source是字符串或预编译代码对象. globals必须是字典, 是source的全局名称空间.

locals可以是任意的映射对象(实现了__getitem__()方法的对象), globals和locals默认是globals()和locals()返回的值.

如果只传入了globals参数, 那么该字典也会作为locals传入.

[, globals[, locals]虽然是可选的，但是如果给出参数，globals必须是字典，locals可以是任何映射对象

"""

#例子

print eval(‘100+200‘)

#exec语法

"""

exec语句用来执行储存在字符串或文件中的Python语句。例如，我们可以在运行时生成一个包含Python代码的字符串，然后使用exec语句执行这些语句。

"""

exec ‘print "hell"‘

#exec还支持文件对象

"""

f=open(‘a.txt‘,‘r‘)

exec f

"""

"""

execfile(file[,globals[,locals]])

execfile()函数与exec语句等价，不同之处在于：execfile()函数执行文件中的语句，而exec语句处理字符串。其中globals和locals参数应是字典，该字典包含文件在执行期间有效的符号表；如果locals参数省略，则所有的引用都使用globals名称空间。如

果两个可选参数都省略，文件就访问运行期间的当前符号表。

"""