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

本篇将详细介绍Python 类的成员、成员修饰符、类的特殊成员。

类的成员分为字段、方法和属性

字段：分为普通字段和静态字段，普通字段在每个对象的内存中均保存一份，静态字段仅在类的内存中保存一份

方法：分为普通方法、类方法和静态方法，

• 普通方法：由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self；
• 类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls；
• 静态方法：由类调用；无默认参数；

字段和方法常见使用见下面例子：

#类的成员分为字段、方法和属性
#字段，分为普通字段和静态字段，普通字段属于对象，静态字段属于类
#方法：分为普通方法、静态方法和类方法
#普通方法：由对象调用，至少有一个self参数，执行普通方法时，自动将该方法调用的对象赋值给self
#类方法：由类调用，至少又一个cls参数，执行类方法时，自动将调用该方法的类复制给cls
#静态方法:由类调用，无默认参数
class FOO:
    func="我是静态字段"
    def __init__(self,name):
        self.name=name   #普通字段

    def ord_fun(self):
        print("普通方法，至少有一个self字段",self.name)
    @classmethod
    def class_fun(cls):
        print("类方法，至少有一个cls参数")
    @staticmethod
    def static_fun():
        print("静态方法，无参数")

    @property
    def prop(self):
        print("属性调用")

#普通字段的调用：
f=FOO("Eric")
print(f.name)
#静态字段的调用
print(FOO.func)

#普通方法的调用
f.ord_fun()
#类方法的调用
FOO.class_fun()
#静态方法的调用
FOO.static_fun()
#属性调用,与普通方法的调用一致，定义时仅有一个self参数，调用时无需括号
#访问属性时可以制造出和访问字段完全一致的假象
#属性由方法变种而来，若没有属性，方法完全可以替代
f.prop

属性

1、属性的基本使用

• 定义时，在普通方法的基础上添加 @property 装饰器；
• 定义时，属性仅有一个self参数
• 调用时，无需括号
•            方法：foo_obj.func()
•            属性：foo_obj.prop
• python属性的功能：属性内部进行一系列的逻辑运算，最终将计算结果返回

class Pager(object):
    def __init__(self,current_page):
        #用户当前请求的页码
        self.current_page=current_page
        #每页默认显示的条数
        self.per_items=10

    @property
    def start(self):
        val=(self.current_page-1)*self.per_items+1
        return val
    @property
    def end(self):
        val=self.current_page*self.per_items
        return val
#
p=Pager(2)
print("第二页开始：",p.start)
print("第二页结束：",p.end)

2、属性的两种定义方法：

　　1、装饰器，即在方法上使用装饰器

　　2、静态字段，即在类中定义值为property的字段

装饰器：经典类：如上述例子所示，定义属性的方法  @property

　　　　新式类：新式类的属性比经典类的属性丰富

#新式类，具有三种@property装饰器
class Goods(object):
    def __init__(self,name):
        self.name=name
        #原价
        self.original_price=100
        #折扣价
        self.discount=0.8

    @property
    def price(self):
        #实际价格
        new_price=self.original_price*self.discount
        return new_price

    @price.setter
    def price(self,value):
        #修改商品原价
        self.original_price=value

    @price.deleter
    def price(self):
        #删除商品原价
        del self.original_price

obj=Goods("apple")
print(obj.price)
obj.price=200
print(obj.price)
del obj.price

静态字段方式：使用静态字段创建属性时，经典类和新式类无区别

静态字段方式创建属性具有三种访问方式，我们可以根据他们几个属性的访问特点，分别将三个方法定义为对同一个属性：获取、修改、删除

class Goods(object):

    def __init__(self):
        # 原价
        self.original_price = 100
        # 折扣
        self.discount = 0.8

    def get_price(self):
        # 实际价格 = 原价 * 折扣
        new_price = self.original_price * self.discount
        return new_price

    def set_price(self, value):
        self.original_price = value

    def del_price(self, value):
        del self.original_price

    PRICE = property(get_price, set_price, del_price, '价格属性描述...')

obj = Goods()
obj.PRICE         # 获取商品价格
obj.PRICE = 200   # 修改商品原价
del obj.PRICE     # 删除商品原价

二、类成员的修饰符

类成员分为：公有成员：在任何地方都能方位

私有成员：只有在类的内部才能访问，私有成员命名时前两个字符是下划线 __name,特殊成员除外（__init__）

#公有成员：在任何地方都能访问。静态：类的对象可以访问，类内部可以访问，派生类可以访问
#私有成员：只有在类的内部才能访问，仅在类内部可以访问
class C(object):
    name="公有静态字段"
    __na="私有静态字段"
    def __init__(self):
        self.foo="公有普通字段"
        self.__fox="私有普通字段"

    def func(self):     #类内部访问
        print(self.foo)
        print(self.__fox)
        print(C.name)
        print(C.__na)
class D(C):     #只能访问公有静态字段和公有普通字段
    def show(self):
        print(C.name)
        # print(C.__na)   无法正常访问
        print(self.foo)
        # print(self.__fox)    无法正常访问私有字段
print("类访问：",C.name)    #类访问
# print("类访问私有字段：",C.__na)   #报错，无法访问
obj2=C()
obj2.func()   #全部可以正常访问，打印四个


obj_d=D()
obj_d.show()

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