面向对象:类的成员

类的组成成员:
class A:

    company_name = '教育'  # 静态变量(静态字段)
    __iphone = '1353333xxxx'  # 私有静态变量(私有静态字段)


    def __init__(self,name,age): #特殊方法

        self.name = name  #对象属性(普通字段)
        self.__age = age  # 私有对象属性(私有普通字段)

    def func1(self):  # 普通方法
        pass

    def __func(self): #私有方法
        print(666)


    @classmethod  # 类方法
    def class_func(cls):
        """ 定义类方法，至少有一个cls参数 """
        print('类方法')

    @staticmethod  #静态方法
    def static_func():
        """ 定义静态方法 ，无默认参数"""
        print('静态方法')

    @property  # 属性
    def prop(self):
        pass
对于每一个类的成员而言都有两种形式:
    公有成员:在任何地方都可以访问
    私有成员:只有在类的内部才能访问

1.私有成员

私有成员:重要的数据,功能(只允许本类使用的属性,方法)设置成私有成员
python中所有的私有成员都形同虚设,__dict__就可以查看到
类从加载时,只要遇到类中的私有成员,都会在私有成员前面加上_类名.

1.类的私有属性
class A:
    name = '奇奇'
    __name  = '七七'   #类的私有属性
    def func(self):
        print(self.name)
        print(self.__name)
obj = A()
obj.func()
#只能在类的内部访问,不能在类的外部以及派生类访问

2.对象的私有属性
class A:
    def __init__(self,name,pwd):
        self.name = name
        self.__pwd = pwd
    def md5(self):
        self.__pwd = self.__pwd + '123'
obj = A("奇奇","qiqi")
#只能在类的内部使用,不能在类的外部以及派生类使用

3.类的私有方法
class A:
    def func(self):
        self.__func()
        print('is A func')
    def __func(self):
        print('is A __func')
obj = A()
obj.func()
#只能在类的内部使用,不能在类的外部以及派生类使用


class A:
    name = '奇奇'
    __name = '七七'  # 私有类的属性
    def __func(self):
        print('in __func')

print(A.__dict__)
print(A._A__name)   #在私有成员前面加上_类名就可以访问

2.类的其他方法

1.类方法:
class A:
    def func(self):
        print("实例方法")
    @classmethod
    def cls_mothod(cls):
       #obj = cls()   实例化一个对象
        print("类方法")
A.cls_func()
obj = A()
obj.cls_func()

类方法:一般就是通过类名去调用的方法,并且自动将类名地址传给cls
      但是通过对象调用也可以,但是传的地址还是类名地址
        
类方法的用处:1.得到类名可以实例化对象
           2.可以操作类的属性
        
例:创建学生类,只要实例化一个对象,写一个类方法,统计实例化学生的数量
class Student:
    count = 0
    def __init__(self,name,id):
        self.name = name
        self.id = id
        Student.addnum()
    @classmethod
    def addnum(cls):
        cls.count += 1
    @classmrthod
    def getnum(cls)
        return cls.count
obj1 = Student("qiqi",152345)
obj2 = Student("wuwu",153354)
print(Student.getnum())


2.静态方法
class A:
    def func(self):
        print("实例方法")
    @classmethod
    def cls_func(cls)
        pass
    @staticmethod
    def static_func():
        print("静态方法")

静态方法是不依赖于类和对象的,静态方法就是函数
作用:保证代码的规范性,合理的划分,后续可维护性高
    

3.属性

property是一种特殊的属性,访问它时会执行一段功能(函数),然后返回值

例:
BMI指数（bmi是计算而来的，但很明显它听起来像是一个属性而非方法，如果我们将其做成一个属性，更便于理解）

成人的BMI数值：
过轻：低于18.5
正常：18.5-23.9
过重：24-27
肥胖：28-32
非常肥胖, 高于32
　　体质指数（BMI）=体重（kg）÷身高^2（m）
　　EX：70kg÷（1.75×1.75）=22.86

class Bmi:
    def __init__(self,name,height,weight):
        self.name = name
        self.height = height
        self.weight = weight
    def bmi(self):
        return self.weight/self.height**2
obj = Bmi("奇奇",1.80,60)
print(obj.bmi())
#结果虽然实现了,但是逻辑上不合理,bmi应该是名词,却被当成方法使用了

class Bmi:
    def  __init__(self,name,height,weight):
        self.name = name
        self.height = height
        self.weight = weight
    @property
    def bmi(self):
        return self.weight/self.height**2
obj = Bmi("奇奇",1.80,60)
print(obj.bmi)
#property将执行一个函数需要函数名()变换成直接函数名
#将动态方法伪装成了一个属性,虽然在代码级别上没有什么提升,但是看起来更合理

property组合:
class Foo:
    @property
    def bmi(self):
       print("get的时候运行我")
    @bmi.setter
    def bmi(self,value):
        print(value)
        print("set的时候运行我")
       #return 111  --无法获得返回值
    @bmi.deleter
    def bmi(self):
        print("delete的时候运行我")
obj = Foo()
obj.bmi
obj.bmi = 666 #操作命令,这个命令是执行被bmi.setter装饰器装饰的函数
del obj.bmi

应用场景:
    1.面试会考一些基本的调用,流程
    2.工作室如果遇到了一些类似于属性的方法名,可以让其伪装成属性
    
设置属性的两种方式:
    1.利用装饰器设置属性
class Foo:
    @property
    def bmi(self):
        print("get的时候运行我")
    @bmi.setter
    def bmi(self,value):
        print(value)
        print("set的时候运行我")
    @bmi.deleter
    def bmi(self):
        print("delete的时候运行我")
obj = Foo()
obj.bmi
obj.bmi = 666
def obj.bmi
    2.利用实例化对象的方式设置属性
class Foo:
    def get_bmi(self):
        print("get的时候运行我")
    def set_bmi(self,value):
        print("set的时候运行我")
    def delete_bmi(self):
        print("delete的时候运行我")
    bmi = property(get_bmi,set_bmi,delete_bmi)
           #内置property三个参数与get,set,delete一一对应
obj = Foo()
obj.bmi
obj.bmi = 666
def obj.bmi
    

4. isinstance和issubclass

1.isinstance 判断对象与类之间的关系
class A:
    pass
class B(A):
    pass
obj = B()
print(isinstance(obj,B))   #True
print(isinstance(obj,A))   #True

isinstacne(a,b) 判断的是a是否为b类或者b类的派生类的实例化对象

2.issubclass 判断的是类与类之间的关系
clas A:
    pass
class B(A):
    pass
class C(B):
    pass
print(issubclass(B,A))    #True
print(issubclass(C,A))    #True

issubclass(a,b) 判断的是a类是否为b类的子孙类