python学习之面向对象(三)

6.8 类的结构细化

6.8.1 类的私有成员

类中的私有成员包括：私有类的属性，私有对象属性，私有类方法

私有静态属性

类的内部可以访问，类的外部不可以访问，派生类中不可以访问

class A:
    __a = 'a'
    __b = 'b'
    def func(self):
        print(self.__a)
        print(self.__b)

class B(A):
    def func(self):
        print(self.__a)
        print(self.__b)

obj = B()
print(A.__a)    #类的外部不行
print(obj.__a)  #类的外部不行
obj.func()      #派生类中不行
A.func(obj)     #类的内部可以

私有对象属性

类的内部可以访问，类的外部不可以访问，派生类中不可以访问

class A:
    a = 'aa'
    def __init__(self):
        self.__b = 'bb'
        self.__c = 'cc'
        self.bb = 'b'
        self.cc = 'c'

    def func(self):
        print(self.__b)

class B(A):

    def func(self):
        print(self.__b)
        print(self.bb)

obj = B()
print(obj.__b)   #类的外部不行
print(A.__b)     #类的外部不行
B.func(obj)      #派生类中不行
A.func(obj)      #类中可以

私有类方法

类的内部可以访问，类的外部不可以访问，派生类中不可以访问

class B:
    school_name = 'QQDX'
    def __func(self):
        print('hello')
    def fine(self):
        self.__func()
        print('hi')

class A(B):
    class_name = 'python'

    def fine(self):
        print(self.class_name)
        self.__func()

obj = A()
print(obj.class_name)
# B.__func()    #在类的外部不可以
B.fine(obj)     #在类的内部可以
A.fine(obj)

【用处】设定一些私有的或者不想让类外用，例如密码，加密方式等可以设置成私有成员

【拓展】私有成员除了在类的内部，其他方式真的访问不到吗？

python中的私有成员：就是在私有成员全面加上 _类名而已，可以根据这个方式进行调用。实际应用中，千万不要这么用！！！

class A:
    __a = 'a'
    __b = 'b'
    def func(self):
        print(self.__a)
        print(self.__b)

class B(A):
    def func(self):
        print(self.__a)
        print(self.__b)

print(A.__dict__)
print(A._A__a)
输出：
{'__module__': '__main__', '_A__a': 'a', '_A__b': 'b', 'func': <function A.func at 0x00000155D52ADC80>, '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}
a

6.8.2 类的方法

类的方法大致分为：实例方法，类方法，静态方法，双下方法

类方法classmethod

类方法，由类直接调用操作的方法，会自动将类名传给cls

class A:
    @classmethod      #类方法
    def  func(cls):
        pass

对象也可以调用这个类的函数，但是函数执行时，会自动将从属的类名传给cls，而非对象名

class LOL:
    __num = 0
    def __init__(self,name,role):
        self.name = name
        self.role = role
        LOL.__GetTeam()

    @classmethod
    def __GetTeam(cls):
        cls.__num += 1  #修改类的静态私有属性__num只能在类的额内部通过类名才能调用

    @classmethod
    def getnum(cls):
        return  cls.__num

gailun = LOL('盖伦','战士')
nvjing = LOL('女警','射手')
qinnv = LOL('萨娜','辅助')
zhaoxin = LOL('赵信','打野')
akali = LOL('阿卡丽','刺客')

print(LOL.getnum())

静态方法staticmethod

不依赖于类，也不依赖于对象，在类内部不需要穿self参数，仅仅就是一个独立的函数，只是放在类的内部而已，使代码结构更加清晰合理。使用时可以用类或者对象调用即可。

【语法】

class A:
    @staticmethod      #静态方法
    def  func():
        pass

【使用】

class LOL:
    def __init__(self,name,role):
        self.name = name
        self.role = role
        self.func()

    @staticmethod
    def func():
        print('为啥要用@staticmethod')
        print('可以把普通函数放到类的里边')

gailun = LOL('盖伦','战士')

6.8.3 类的属性伪装

property类

执行被装饰函数时，可以省去（）这一步，并返回函数的返回值

property可以单独使用，也可以与setter和deleter一起使用，但是setter和deleter使用时，必须要有property

class BMI:

    def __init__(self,hight,weight):
        self.hight = hight
        self.weight = weight

    @property  #伪装，执行这个函数时可以不用加括号;名词做了动词的事，给他加特效后，名词感觉就是名词了
    def bmi(self):
        self.bmi_num = self.hight/(self.weight**2)
        return self.bmi_num

    @bmi.setter   #伪装修改操作
    def bmi(self,argv):
        self.bmi_num_replace = argv
        print('修改的时候执行我')

    @bmi.deleter  #伪装删除操作
    def bmi(self):
        print('删除的时候执行我')

a = BMI(60,1.76)
bmi = a.bmi
del a.bmi
a.bmi = 20.5
print(a.bmi_num_replace)

设置setter和deleter时不能设置与类重名的对象属性名，且伪装函数中不能设置return

还可以表示为，跟上边是一模一样的：

class BMI:

    def __init__(self,hight,weight):
        self.hight = hight
        self.weight = weight

    def get_bmi(self):
        self.bmi_num = self.hight/(self.weight**2)
        return self.bmi_num

    def set_bmi(self,argv):
        self.bmi_num_replace = argv
        print('修改的时候执行我')

    def del_bmi(self):
        print('删除的时候执行我')

    bmi = property(get_bmi,set_bmi,del_bmi)  #内置property三个参数与get,set,delete一一对应

a = BMI(60,1.76)
print(a.bmi)
a.bmi = 20
del a.bmi
print(a.bmi_num_replace)

property类内置了查询，修改，删除函数，传参时一定要一一对应

6.8.4 isinstance和issubclass和type

isinstance

isinstance(a,b)：判断a对象是否是b类（或者b类的派生类）实例化的对象

class A:
    pass
class B(A):
    pass
class C(B):
    pass
class D(C):
    pass
obj = D()
print(isinstance(obj,C))
print(isinstance(obj,B))
print(isinstance(obj,A))

issubclass

issubclass(a,b)： 判断a类是否是b类（或者b的派生类）的派生类

class A:
    pass
class B(A):
    pass
class C(B):
    pass
class D(C):
    pass
class E(D,B):
    pass
class F:
    pass
print(issubclass(D,A))  # True
print(issubclass(E,A))  # True
print(issubclass(F,A))  # False

type

type判断的是从属于哪个类

print(type('aa'))
print(type(0))
print(type(object))
class A:
    pass
print(isinstance(object,type))
print(isinstance(A,type))

type元类是获取该对象从属于的类,而type类比较特殊，因为python原则是一切皆对象，那么就可以把类理解为'对象',而type元类又称作构建类，是python中大多数内置的类（包括object）以及自己定义的类，都是由type元类创造的。

这里只做谅解type类与object类之间的关系比较独特：object是type类的实例，而type类是object类的子类，这种关系比较神奇无法使用python的代码表述，因为定义其中一个之前另一个必须存在，所以这个只作为了解。