装饰器

 1 ##########################################装饰器
 2 #!/usr/bin/env python
 3 #coding:utf-8
 4 
 5 def outer(fun):#装饰器函数，其中的fun就是调用的建立关系处的函数fun1,fun2,fun3，然后在wrapper（）处执行该函数，并加上自己新增 的功能，返回值是返回的整个函数
 6     def wrapper():
 7         fun()#将其放入内存
 8         print ‘fuck‘#将其放入内存
 9     return wrapper#将wrapper返回，并给出一个地址，最后fun1=wrapper
10 
11 @outer#建立关系，@outer=outer(fun1),执行到此，就是将这个传到outer中
12 def fun1():
13     print ‘func1‘
14 @outer#建立关系
15 def fun2():
16     print ‘func2‘
17 @outer#建立关系
18 def fun3():
19     print ‘func3‘
20 
21 #最后的输出还是在这里执行的,最后fun1=wrapper
22 fun1()
23 fun2()
24 fun3()
25 
26 --------------------------------------------------加参数版
27 #!/usr/bin/env python
28 #coding:utf-8
29 
30 def outer(fun):
31     def wrapper(arg):#参数
32         fun(arg)#参数
33         print ‘fuck‘
34     return wrapper
35 
36 @outer
37 def fun1(arg):#参数
38     print ‘func1‘,arg
39 @outer
40 def fun2(arg):
41     print ‘func2‘,arg
42 @outer
43 def fun3(arg):
44     print ‘func3‘,arg
45 
46 
47 fun1(‘bill‘)#参数
48 fun2(‘bill‘)
49 fun3(‘bill‘)
50 
51 ----------------------------------------------------加返回值版
52 #!/usr/bin/env python
53 #coding:utf-8
54 
55 def outer(fun):
56     def wrapper(arg):
57         result=fun(arg)#修改处
58         print ‘fuck‘
59         return result#修改处
60     return wrapper
61 
62 @outer
63 def fun1(arg):
64     print ‘func1‘,arg
65     return ‘return‘#修改处
66 @outer
67 def fun2(arg):
68     print ‘func2‘,arg
69 @outer
70 def fun3(arg):
71     print ‘func3‘,arg
72 
73 
74 result=fun1(‘bill‘)#修改处
75 print result#修改处
76 fun2(‘bill‘)
77 fun3(‘bill‘)

 1 class person:
 2     def __init__(self,name):#此处的self是传过来的b
 3         self.name=name
 4 
 5 b=person(‘hh‘)
 6 print b.name
 7 ---------------------------------------------------------
 8 #!/usr/bin/env python
 9 #coding:utf-8
10 
11 class person:
12     momo=‘中国的23个生‘#这个是属于类的，静态字段
13     def __init__(self,name):#属于对象的，动态字段
14         self.name=name
15 
16 b=person(‘hh‘)
17 print b.name,b.momo,person.momo#对象可以访问静态字段
18 
19 ------------------------------------------------------------
20 #!/usr/bin/env python
21 #coding:utf-8
22 
23 class person:
24     momo=‘中国的23个生‘#这个是属于类的，静态字段
25     def __init__(self,name):#属于对象的，动态字段
26         self.name=name
27     def sport(self):#动态方法
28         print self.name+‘ is sporting‘
29 
30     @staticmethod#带此装饰器，就是开启静态方法的第一步，例如在数据库操作时就可以使用静态方法，然后去掉self,别的参数可以留下
31     def foo():#去除self就是第二步
32         print ‘带头反腐‘
33 b=person(‘hh‘)
34 b.sport()
35 person.foo()
36 、
37 
38 ------------------------------------------------------------静态方法的使用环境，此时就不需要创建一个个对象，直接调用类，节约内存空间，节约代码量
39 #!/usr/bin/env python
40 #coding:utf-8
41 
42 class mysql:
43     @staticmethod
44     def add(sql):
45         pass
46     @staticmethod
47     def dele(sql):
48         pass
49     @staticmethod
50     def search(sql):
51         pass
52     
53     @staticmethod
54     def select(sql):
55         pass
56     
57 mysql.search(‘‘)
58 mysql.add(‘‘)
59 mysql.dele(‘‘)
60 mysql.select(‘‘)
61 
62 -----------------------------------------------------------私有字段
63 self.__thailand=flag###__加双下划线，类的内部可以访问，外部不可以访问，除非间接调用
64 -----------------------------------------------------------私有方法，也只有类的内部可以访问
65     def __sha(self):
66         pass
67         

 1 ---------------------------------------------------------------
 2 #!/usr/bin/env python
 3 #coding:utf-8
 4 
 5 
 6 class student:
 7     def __init__(self,name,age,high):
 8         self.name=name
 9         self.age=age
10         self.high=high
11 
12     def __siyou(self):#该方法是私有方法，外部不能调用
13         print ‘nima‘
14 
15     def show(self):#内部可以通过调用内部私有方法，从而外部可以调用本方法
16         self.__siyou()
17 liyang=student(‘liyang‘,‘19‘,‘170‘)
18 
19 print liyang.name
20 liyang.show()#虽然我不可以直接调用内部方法，但是我可以通过间接的方式调用私有方法
21 
22 
23 liyang._student__siyou()#这也是一种访问私有方法的方式
24 
25 
26 ----------------------------------------------------------------------
27 #!/usr/bin/env python
28 #coding:utf-8
29 
30 
31 class student:
32     def __init__(self,name,age,high):
33         self.name=name
34         self.age=age
35         self.high=high
36 
37     def __siyou(self):#该方法是私有方法，外部不能调用
38         print ‘nima‘
39 
40     @property#使用特性调用
41     def show(self):#内部可以通过调用内部私有方法，从而外部可以调用本方法
42         self.__siyou()
43 liyang=student(‘liyang‘,‘19‘,‘170‘)
44 
45 print liyang.name
46 #liyang.show()#虽然我不可以直接调用内部方法，但是我可以通过间接的方式调用私有方法
47 liyang.show使用特性的手法访问
48 #liyang._student__siyou()#这也是一种访问私有方法的方式
49 
50 -------------------------------------------------------------------修改私有字段的值
51 #!/usr/bin/env python
52 #coding:utf-8
53 
54 class student(object):#加上object来修改私有值
55     def __init__(self,name,age,height,flag):
56         self.name=name
57         self.age=age
58         self.height=height
59         self.__thailand=flag#私有字段
60 
61     def show(self):#私有字段的访问
62         print self.__thailand
63 
64     def __nima(self):#私有方法
65         print ‘我是bill‘
66     def call(self):#私有方法的访问
67         self.__nima()
68 
69     @property#通过特性来访问私有字段
70     def thailand(self):
71          return self.__thailand
72 
73     @thailand.setter#修改私有字段的值
74     def thailandd(self,value):#加上传参数的值
75         self.__thailandd=value
76 li=student(‘li‘,‘19‘,‘170‘,True)
77 
78 li.call()
79 #print li.__thailand
80 li.show()
81 print li.thailand
82 
83 li.thailand=False
84 print li.thailand

 1 --------------------------------------------特性方法
 2 #!/usr/bin/env python
 3 #coding:utf-8
 4 
 5 class person:
 6     momo=‘中国的23个生‘#这个是属于类的，静态字段
 7     def __init__(self,name,flag):#属于对象的，动态字段
 8         self.name=name
 9         self.__thailand=flag
10     def sport(self):#动态方法
11         print self.name+‘ is sporting‘
12 
13     def __sha(self):
14         pass
15     @staticmethod#带此装饰器，就是开启静态方法的第一步
16     def foo():#去除self就是第二步
17         print ‘带头反腐‘
18     @property#将方法变成一个特性
19     def bar(self):
20          print self.name
21          return ‘something‘
22 b=person(‘hh‘,‘taiguo‘)
23 print b.name#字段的访问
24 b.sport()#访问方法
25 person.foo()
26 b.bar#特性访问
27 print b.bar
28 
29 
30 ##################################################################经典类中特性全部都是可读可写（没有只读的功能）
31 class person:
32     def __init__(self):
33         self.__name=‘bill‘
34     @property
35     def Name(self):
36         return self.__name
37 
38 p1=person()
39 print p1.Name#通过特性Name.读取self.__name的值
40 p1.Name=‘xx‘#通过特性Name,设置self.__name的值
41 
42 ###################################################################新式类中的特性默认都是只读，如果想要设置，那么久需要创建一个被装饰的@xxx.setter修饰的特性
43 在装饰器杂项里面有