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)

巴特西

Python基础（9）——类

1) 继承的语法

1) 覆盖父类的方法

2) 对父类方法进行扩展

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

最新文章

热门文章

巴特西

Python基础（9）——类

1) 继承的语法

1) 覆盖父类的方法

2) 对父类方法进行 扩展

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

最新文章

热门文章

2) 对父类方法进行扩展