python面向对象-2深入类的属性

 1 >>> class A:
 2     a=0
 3     def __init__(self):
 4         self.a=10
 5         self.b=100
 6 
 7         
 8 >>> a=A()
 9 >>> a.a
10 10
11 >>> a.b
12 100
13 >>> A.a
14 0
15 >>> A.b
16 Traceback (most recent call last):
17   File "<pyshell#10>", line 1, in <module>
18     A.b
19 AttributeError: type object ‘A‘ has no attribute ‘b‘
20 >>> 

 1 >>> class A:
 2     a=0
 3     def __init__(self):
 4         self.a=10
 5         self.b=100
 6 
 7         
 8 >>> a=A()
 9 >>> getattr(a,‘a‘)#用getattr()函数获取实例a中a属性的值
10 10
11 >>> setattr(a,‘a‘,20)#设置实例a中a属性的值为20
12 >>> getattr(a,‘a‘)#用getattr()函数获取实例a中a属性的值
13 20
14 >>> hasattr(a,‘b‘)#测试实例a中是否包含属性b
15 True

 1 class Washer:
 2 
 3     def __init__(self,water=10,scour=2):
 4         self._water=water #不想让用户直接访问实例变量，可以标志成私有
 5         self.scour=scour
 6         #属性包装，将water属性包装成方法，用户使用water时实际是访问的方法
 7     @property
 8     def water(self):#如果用户使用 实例.water相当于访问这个方法，而不是真的访问属性
 9         return self._water
10 
11     def set_water(self,water):
12         self.water=water        
13 
14     def set_scour(self,scour):
15         self.scour=scour        
16 
17     def add_water(self):
18         print(‘Add water:‘,self.water)
19 
20     def add_scour(self):
21         print(‘Add scour:‘,self.scour)
22 
23     def start_wash(self):
24         self.add_water()
25         self.add_scour()
26         print(‘Start wash...‘)
27         
28 if __name__==‘__main__‘:
29     w=Washer()
30     #w.start_wash()
31     print(w.water)# 可以像访问属性一样访问方法

 1 class Washer:
 2 
 3     def __init__(self,water=10,scour=2):
 4         self._water=water #不想让用户直接访问实例变量，可以标志成私有
 5         self.scour=scour
 6         #属性包装，将water属性包装成方法，用户使用water时实际是访问的方法
 7     @property
 8     def water(self):#如果用户使用 实例.water相当于访问这个方法，而不是真的访问属性
 9         return self._water
10     
11     @water.setter   #新添加代码
12     def water(self,water):
13         if 0<water<=500:
14             self._water=water
15         else:
16             print(‘set Failure！‘)
17     
18     def set_water(self,water):
19         self.water=water        
20 
21     def set_scour(self,scour):
22         self.scour=scour        
23 
24     def add_water(self):
25         print(‘Add water:‘,self.water)
26 
27     def add_scour(self):
28         print(‘Add scour:‘,self.scour)
29 
30     def start_wash(self):
31         self.add_water()
32         self.add_scour()
33         print(‘Start wash...‘)
34         
35 if __name__==‘__main__‘:
36     w=Washer()
37     print(w.water)# 可以像访问属性一样访问方法
38     #w._water=20 #为了不让用户这样直接给实例属性赋值，用下面的语句
39     w.water=123 #可以像给属性赋值一样给方法赋值，并检测范围
40     print(w.water)# 可以像访问属性一样访问方法

 1 class Washer:
 2 
 3     def __init__(self,water=10,scour=2):
 4         self._water=water #不想让用户直接访问实例变量，可以标志成私有
 5         self.scour=scour
 6         self.year=2000#这是生产日期
 7         #属性包装，将water属性包装成方法，用户使用water时实际是访问的方法
 8     @property
 9     def water1(self):#如果用户使用 实例.water相当于访问这个方法，而不是真的访问属性
10         return self._water
11     
12     @water1.setter
13     def water1(self,water):
14         if 0<water<=500:
15             self._water=water
16         else:
17             print(‘set Failure！‘)
18     @property
19     def total_year(self): #定义一个虚拟实例属性，这个属性其实是一个方法，但是可以按照属性来用
20         return 2017-self.year
21     
22     def set_water(self,water):
23         self.water=water        
24 
25     def set_scour(self,scour):
26         self.scour=scour        
27 
28     def add_water(self):
29         print(‘Add water:‘,self.water)
30 
31     def add_scour(self):
32         print(‘Add scour:‘,self.scour)
33 
34     def start_wash(self):
35         self.add_water()
36         self.add_scour()
37         print(‘Start wash...‘)
38         
39 if __name__==‘__main__‘:
40     w=Washer()
41     print(w.water1)# 可以像访问属性一样访问方法
42     #w._water=20 #为了不让用户这样直接给实例属性赋值，用下面的语句
43     w.water1=123
44     print(w.water1)# 可以像访问属性一样访问方法
45     print(w.total_year)
46   
47     

 1 class NonNeg:#数据描述符
 2     def __init__(self,default=0):#构造方法
 3         self.default=default#一个实例属性
 4     def __get__(self,instance,owner):#协议方法
 5         return self.default
 6     def __set__(self,instance,val):#协议方法
 7         if val>0:
 8             self.default=val
 9         else:
10             print(‘The value must be NonNegative！‘)
11     def __delete__(self,instance):#协议方法
12         pass
13 class Movie:
14     rating=NonNeg()#描述符类NonNeg作另一个类Movie的属性，rating是Movie的类属性。
15     score=NonNeg()
16     
17 if __name__==‘__main__‘:
18     m=Movie()
19     print(‘rating:‘,m.rating)
20     print(‘score:‘,m.score)#输出默认值default
21     m.rating=80#使用__set__协议方法
22     print(‘rating:‘,m.rating)#使用到 __get__协议方法
23     m.score=-3
24     print(‘score:‘,m.score)

 1 class Tst:
 2     def pr(self):
 3         self.pr=10
 4         print(‘Tst‘)
 5 t1=Tst()
 6 t1.pr()#输出Tst
 7 t1.pr#啥都没有输出
 8 print(t1.pr)#输出10
 9 print(‘下面实例化后不访问t.pr()直接访问t.pr：‘)
10 t2=Tst()
11 t2.pr#啥都没输出
12 print(t2.pr)#输出了bound method Tst.pr of <__main__.Tst object

 1 class Tst:
 2     def __init__(self,default=1):
 3         self.water=default
 4     def __call__(self):
 5         print(‘包含call函数的类，他的实例可以直接当做函数使用。‘)
 6     def info(self):
 7         print("pass")
 8 
 9 t=Tst()
10 t()