python12类

self 表示类里面的对象的引用

python一般不需要去解决内存管理，解释器会进行自动给回收

#类鱼类之间空格两行，前面的函数里面也是两行，类里面的方法个一行
class Cat(object):
    """
    猫科动物
    """
    def __init__(self,name,age,sex=None):
        #一定要把没用默认值的变量写道前面
        self.name = name
        self.__age = age
        self.sex = sex
    def set_age(self,age):
        """
        变更年龄
        :param age: int 年龄
        """
        self.__age = age
        #return self.__age

    def show_info(self):
        rest ="我叫什么{}，今年{}岁,性别是{}".format(self.name,self.__age,self.sex)
        print(rest)
        return rest

    def eat(self):
        print("aaa")
class Dog():
    pass

if __name__ == "__main__":
    cat_blact = Cat("quan",11)
    cat_blact.show_info()
    cat_blact.eat()

    cat_white = Cat("zhi",12,"man")
    cat_white.show_info()

    print(cat_white.name)
    #print(cat_white.__age)#无法访问私有变量，只能通过类内函数
    cat_white.name = "改变名字"
    print(cat_white.name) #不是私有变量可以直接调用改变

    cat_white.set_age(44)
    cat_white.show_info()

    #类的实例是否是该类
    print(isinstance(cat_white,Cat))
    print(isinstance(cat_blact,Cat))
    print(isinstance(cat_blact,Dog))
    print(isinstance(cat_white,Dog))

jieguo:

我叫什么quan，今年11岁,性别是None
aaa
我叫什么zhi，今年12岁,性别是man
zhi
改变名字
我叫什么改变名字，今年44岁,性别是man
True
True
False
False

class BaseCat(object):
    """
    猫科动物的基础类BaseCat
    Tige   Panda  PerCat

    """
    tag = "猫科动物"
    def __init__(self,name):
        self.name = name

    def eat(self):
        """
        猫吃东西
        :return:
        """
        print("猫吃base")

class  Tiger(BaseCat):
    """
    老虎类，猫科动物
    """
    def eat(self):
        super(Tiger,self).eat()
        print("老虎吃肉")

class Panda(BaseCat):
    """
    熊猫也是
    """
    pass

class PerCat(BaseCat):
    """
    家猫类
    """
    def eat(self):
        super(PerCat, self).eat()
        print("家猫吃pet")

class HuaCat(PerCat):
    """
    家猫中的花猫
    """
    def eat(self):
        super(HuaCat, self).eat()
        print("家猫吃hua")

class DuanCat(PerCat):
    """
    短毛
    """
    def eat(self):
        # print("家猫吃duan")
        super(DuanCat, self).eat()

if __name__ == "__main__":
    cat = HuaCat("huahua")
    cat.eat()
    print("+++++++++++++++++++++++++++++")
    #实例化duan猫
    cat_d = DuanCat("duanduan")
    cat_d.eat()

    #子类的判断：
    print(issubclass(DuanCat,BaseCat))
    print(issubclass(HuaCat, BaseCat))
    print(issubclass(HuaCat, PerCat))
    print(issubclass(HuaCat,DuanCat))

注意：
当多重继承的父类存再相同的方法时，按照继承顺序，最先寻找到的方法为执行方法，剩下的即使发现也不会执行

class BaseCat(object):
    """
    猫科动物的基础类BaseCat
    Tige   Panda  PerCat

    """
    tag = "猫科动物"
    def __init__(self,name):
        self.name = name

    def eat(self):
        """
        猫吃东西
        :return:
        """
        print("猫吃base")

class ProtectMinxi(object):
    def protect(self):
        print("我是保护动物")

class ProtectL(object):
    def protect(self):
        print("我是国家级别")

class  Tiger(BaseCat,ProtectMinxi,ProtectL):
    """
    老虎类，猫科动物
    """
    def eat(self):
        super(Tiger,self).eat()
        print("老虎吃肉")

class  Tiger1(BaseCat,ProtectL,ProtectMinxi):
    """
    老虎类，猫科动物
    """
    def eat(self):
        super(Tiger1,self).eat()
        print("老虎吃肉")

if __name__ == "__main__":
    tager1 = Tiger("quan")
    tager1.protect()

    tager2 = Tiger1("zhi")
    tager2.protect()

结果：

我是保护动物
我是国家级别

class BaseCat(object):
    """
    猫科动物的基础类BaseCat
    Tige   Panda  PerCat

    """
    tag = "猫科动物"
    def __init__(self,name):
        self.name = name
        print("Base_init")

    def eat(self):
        """
        猫吃东西
        :return:
        """
        print("猫吃base")

class  Tiger(BaseCat):
    """
    老虎类，猫科动物
    """
    def __init__(self,name,color):
        super(Tiger,self).__init__(name)
        self.color = color
        print("Tiger_init")

    def eat(self):
        super(Tiger,self).eat()
        print("老虎吃肉")

    def show_info(self):
        print("Tiger{},{}".format(self.name,self.color))

if __name__ == "__main__":
    tiger = Tiger("quan","black")
    tiger.show_info()

结果：
Base_init
Tiger_init
Tigerquan,black

class PetCat(object):

    def __init__(self,name,age):
        """
        构造方法
        :param name: 猫的名称
        :param age:  猫的年龄
        """
        self.name = name
        self.__age = age

    @property
    def age(self):
        return self.__age

    @age.setter
    def age(self,value):
        if not isinstance(value,int):
            print("年龄必须时整数")
            return 0
        if value <0 or value > 100:
            print("年龄必须介于0-100之间")
            return 0
        self.__age = value
    @property
    def show_info(self):
        return "我叫{0}，今年{1}".format(self.name,self.age)

    def __str__(self):
        return "类的描述函数，可以通过直接打印类实例得到"
if __name__ == "__main__":
    cat_balk = PetCat("quan",12)
    cat_balk.age = 6
    rest = cat_balk.show_info
    print(rest)
    print(cat_balk.age)

使用@property装饰器的好处是既可以保护类的封装性，又可以使用“类.属性”来对私有属性进行操作。

使用@property装饰器可以直接通过方法名来访问方法，不需要再在后面使用"()".

使用＠property 直接调用 age() 方法，这样就使得该方法变成了 age 属性的 getter 方法，也就是读操作
setter 装饰器：@age.setter，可以对私有属性age的值进行写操作
deleter 装饰器:  @age.deleter，可以对私有属性age的值进行删除操作
注1：另外，私有属性只能在类中使用，且不可访问，目的是保护数据的安全性，以及隐藏核心开发细节。私有属性或私有方法以两个下划线开头。

注2：面向对象有三大特性: 封装，继承，多态

父类的私有方法和私有属性，不会被子类继承
可以通过调用继承的父类的共有方法，间接的访问父类的私有方法、属性
python中用super来使子类继承父类的属性或方法

当父类对变量出现slots的限制，不能再添加新的方法和属性，再子类如果还存在其他的slots语句变量，变量会加载父类后边，

class PetCat(object):

    __slots__ = ("name","age") #加入slots之后不能给实例添加属性和方法
    def __init__(self,name,age):
        """
        构造方法
        :param name: 猫的名称
        :param age:  猫的年龄
        """
        self.name = name
        self.age = age

    @property
    def show_info(self):
        return "我叫{0}，今年{1}".format(self.name, self.age)

    def __str__(self):
        return "类的描述函数，可以通过直接打印类实例得到"
class HuaCat(PetCat):
    __slots__ = ("color")#不加是不能添加新的方法和属性的
    pass

def eat():
    print("chichi")
if __name__ == "__main__":
    cat_balk = PetCat("quan",12)
    rest = cat_balk.show_info

    cat_white = HuaCat("zhi",12)
    cat_white.color = "hei"
    print(cat_white.show_info)

class Cat(object):
    tag = "miao"
    def __init__(self,name):
        self.name = name

    @staticmethod
    def breath():
        print("fuxifuxi")

    def show_info(self):
        print("{0}, {1}".format(self.tag,self.name))

if __name__ == "__main__":
    #非实例
    Cat.breath()
    print("QQQQQQQQQQQQQQQQQQQQQQ")
    #需要实例化调用
    cat = Cat("quan")
    cat.breath()
    cat.show_info()

jieguo :
fuxifuxi
QQQQQQQQQQQQQQQQQQQQQQ
fuxifuxi
miao, quan

class Cat(object):
    tag = "miao"
    def __init__(self,name):
        self.name = name

    @staticmethod
    def breath():
        print("fuxifuxi")

    @classmethod
    #后面设计系统的时候会用到的设计模式
    def show_info(cls,name):
        return cls(name)
       # print("{0}, {1}".format(cls.tag,cls.name))

    def show_info2(self):
        print("{0}, {1}".format(self.tag, self.name))

if __name__ == "__main__":
    cat = Cat.show_info("xiao")
    cat.show_info2()

结果：
miao, xiao