python之路——面向对象（进阶篇）

面向对象进阶：类成员、类成员的修饰符、类的特殊成员

类成员

类成员分为三大类：字段、方法、属性

一、字段

• 静态字段 （属于类）
• 普通字段（属于对象）

 

class City:
    # 静态字段
    country = "中国"

    def  __init__(self,city_name):
        # 普通字段
        self.city_name = city_name

    def show(self):
        print(self.city_name)


obj1 = City("Harbin")
obj2 = City("Shanghai")
# 普通字段对象来访问
print(obj1.city_name,obj2.city_name)
# 静态字段通过类名访问
print(City.country)  

内存中分布：

1. 静态字段在内存中只保存一份
2. 普通字段在每个对象中都要保存一份

静态字段定义及应用：随着这个程序的执行产生，随着程序的结束而消失，这样和程序‘共存亡’的字段，我们就叫它静态字段。它就像是一个全局变量，不属于任何一个对象，我们可以直接使用类来调用，也可以在对象使用方法的时候使用它。它是对象共享的变量，存在类的内存里。

特殊：对象也可以访问静态字段。静态字段在代码加载时已经创建。

遵循规则：普通字段只能对象访问；静态字段用类访问。（万不得已用对象访问）

二、方法

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

 

class Province:

    country = "China"
    def __init__(self,name):
        self.name =  name

    # 普通方法 由对象调用。
    def show(self):
        print(self.name)

    # 静态方法 ，无self参数；方法前边加上关键字@staticmethod 由类调用
    @staticmethod
    def display(a,b,c):
        print(a,b,c)

    # 类方法（相当于静态方法特殊形式），至少要有一个cls参数。由类调用
    @classmethod
    def listen(cls,b):
        '''
        cls:类名
        '''
        print(cls.country,b)

obj = Province("黑龙江")
obj.show() # 普通方法由对象调用
Province.display(1,2,3) # 静态方法由类调用执行
Province.listen(2) # cls是python自动传递

 

三、属性

• 属性的基本使用

class Page:

    def __init__(self,all_counts):
        self.all_counts = all_counts

    # 属性： 分页
    @property
    def divpages(self):
        a,b = divmod(self.all_counts,10)
        if b == 0:
            return a
        else:
            return a+1


p = Page(101)
ret = p.divpages# 调用属性 直接返回
print(ret)

属性的定义和调用：

• 定义时，在普通方法的基础上添加 @property 装饰器；
• 定义时，属性仅有一个self参数
• 调用时，无需括号
             属性：p.divpages

Python的属性的功能是：属性内部进行一系列的逻辑计算，最终将计算结果返回

注意：属性存在意义是：访问属性时可以制造出和访问字段完全相同的假象

        属性由方法变种而来，如果Python中没有属性，方法完全可以代替其功能。

class Page:

    def __init__(self,all_counts):
        self.all_counts = all_counts

    # 属性： 分页
    @property
    def divpages(self):
        a,b = divmod(self.all_counts,10)
        if b == 0:
            return a
        else:
            return a+1
    # 设置属性：支持赋值操作
    @divpages.setter
    def divpages(self,value):
        self.all_counts = value
    # 删除
    @divpages.deleter
    def divpages(self):
        print("del property")
p = Page(101)
p.divpages = 111 #自动执行 @divpages .setter 修饰的 divpages 方法，并将  123 赋值给方法的参数
ret = p.divpages # 自动执行 @property 修饰的 divpages方法，并获取方法的返回值
del p.divpages  # 自动执行 @divpages.deleter 修饰的 divpages方法
print(ret)

 

属性操作：不同属性调用形式，触发不同装饰器的方法，见下图。

 

 

• 属性另一种表达方式 

class Page:

    def __init__(self,count):
        self.count = count

     
    def f1(self):
        return 123
    
    def f2(self):
        print("fset:赋值")

    def f3(self):
        print("fdel:删除")

    foo = property(fget=f1,fset=f2,fdel=f3)

p = Page(100)
ret = p.foo # 自动回找到fool，会找到fget对应函数f1并执行，并将返回值
p.foo =113 #会找到fset对应函数f2并执行
del p.foo # 会找到fdel并执行f3

 

类成员修饰符

• 公有：在类内和类外均可以访问
• 私有：仅在类的内部可以访问；私有成员命名时，前两个字符是下划线

1. 公有字段和私有字段

class Person:
    # 私有 静态字段
    __school = "北大"
    def __init__(self,name,sex):
        # 普通字段，公有，name ；私有 sex 
        self.name = name
        self.__sex = sex
    
    # 均可在类内调用
    def f1(self):
        print(self.name)    
        print(self__sex)

    def f2(self):
        print(Person.__school)

class ChianPerson(Person):
    def f2(self):
        print(self.__sex)
    
obj = Person("lcy","man")
print(obj.name) # 类外访问公有普通字段
# print(obj.__sex) # 无法访问 报错 no attribute 
#print(Person.__school) # 无法访问
obj.f3() # 打印 "北大"
# ----- 继承,派生类不能访问基类私有的普通字段-------
obj2 = ChinaPerson("alex","female")
#obj2.f2() # 执行 失败，只有Person类内方法可以访问
obj2.f1() # 可以执行f1是Person类中的方法

　　2. 公有方法和私有方法

（略）

这里公有方法和私有方法与上边字段访问限制是一样的。私有方法命名同私有字段命名相同。只要在函数名前加两个下划线，就表示私有方法。

 类的特殊成员

• __init__:构造方法
• __del__:析构方法
• __doc__:注释类
• __module__:对象所在模块
• __class__:对象类名
• __call__: obj() 或类名()触发执行
• __str__:print(obj)自动调用
• 其他：__add__

class Person:
    '''
    这是一个人类
    '''
    def __init__(self,name):
        self.name = name

    def __del__(self):
        print("这是析构函数一般不自定义，python有自己的回收机制")

    def __call__(self, *args, **kwargs):
        print("call")

    def __str__(self):
        return  ("__str__:%s"%self.name)

    def __add__(self, other):
        print(self.name,other.name)
        


# 创建对象，自动调用__init__
obj_p1 = Person("lcy")#
obj_p2 = Person("alex")
print(obj_p1.__doc__)
print(obj_p1.__module__)
print(obj_p1.__class__)
# 自动调用 __call__
obj_p1()
#Person("lcy")() 同 obj_p1()
# 触发__str__方法
print(obj_p1)
res = str(obj_p1)
print(res)
# 会触发 __add__ /同理会有其他的方法，加减乘除。。。
obj_p1+obj_p2
# 程序会自动调用__del__析构函数，对象在回收机制之前，这里会调用两次，因为创建了两次

• __dict__:重点 （默认已经存在类或者对象中）

获取类成员：静态字段，方法。

class Game:

    Game_name = "SIM3"

    def  __init__(self):
        pass

    def show(self):
        pass

print(Game.__dict__)
'''
{'__init__': <function Game.__init__ at 0x00503E88>, 
'show': <function Game.show at 0x00503DF8>, 
'__weakref__': <attribute '__weakref__' of 'Game' objects>,
'__module__': '__main__', '__dict__': <attribute '__dict__' of 'Game' objects>,
'Game_name': 'SIM3', '__doc__': None}
'''

对象：获取对象的字段

class Game:

    Game_name = "SIM3"

    def  __init__(self,level,money):
        self.level = level
        self.money = money

    def show(self):
        pass
obj = Game(12,199)
print(obj.__dict__)
'''
{'money': 199, 'level': 12}
'''

• __getitem__、__setitem__、__delitem__

对象用于索引，如字典相关操作。获取、设置以及删除操作

class Foo:

    def __getitem__(self, item):
        print(item)

    def  __setitem__(self, key, value):
        print(key,value)

    def __delitem__(self, key):
        print(key)

obj = Foo()
obj["k1"] # 触发 __getitem__
obj[3]   #触发 __getitem__
obj[2] = 234 # 触发__setitme
del obj[3] # 触发__delitem

支持对象切片操作。（python3 用触发上边的方法来实现）

class Foo:

    def __getitem__(self, item):
        print(type(item))
        print(item.start)
        print(item.stop)
        print(item.step)

    def  __setitem__(self, key, value):
        print(type(key))
        print(key.start,key.stop,key.step,value)

    def __delitem__(self, key):
        print(type(key))
        print(key.start,key.stop,key.step)

obj = Foo()
obj[1:3:2] # 触发 __getitem__
obj[1:3:2] = [11,22,44]   #触发 __setitem__
del obj[1:3:2] # 触发__delitem__
输出：

<class 'slice'>
1
3
2
<class 'slice'>
1 3 2 [11, 22, 44]
<class 'slice'>
1 3 2

（待续，天冷，打字都动手啊）