1 #类的成员分为字段、方法和属性
 2 #字段，分为普通字段和静态字段，普通字段属于对象，静态字段属于类
 3 #方法：分为普通方法、静态方法和类方法
 4 #普通方法：由对象调用，至少有一个self参数，执行普通方法时，自动将该方法调用的对象赋值给self
 5 #类方法：由类调用，至少又一个cls参数，执行类方法时，自动将调用该方法的类复制给cls
 6 #静态方法:由类调用，无默认参数
 7 class FOO:
 8     func="我是静态字段"
 9     def __init__(self,name):
10         self.name=name   #普通字段
11 
12     def ord_fun(self):
13         print("普通方法，至少有一个self字段",self.name)
14     @classmethod
15     def class_fun(cls):
16         print("类方法，至少有一个cls参数")
17     @staticmethod
18     def static_fun():
19         print("静态方法，无参数")
20 
21     @property
22     def prop(self):
23         print("属性调用")
24 
25 #普通字段的调用：
26 f=FOO("Eric")
27 print(f.name)
28 #静态字段的调用
29 print(FOO.func)
30 
31 #普通方法的调用
32 f.ord_fun()
33 #类方法的调用
34 FOO.class_fun()
35 #静态方法的调用
36 FOO.static_fun()
37 #属性调用,与普通方法的调用一致，定义时仅有一个self参数，调用时无需括号
38 #访问属性时可以制造出和访问字段完全一致的假象
39 #属性由方法变种而来，若没有属性，方法完全可以替代
40 f.prop

 1 class Pager(object):
 2     def __init__(self,current_page):
 3         #用户当前请求的页码
 4         self.current_page=current_page
 5         #每页默认显示的条数
 6         self.per_items=10
 7 
 8     @property
 9     def start(self):
10         val=(self.current_page-1)*self.per_items+1
11         return val
12     @property
13     def end(self):
14         val=self.current_page*self.per_items
15         return val
16 #
17 p=Pager(2)
18 print("第二页开始：",p.start)
19 print("第二页结束：",p.end)

 1 #新式类，具有三种@property装饰器
 2 class Goods(object):
 3     def __init__(self,name):
 4         self.name=name
 5         #原价
 6         self.original_price=100
 7         #折扣价
 8         self.discount=0.8
 9 
10     @property
11     def price(self):
12         #实际价格
13         new_price=self.original_price*self.discount
14         return new_price
15 
16     @price.setter
17     def price(self,value):
18         #修改商品原价
19         self.original_price=value
20 
21     @price.deleter
22     def price(self):
23         #删除商品原价
24         del self.original_price
25 
26 obj=Goods("apple")
27 print(obj.price)
28 obj.price=200
29 print(obj.price)
30 del obj.price

 1 class Goods(object):
 2 
 3     def __init__(self):
 4         # 原价
 5         self.original_price = 100
 6         # 折扣
 7         self.discount = 0.8
 8 
 9     def get_price(self):
10         # 实际价格 = 原价 * 折扣
11         new_price = self.original_price * self.discount
12         return new_price
13 
14     def set_price(self, value):
15         self.original_price = value
16 
17     def del_price(self, value):
18         del self.original_price
19 
20     PRICE = property(get_price, set_price, del_price, ‘价格属性描述...‘)
21 
22 obj = Goods()
23 obj.PRICE         # 获取商品价格
24 obj.PRICE = 200   # 修改商品原价
25 del obj.PRICE     # 删除商品原价

 1 #公有成员：在任何地方都能访问。静态：类的对象可以访问，类内部可以访问，派生类可以访问
 2 #私有成员：只有在类的内部才能访问，仅在类内部可以访问
 3 class C(object):
 4     name="公有静态字段"
 5     __na="私有静态字段"
 6     def __init__(self):
 7         self.foo="公有普通字段"
 8         self.__fox="私有普通字段"
 9 
10     def func(self):     #类内部访问
11         print(self.foo)
12         print(self.__fox)
13         print(C.name)
14         print(C.__na)
15 class D(C):     #只能访问公有静态字段和公有普通字段
16     def show(self):
17         print(C.name)
18         # print(C.__na)   无法正常访问
19         print(self.foo)
20         # print(self.__fox)    无法正常访问私有字段
21 print("类访问：",C.name)    #类访问
22 # print("类访问私有字段：",C.__na)   #报错，无法访问
23 obj2=C()
24 obj2.func()   #全部可以正常访问，打印四个
25 
26 
27 obj_d=D()
28 obj_d.show()