本篇将详细介绍Python 类的成员、成员修饰符、类的特殊成员。
类的成员分为字段、方法和属性
字段：分为普通字段和静态字段，普通字段在每个对象的内存中均保存一份，静态字段仅在类的内存中保存一份
方法：分为普通方法、类方法和静态方法，
- 普通方法：由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self；
- 类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls；
- 静态方法：由类调用；无默认参数；
字段和方法常见使用见下面例子：
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、属性的基本使用
- 定义时，在普通方法的基础上添加 @property 装饰器；
- 定义时，属性仅有一个self参数
- 调用时，无需括号
- 方法：foo_obj.func()
- 属性：foo_obj.prop
- python属性的功能：属性内部进行一系列的逻辑运算，最终将计算结果返回
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)
2、属性的两种定义方法：
1、装饰器，即在方法上使用装饰器
2、静态字段，即在类中定义值为property的字段
装饰器：经典类：如上述例子所示，定义属性的方法 @property
新式类：新式类的属性比经典类的属性丰富
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 # 删除商品原价
二、类成员的修饰符
类成员分为：公有成员：在任何地方都能方位
私有成员：只有在类的内部才能访问，私有成员命名时前两个字符是下划线 __name,特殊成员除外（__init__）
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()
类的特殊成员在实际使用中知道即可，故不一一列举
时间： 2024-11-02 23:26:48