python学习-面向对象

类的特性

类及类的定义：
面向对象的基础
一种类型
类的实例成为对象
一种用户自定义的类型
类里面又很多自定义的属性和方法

类的特殊方法-构造方法

类的构造方法（如果不写，默认生成）
self 类对象的引用
name 类的属性

类的特殊方法-析构函数

类的其他方法

doc ：查看文档信息

class Cat:
    """猫科动物类"""
    def __init__(self):
        pass
    pass

from test_class import Cat
Cat.doc
‘猫科动物类’

module：模块信息
tag:自定义的类属性

class Cat:
    #类的属性
    tag = 'Cat'
    """猫科动物类"""
    def __init__(self,name):
        #实例化对象的属性
        self.name = name
        pass
    pass

catch:自定义的类方法
dir:查看类的方法

dir(Cat)
[‘class’, ‘delattr’, ‘dict’, ‘dir’, ‘doc’, ‘eq’, ‘format’, ‘ge’, ‘getattribute’, ‘gt’, ‘hash’, ‘init’, ‘init_subclass’, ‘le’, ‘lt’, ‘module’, ‘ne’, ‘n
ew’, ‘reduce’, ‘reduce_ex’, ‘repr’, ‘setattr’, ‘sizeof’, ‘str’, ‘subclasshook’, ‘weakref’]

help：查看帮助
dict
bases:查看继承的类

类的实现

class Cat(object):
    """猫科动物类"""

    #
    tag = "我是家猫"
    def __init__(self,name,age,sex =  None):
        self.name = name
        #隐藏age,私有化
        self.__age = age
        self.sex = sex

    def set_age(self,age):
        """更改年龄"""
        self.__age = age
        return self.__age

    #展示信息
    def show_info(self):
        rest = ('我叫:{0},今年{1}岁'.format(self.name,self.__age))
        print('我的性别:{0}'.format(self.sex))
        print(rest)
        return rest

    def eat(self):
        print("猫喜欢吃鱼")

    def catch(self):
        print("猫捉老鼠")

if __name__ =='__main__':
    """实例化"""
    cat_black = Cat('小黑',24,'公')
    cat_black.eat()
    cat_black.show_info()
    print('---------------------')
    print(cat_black.name)
    #print(cat_black.__age) 无法改变私有变量
    cat_black.name = '嘿嘿' #可以直接改变
    cat_black.__age = 6 # 无法修改私有变量
    cat_black.show_info()
    print('---------------')
    cat_black.set_age(7)
    cat_black.show_info()
    print('------')
    print(Cat.tag)
    

类方法中的self是实例对象，表示实例化对象可以直接调用方法
构造函数中初始化参数如果没有默认值，必须传参，有默认值放最后

判断是否类的实例

    #类的实例判断
    print(isinstance(cat_black,Cat))

类的继承

"""
猫科动物的细化
           猫科动物类BaseCat
      |               |              |
    Tiger类          Panda 类      PetCat 类
                                   |           |
                                DuanCat 类     HuaCat类
"""


class BaseCat(object):
    """猫科动物的基础类"""
    tag = '猫科动物'

    def __init__(self,name):
        self.name = name #猫都有名字

    def eat(self):
        print('猫都吃东西')

    def eat2(self):
        print('我是爷爷')


class Tiger(BaseCat):
    """老虎类"""
    def eat(self):
        # 调用父类方法
        super(Tiger, self).eat()
        print('我还喜欢吃肉，大猪肉')


class Panda(BaseCat):
    """熊猫类，也是猫科动物"""
    pass


class PetCat(BaseCat):
    """家猫类"""
    def eat(self):
        #调用父类的方法
        super(PetCat, self).eat()
        print('我爱吃猫粮')


class HuaCat(PetCat):
    """中华田园猫"""
    def eat(self):
        #调用父类的方法
        super(HuaCat, self).eat()
        print('我还爱吃零食')


class DuanCat(PetCat):
    """英国短毛"""
    pass

if __name__ == '__main__':
    """实例化中华田园猫"""
    cat = HuaCat('小黄')
    cat.eat()
    print('----------------------')
    cat_d = DuanCat('小辉')
    cat_d.eat()
    #子类的判断
    print(issubclass(DuanCat,PetCat))

类的多态

class BaseCat(object):
    """猫科动物的基础类"""
    tag = '猫科动物'

    def __init__(self,name):
        print('BaseCat init')
        self.name = name #猫都有名字

    def eat(self):
        print('猫都吃东西')

    def eat2(self):
        print('我是爷爷')


class Tiger(BaseCat):
    """重写，重载"""
    def  __init__(self,name,color):
        super().__init__(name)
        print('Tiger init')
        self.color = color

    def show_info(self):
        print('Tiger :{0},颜色:{1}'.format(self.name,self.color))

    def eat(self):
        # 调用父类方法
        super().eat()
        print('我还喜欢吃肉，大猪肉')


if __name__ == '__main__':
    tiger = Tiger('华南虎','黄色')
    tiger.show_info()

类的高级特性@property

说明：将类的方法当作属性来使用

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,values):
        if  not isinstance(values,int):
            print('年龄只能是整数')
            return 0
        if values <0 or values>100:
            print('年龄不符')
            return 0
        self.__age = values

    #描述符
    @property
    def show_info(self):
        """显示猫的信息"""
        return '我叫:{0},今年{1}岁'.format(self.name,self.age)


if __name__ =='__main__':
    cat_black = PetCat('小黑',2)
    rest = cat_black.show_info
    print(rest)
    #改变猫的age
    cat_black.age = -4
    rest = cat_black.show_info
    print(rest)

类的高级特性 slot:

说明 ： 1，为指定的类设置一个静态属性列表（不可改变）
2，为属性很少的类节约内存空间

class PetCat(object):

    #限制只能使用这两个属性，后面是元组
    __slots__ = ('name','age')

    """家猫类"""
    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)

class HuaCat(PetCat):
    __slots__ = ('color',)
    pass


def eat():
        print('我喜欢吃鱼')

if __name__ =='__main__':
    cat_black = PetCat('小黑',2)
    rest = cat_black.show_info
    print(rest)
    #给实例添加新的属性
    #cat_black.color = '白的'
    #print(cat_black.color)
    #给实例增加新的方法
    #cat_black.eat =eat
    #cat_black.eat()
    print('------------')
    cat_white = HuaCat('小白',3)
    rest = cat_black.show_info
    cat_white.color = '白的'
    #print(cat_black.color)
    print(cat_white.color)
    

静态方法和实例方法

1.staticmethod 静态方法
2.classmethod 类方法

class Cat(object):

    tag = '猫科动物'

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

    @staticmethod
    def breath():
        print('猫都需要呼吸')

    def show_info(self):
        """显示猫的信息"""
        print('类的属性:{0},实例的属性:{1}'.format(self.tag,self.name))

    #类的方法，cls无法调用name
    @classmethod
    def show_info(cls):
        """显示猫的信息"""
        print('类的属性:{0},实例的属性:{1}'.format(cls.tag,cls.name))

if __name__ =='__main__':
    #静态方法可以通过类进行调用
    Cat.breath()
    #通过类的实例进行调用
    cat = Cat('小黑')
    cat.breath()
    cat.show_info()