面向对象相关知识及常用操作

Posted 2020-08-19 Eric9

本篇将详细介绍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()

类的特殊成员在实际使用中知道即可，故不一一列举