Python基础（9）——类

类的语法

类的定义

 class Dog(object):     print("hello,I am a dog!") d = Dog() #实例化这个类，
 #此时的d就是类Dog的实例化对象 #实例化，其实就是以Dog类为模版，在内存里开辟一块空间，存上数据，赋值成一个变量名

　　类的初始化

 class Dog(object):     def __init__(self,name,dog_type):
         self.name = name
         self.type = dog_type     def sayhi(self):         print("hello,I am a dog, my name is ",self.name) d = Dog('LiChuang',"京巴")
 d.sayhi()

　　类的方法

__init__ 方法相当于构造函数

class Cat:
    """这是一个猫类"""    def __init__(self):
        print("初始化方法")

__del__方法相当于析构函数

class Cat:    def __init__(self, new_name):        self.name = new_name        print("%s 来了" % self.name)    def __del__(self):        print("%s 去了" % self.name)

定义私有属性或方法

在定义属性或方法时，在属性名或者方法名前增加两个下划线

class Women:    def __init__(self, name):        self.name = name
        # 不要问女生的年龄
        self.__age = 18    def __secret(self):
        print("我的年龄是 %d" % self.__age)xiaofang = Women("小芳")
# 私有属性，外部不能直接访问
# print(xiaofang.__age)# 私有方法，外部不能直接调用
# xiaofang.__secret()

类的继承

1) 继承的语法

class 类名(父类名):    pass

2）重写(override)

当父类的方法实现不能满足子类需求时，可以对方法进行 重写(override)

重写父类方法有两种情况：

覆盖父类的方法
对父类方法进行扩展

1) 覆盖父类的方法

如果在开发中，父类的方法实现 和 子类的方法实现，完全不同
就可以使用覆盖的方式，在子类中 重新编写 父类的方法实现

具体的实现方式，就相当于在 子类中 定义了一个 和父类同名的方法并且实现

重写之后，在运行时，只会调用 子类中重写的方法，而不再会调用 父类封装的方法

2) 对父类方法进行扩展

如果在开发中，子类的方法实现 中包含 父类的方法实现
- 父类原本封装的方法实现 是 子类方法的一部分
就可以使用扩展的方式
1. 在子类中 重写父类的方法
2. 在需要的位置使用 super().父类方法 来调用父类方法的执行
3. 代码其他的位置针对子类的需求，编写 子类特有的代码实现

关于 super

在 Python 中 super 是一个 特殊的类
super() 就是使用 super 类创建出来的对象
最常使用的场景就是在 重写父类方法时，调用 在父类中封装的方法实现

class Dog():
    def bark(self):
        print("汪汪汪")class XiaoTianQuan(Dog):
    def bark(self):
         #子类特有需求
        print("像神一样叫...")         #使用super()调用父类中的方法
        super().bark()

完整例子

class SchoolMember(object):
    members = 0 #初始学校人数为0
    def __init__(self,name,age):
        self.name = name
        self.age = age    def  tell(self):
        pass    def enroll(self):
        '''注册'''
        SchoolMember.members +=1
        print("\033[32;1mnew member [%s] is enrolled,now there are [%s] members.\033[0m " %(self.name,SchoolMember.members))    def __del__(self):
        '''析构方法'''
        print("\033[31;1mmember [%s] is dead!\033[0m" %self.name)
class Teacher(SchoolMember):
    def __init__(self,name,age,course,salary):
        super(Teacher,self).__init__(name,age)
        self.course = course
        self.salary = salary
        self.enroll()    def teaching(self):
        '''讲课方法'''
        print("Teacher [%s] is teaching [%s] for class [%s]" %(self.name,self.course,'s12'))    def tell(self):
        '''自我介绍方法'''
        msg = '''Hi, my name is [%s], works for [%s] as a [%s] teacher !''' %(self.name,'Oldboy', self.course)
        print(msg)class Student(SchoolMember):
    def __init__(self, name,age,grade,sid):
        super(Student,self).__init__(name,age)
        self.grade = grade
        self.sid = sid
        self.enroll()    def tell(self):
        '''自我介绍方法'''
        msg = '''Hi, my name is [%s], I'm studying [%s] in [%s]!''' %(self.name, self.grade,'Oldboy')
        print(msg)if __name__ == '__main__':
    t1 = Teacher("Alex",22,'Python',20000)
    t2 = Teacher("TengLan",29,'Linux',3000)    s1 = Student("Qinghua", 24,"Python S12",1483)
    s2 = Student("SanJiang", 26,"Python S12",1484)    t1.teaching()
    t2.teaching()
    t1.tell()

多继承

class 子类名(父类名1, 父类名2...)
    pass

Python 中的 MRO —— 方法搜索顺序（知道）

Python 中针对类提供了一个 内置属性 __mro__ 可以查看方法搜索顺序
MRO 是 method resolution order，主要用于 在多继承时判断方法、属性的调用路径

print(C.__mro__)

输出结果

(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)

在搜索方法时，是按照 __mro__ 的输出结果 从左至右 的顺序查找的
如果在当前类中 找到方法，就直接执行，不再搜索
如果 没有找到，就查找下一个类 中是否有对应的方法，如果找到，就直接执行，不再搜索
如果找到最后一个类，还没有找到方法，程序报错

Python3全是广度优先继承Python2是经典类是深度优先、新型类是广度优先

多态

多态不同的 子类对象 调用相同的 父类方法，产生不同的执行结果

以 继承的子类重写父类方法 为前提
例子：

class Dog(object):    def __init__(self, name):
        self.name = name    def game(self):
        print("%s 蹦蹦跳跳的玩耍..." % self.name)class XiaoTianDog(Dog):    def game(self):
        print("%s 飞到天上去玩耍..." % self.name)class Person(object):    def __init__(self, name):
        self.name = name    def game_with_dog(self, dog):        print("%s 和 %s 快乐的玩耍..." % (self.name, dog.name))        # 让狗玩耍
        dog.game()# 1. 创建一个狗对象
# wangcai = Dog("旺财")
wangcai = XiaoTianDog("飞天旺财")# 2. 创建一个小明对象
xiaoming = Person("小明")# 3. 让小明调用和狗玩的方法
xiaoming.game_with_dog(wangcai)

class Animal(object):
    def __init__(self, name):  # Constructor of the class
        self.name = name    def talk(self):              # Abstract method, defined by convention only
        raise NotImplementedError("Subclass must implement abstract method")class Cat(Animal):
    def talk(self):
        print('%s: 喵喵喵!' %self.name)class Dog(Animal):
    def talk(self):
        print('%s: 汪！汪！汪！' %self.name)def func(obj): #一个接口，多种形态
    obj.talk()c1 = Cat('小晴')
d1 = Dog('李磊')func(c1)
func(d1)

另一种更简便的形式

class Animal(object):
    def __init__(self, name):  # Constructor of the class
        self.name = name    def talk(self):  # Abstract method, defined by convention only
        raise NotImplementedError("Subclass must implement abstract method")###该写成类内的形式
    @staticmethod
    def func(obj):  # 一个接口，多种形态
        obj.talk()class Cat(Animal):
    def talk(self):
        print('%s: 喵喵喵!' % self.name)class Dog(Animal):
    def talk(self):
        print('%s: 汪！汪！汪！' % self.name)c1 = Cat('小晴')
d1 = Dog('李磊')Animal.func(c1)

1) 继承的语法

1) 覆盖父类的方法

2) 对父类方法进行 扩展

Python 中的 MRO —— 方法搜索顺序（知道）

个人收藏笔记记录

开通VIP

2) 对父类方法进行扩展