接着上一篇

7,函数是Python世界中的一级类对象

在Python里函数和其他东西一样都是对象

1
2
3
4
5
6
7
8
9
#coding:UTF8
print 
issubclass
(
int
, 
object
) 
True
def 
foo():
     
pass
print 
foo.__class__ 
# 1
<
type 
'function'
>
print 
issubclass
(foo.__class__, 
object
)
True

函数在Python里就是对象,和其他一样,在Python里,函数只是一些普通的值而已,也就是说把函数像参数一样传递给其他的函数或者从函数里返回函数,如:

1
2
3
4
5
6
7
8
9
10
11
#coding:UTF8
def 
add(x, y):
     
return 
x 
+ 
y
def 
sub(x, y):
     
return 
x 
- 
y
def 
apply
(func, x, y): 
# 1
     
return 
func(x, y) 
# 2
print 
apply
(add, 
2
, 
1
) 
# 3
3
print 
apply
(sub, 
2
, 
1
)
1

在#1处看到函数准备接收一个函数的变量,只是一个普通的变量而已,和其他变量一样,在#2处调用传进来的函数:"()代表这调用函数的操作并且调用变量包含额值.在#3处,能看到传递函数并没有特殊的用法".函数的名称只是跟其他变量一样的标识符而已

Python把频繁要用的操作变成函数作为参数进行使用,向通过传递一个函数给内置排序函数的key参数 从而 来自定义排序规则

1
2
3
4
5
6
7
8
9
10
11
12
#coding:UTF8
def 
outer():
     
def 
inner():
         
print 
"Inside inner"
     
return 
inner 
# 1
  
foo 
= 
outer() 
#2
print 
foo
<function inner at 
0x000000000269C048
>
 
foo()
Inside inner

 在#1处恰好是函数标识符的变量inner作为返回值返回出来 "把函数inner返回出来,否则它根本不可能会被调用到" 每次函数outer呗调用,函数inner都会被重新定义,如果它不被当做变量返回额话,每次执行过后将不复存在

在#2处捕获返回值--函数inner,将它存在一个新的变量foo里.当对foo进行求值,确定包含函数inner,而且能够对它进行调用

8,闭包

1
2
3
4
5
6
7
8
9
10
11
#coding:UTF8
 
def 
outer():
     
x 
= 
1
     
def 
inner():
         
print 
x 
# 1
     
return 
inner
foo 
= 
outer()
print 
foo.func_closure
 
(<cell at 
0x00000000026861F8
: 
int 
object 
at 
0x0000000001E279A8
>,)

x是outer里的一个局部变量,当函数inner在#1处打印x时,Python解释器会在inner内部查找相应的变量,事实也查不到,接着会到封闭作用域里查找,并且找到匹配

从变量的生存周期来看,变量x是函数outer的一个本地变量,意味着只有当函数outer正在运行时才会存在,根据Python运行模式,无法再函数outer返回之后继续调用函数inner,在函数inner调用时,变量x早已不复存在,可能会发生一个运行时的错误
但返回的函数inner可以继续工作,Python支持一个叫做函数闭包的特性,嵌套定义在非全局作用域里的函数能够记住它在被定义的时候它所处的封闭命名空间,这能够通过查看函数的func_closure属性得出结论，这个属性里面包含封闭作用域里面的值（只会包含被捕捉到的值，比如x，如果在outer里面还定义了其他的值，封闭作用域里面是不会有的)
每次函数outer被调用的时候，函数inner都会被重新定义。现在变量x的值不会变化，所以每次返回的函数inner会是同样的逻辑
稍微改动下:

1
2
3
4
5
6
7
8
9
10
11
12
13
#coding:UTF8
 
def 
outer(x):
     
def 
inner():
         
print 
x 
# 1
     
return 
inner
print1 
= 
outer(
1
)
print2 
= 
outer(
2
)
 
print1()
1
print2()
2

从中可以看到闭包--被函数记住的封闭作用域--能够被用来创建自定义的函数,本质上是一个硬编码的参数.事实上并不是传递参数1或者2给函数inner,实际上是创建了能够打印各种数字的各种自定义版本

闭包单独拿出来就是一个非常强大的功能,在某些方面:outer像是给inner服务器的构造器,x像是一个私有变量

9,装饰器

装饰器其实就是一个闭包,把一个函数当做参数然后返回一个替代版参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#coding:UTF8
 
def 
outer(func):
     
def 
inner():
         
print 
"before func"
         
ret 
= 
func() 
# 1
         
return 
ret 
+ 
1
     
return 
inner
def 
foo():
     
return 
1
decorated 
= 
outer(foo) 
# 2
print 
decorated()
 
before func
2

定义了一个函数outer,只有一个func参数,在其定义了嵌套的函数inner,inner会打印一串字符串,然后调用func,在#1得到返回值,在outer每次调用时func值可能会不一样,但不管怎用,都会调用它,最后,inner返回func()+1的值,通过调用在#2处存储decorated里的函数能够看到被打印出来的字符串以及返回值2，而不是期望中调用函数foo得到的返回值1。

可以认为变量decorated是函数foo的一个装饰版本，一个加强版本。事实上如果打算写一个有用的装饰器的话，可能会想愿意用装饰版本完全取代原先的函数foo，这样总是会得到我们的”加强版“foo。想要达到这个效果，完全不需要学习新的语法，简单地赋值给变量foo就行了：

1
foo 
= 
outer(foo)

现在，任何怎么调用都不会牵扯到原先的函数foo，都会得到新的装饰版本的foo，现在还是来写一个有用的装饰器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#coding:UTF8
 
import 
time
def 
bar():
    
time.sleep(
2
)
    
print
(
'in the bar'
)
def 
test2(func):
    
print
(func)
    
return 
func
 
# print(test2(bar))
bar
=
test2(bar)
bar()  
#run bar
 
<function bar at 
0x00000000026BCF98
>
in 
the bar

10. 使用 @ 标识符将装饰器应用到函数和利用*args and **kwargs

Python2.4支持使用标识符@将装饰器应用在函数上，只需要在函数的定义前加上@和装饰器的名称。在上一节的例子里我们是将原本的方法用装饰后的方法代替:

1
bar
=
test2(bar)

这种方式能够在任何时候对任意方法进行包装。但是如果自定义一个方法，可以使用@进行装饰：

#coding:UTF8

import time
def test2(func):
    print(func)
    return func
@test2
def bar():
    time.sleep(2)
    print('in the bar')
bar()  #run bar

_______________________________________________________________________________

#coding:UTF8

import time
def timer(func): #timer(test1)  func=test1
    def deco(*args,**kwargs):
        start_time=time.time()
        func(*args,**kwargs)   #run test1()
        stop_time = time.time()
        print("the func run time  is %s" %(stop_time-start_time))
    return deco
@timer  #test1=timer(test1)
def test1():
    time.sleep(1)
    print('in the test1')
@timer # test2 = timer(test2)  = deco  test2(name) =deco(name)
def test2(name,age):
    print("test2:",name,age)
test1()
test2("Tom",22)
in the test1
the func run time  is 1.05200004578
('test2:', 'Tom', 22)
the func run time  is 0.0

_______________________________________________________________________________

下面贡献一个高级版的装饰器：

#coding:utf8

import time
user,passwd = 'hbert','abc'
def auth(auth_type):
    print("auth func:",auth_type)
    def outer_wrapper(func):
        def wrapper(*args, **kwargs):
            #print("wrapper func args:", *args, **kwargs)
            if auth_type == "local":
                username = raw_input("Username:").strip()
                password = raw_input("Password:").strip()
                if user == username and passwd == password:
                    print("\033[32;1mUser has passed authentication\033[0m")
                    res = func(*args, **kwargs)  # from home
                    print("---after authenticaion ")
                    return res
                else:
                    exit("\033[31;1mInvalid username or password\033[0m")
            elif auth_type == "ldap":
                print("搞毛线ldap,不会。。。。")
        return wrapper
    return outer_wrapper
def index():
    print("welcome to index page")
@auth(auth_type="local") # home = wrapper()
def home():
    print("welcome to home  page")
    return "from home"
@auth(auth_type="ldap")
def bbs():
    print("welcome to bbs  page")
index()
print(home()) #wrapper()
bbs()