【python】第一模块步骤三第二课、类的特性

第二课、类的特性

一、类的定义与实现

　　1.1类和类的方法

　　类及类的定义

面向对象的基础
一种类型
类的实例称之为对象
一种用户自定义的类型
类里面有很多自定义的属性和方法

　　1.2 类的属性和方法

　　类的特殊方法——构造函数

def _init_(self,name,*args,**kwargs): self.name = name
pass

　　类的特殊方法——析构函数

def __del__(self):
pass

　　其他类的特殊方法

__doc__:文档信息
__module__:模块信息
tag：自定义的类属性
catch：自定义的类方法

 1 class Cat(object):
 2     """
 3     猫科动物类
 4     """
 5     # 类的属性
 6     tag = 'Cat base'
 7 
 8     def __init__(self,name):
 9         # 实例化后的属性
10         self.name = name
11         pass
12 
13     def eat(self):
14         """
15         吃
16         :return:
17         """
18         pass
19 class Tiger(Cat):
20     pass

　　1.3 类的实现

 1 class Cat(object):
 2     """
 3     猫科动物类
 4     """
 5     # 类的属性
 6     tag = '猫科动物'
 7     def __init__(self, name, age):
 8         # 实例化后的属性
 9         self.name = name
10         self.__age = age
11 
12     def set_age(self,age):
13         """
14         改变猫的年龄
15         :param age:int 年龄
16         :return:改变后的年龄
17         """
18         self.__age = age
19         # return self.__age
20 
21     def catch(self):
22         """猫捉老鼠"""
23         print('猫可以捕捉老鼠')
24 
25     def eat(self):
26         """
27         吃
28         :return:
29         """
30         print('猫喜欢吃鱼')
31 
32     def get_age(self):
33         """
34         显示猫的信息
35         :return:
36         """
37         rest = '{0}的年龄是{1}岁'.format(self.name, self.__age)
38         print(rest)
39         return rest

　　1.4 类的实例及判定

　　类的实例

 1 class Cat(object):
 2     """
 3     猫科动物类
 4     """
 5     # 类的属性
 6     tag = '猫科动物'
 7     def __init__(self, name, age, sex = None):
 8         # 实例化后的属性
 9         self.name = name
10         self.__age = age
11         self.sex = sex
12 
13     def set_age(self,age):
14         """
15         改变猫的年龄
16         :param age:int 年龄
17         :return:改变后的年龄
18         """
19         self.__age = age
20         # return self.__age
21 
22     def catch(self):
23         """猫捉老鼠"""
24         print('猫可以捕捉老鼠')
25 
26     def eat(self):
27         """
28         吃
29         :return:
30         """
31         print('猫喜欢吃鱼')
32 
33     def show_info(self):
34         """
35         显示猫的信息
36         :return:
37         """
38         rest = '{0}的年龄是{1}岁'.format(self.name, self.__age)
39         print('我的性别：{0}'.format(self.sex))
40         print(rest)
41         return rest
42 
43 class Tiger(object):
44     pass
45 
46 
47 if __name__ == '__main__':
48     # 实例化你家的小黑
49     cat_black = Cat('小黑', 2, '公的')
50     cat_black.eat()
51     cat_black.show_info()
52     print('----------')
53     print(cat_black.name)
54     # print(cat_black.age)
55     # print(cat_black.__age) # 无法访问私有变量
56     # 更改猫的名称
57     cat_black.name = '黑黑' # 可以直接改变
58     cat_black.__age = 6    # 无法操作私有变量
59     cat_black.show_info()
60     print('----------')
61     cat_black.set_age(7)
62     cat_black.show_info()
63 
64     print(Cat.tag)
65     print(cat_black.tag)
66 
67     # 实例化我家的小白
68     print('XXXXXXXXXXXXXXXXX')
69     cat_white = Cat('小白', 3, '母的')
70     cat_white.show_info()
71     print(cat_white.tag)
72 
73 
74     # 类的实例判断
75     print(isinstance(cat_black, Cat))
76     print(isinstance(cat_white, Cat))
77     print(isinstance(cat_black, Tiger))
78     print(isinstance(cat_white, Tiger))

二、类的继承与多态

　　2.1类的继承

　　类的继承

判断是否为其子类
- >>>issubclass(GoldDog,Animal)
- True
调用父类的方法
- def eat(self):
  - super(Cat,self).eat()
  - print('猫还喜欢吃鱼')

　　2.2类的多重继承

 1 """
 2 猫科动物的细化
 3         猫科动物类Cat
 4     Tiger类      panda类        PetCat类
 5                             duanCat类     huaCat类
 6 """
 7 
 8 class BaseCat(object):
 9     """
10     猫科动物的基础类
11     """
12     tag = '猫科动物'
13 
14     def __init__(self, name):
15         self.name = name # 猫都有名字
16 
17     def eat(self):
18         """猫吃东西"""
19         print('猫都要吃东西')
20 
21 class ProtectedMixin(object):
22     """受保护的类"""
23     def protected(self):
24         print('我是受省份级别保护的')
25 
26 class CountryProtectedMixin(object):
27     def protected(self):
28         print('我是受国家级别保护的')
29 
30 class Tiger(BaseCat, ProtectedMixin, CountryProtectedMixin):
31     """
32     老虎类 也是猫科动物
33     """
34     def eat(self):
35         super(Tiger, self).eat()
36         print("我还喜欢吃肉，大猪肉")
37 
38 
39 class Panda(BaseCat, ProtectedMixin):
40     """
41     熊猫类 也是猫科动物
42     """
43     pass
44 
45 class PetCat(BaseCat):
46     """
47     家猫类
48     """
49     def eat(self):
50         # 调用父类的方法
51         super(PetCat, self).eat()
52         print("我还喜欢猫粮")
53 
54 class HuaCat(PetCat):
55     """
56     中华田园猫
57     """
58     def eat(self):
59         # 调用父类的方法
60         super(HuaCat, self).eat()
61         print("我还喜欢零食")
62 
63 class DuanCat(PetCat):
64     """
65     英国短毛
66     """
67 
68     def eat(self):
69         print("我啥都吃")
70 
71 if __name__ == '__main__':
72     # # 实例化中华田园猫
73     # cat = HuaCat('小黄')
74     # cat.eat()
75     # print('______________')
76     # # 实例化英国短毛猫
77     # cat_d = DuanCat('小辉')
78     # cat_d.eat()
79     #
80     # # 子类的判断
81     # print(issubclass(DuanCat, BaseCat))
82     # print(issubclass(DuanCat, Tiger))
83     panda = Panda('卧龙小熊猫')
84     panda.eat()
85     panda.protected()
86 
87     tiger = Tiger('华南虎')
88     tiger.protected()
89     print('----------------')
90     # 验证子类信息
91     print(issubclass(Panda, ProtectedMixin))
92     print(issubclass(Panda, BaseCat))

　　2.3 多态

　　多态

每当无需知道对象是什么样的就能对其执行操作时，都是多态在起作用
举例      >>>1+2
             3

             >>>'you'+'me'

            ‘youme’

三、类的高级特性（难点）

　　3.1 类的高级特性之property

　　类的高级特性

1.@property：将类的方法当作属性来使用

 1 class petcat(object):
 2     """ 家猫类 """
 3 
 4     def __init__(self, name, age):
 5         """
 6         构造方法
 7         :param name:猫的名称
 8         :param age:猫的年龄
 9         """
10         self.name = name
11         # 私有的属性，不能给你们操作
12         self.__age = age
13 
14     @property
15     def age(self):
16         return self.__age
17 
18     @age.setter
19     def age(self, value):
20         if not isinstance(value, int):
21             print('年龄只能是整数')
22         if value < 0 or value > 100:
23             print('年龄只能介于0-100之间')
24             return 0
25         self.__age = value
26 
27     # 描述符
28     @property
29     def show_info(self):
30         """显示猫的信息"""
31         return '我叫：{0}，今年{1}岁'.format(self.name, self.age)
32 
33     def __str__(self):
34         return '我的对象：{0}'.format(self.name)
35 
36 if __name__ == '__main__':
37     cat_black = petcat('小黑', 2)
38     rest = cat_black.show_info
39     print(rest)
40     # 改变它的年龄
41     cat_black.age = 'a'
42     rest = cat_black.show_info
43     print(rest)
44 
45     # print(cat_black)

2.__slots__:

为指定的类设置一个静态属性列表
为属性很少的类节约内存空间

 1 class petcat(object):
 2     """ 家猫类 """
 3 
 4     __slots__ = ('name', 'age')
 5 
 6     def __init__(self, name, age):
 7         """
 8         构造方法
 9         :param name:猫的名称
10         :param age:猫的年龄
11         """
12         self.name = name
13         # 私有的属性，不能给你们操作
14         self.age = age
15 
16     # 描述符
17     @property
18     def show_info(self):
19         """显示猫的信息"""
20         return '我叫：{0}，今年{1}岁'.format(self.name, self.age)
21 
22     def __str__(self):
23         return '我的对象：{0}'.format(self.name)
24 
25 class HuaCat(petcat):
26     """中华田园猫"""
27     __slots__ = ('color')
28     pass
29 
30 def eat():
31     print('我喜欢吃鱼')
32 
33 if __name__ == '__main__':
34     cat_white = HuaCat('小白', 3)
35     rest = cat_white.show_info
36     print(rest)
37     #使用slots后不允许给实例添加新的属性和方法（函数）
38     # 给实例添加新的属性
39     cat_white.color = '白色'
40     print(cat_white.color)
41     # # 给实例添加新的方法（函数）
42     # cat_black.eat = eat
43     # cat_black.eat()
44     cat_white.name = '旺旺'
45     print(cat_white.show_info)

　　3.2 类的静态方法和实例方法

　　类的静态方法和实例方法

@staticmethod 表示静态方法
@classmethod 表示类方法

 1 class Cat(object):
 2 
 3     tag = '猫科动物'
 4 
 5     def __init__(self, name):
 6         self.name = name
 7 
 8     @staticmethod
 9     def breath():
10         """呼吸"""
11         print('猫都需要呼吸空气')
12 
13     def show_info(self):
14         print(self.tag)
15 
16     @classmethod
17     def show_info(cls, name):
18         """显示猫的信息"""
19         # print('类的属性：{0}，实例的属性：{1}'.format(cls.tag, cls.name))
20         return cls(name)
21         # cat = Cat(name)
22         # return cat
23 
24     def show_info2(self):
25         """显示猫的信息"""
26         print('类的属性：{0}，实例的属性：{1}'.format(self.tag, self.name))
27 
28 
29 if __name__ == '__main__':
30     # # 通过类进行调用
31     # Cat.breath()
32     # # 通过类的实例进行调用
33     # cat = Cat('小黑')
34     # cat.breath()
35     # cat.show_info2()
36 
37     # 调用classMethod
38     cat2 = Cat.show_info('小黄')
39     cat2.show_info2()

四、课程总结

　　4 课程总结

　　小结

面向对象概述
类及类的定义
类的特殊方法
类的实现
类的实例
类的继承
类的多重继承
多态
类的高级属性
类的静态方法和实例方法

　　一些建议

命名要尽可能的语义化
慎用继承，尤其是多重继承
注释一定不可缺少
一个函数操作一个全局变量，最好将它们作为一个类的属性和方法
方法应只关心其所属实例的属性，对于其他实例的状态，让他们自己去管理

posted on 2019-11-22 10:07 喵了个喵0507 阅读(205) 评论(0) 收藏举报

刷新页面返回顶部