继承与重写

1.重写

继承后，子类可以拥有除父类继承的内容以外的其他内容。

1.关于方法

a.在子类中可以直接添加方法

b.重写

完全重写:重新实现从父类继承下来的方法,重写后,子类在调用这个方法的时候，就调用子类自己的方法。

保留父类实现额功能，在添加新的功能

对象和类调用方法的过程：先看当前类是否存在这个方法，没有在父类寻找看有没有这个方法，如果没有就查找到父类的父类，直到查找到object类为止。

class Animal(object):
    """动物类"""
    def __init__(self):
        self.age = 0
        self.color = ''

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

    def shout(self):
        print('叫唤')

    @classmethod
    def get_number(cls):
        return 100


class Dog(Animal):
    """狗类"""
    def look_after(self):
        print('看家')

    #  重写父类的shout
    def shout(self):
        print('汪汪汪~')

    # 重写父类eat方法
    def eat(self):
        # 保留父类eat的功能
        super().eat()
        print('吃骨头')

    @classmethod
    def get_number(cls):
        # 保留父类的类方法的功能的时候，还是super().类方法
        print(super().get_number())


if __name__ == '__main__':
    dog = Dog()
    dog.age = 3
    print(dog.color)
    dog.shout()
    dog.look_after()
    dog.eat()

    an = Animal()
    # 继承后，父类不能使用在子类中添加的属性和方法
    # an.look_after()
    an.eat()
    Dog.get_number()

2.添加属性

对象属性的继承:是通过继承init方法来继承的对象属性

给当前类添加对象属性:重写init方法。

注意：如果要保留父类的对象属性，需要使用super( )去调用父类的init方法

多态:同一个事物都有多种形态

方法的多态: 子类继承父类的方法，可以对方法进行重写，一个方法就有多种形态(多态的表现)

类的多态:继承产生多态

class Person(object):
    """人类"""
    def __init__(self, name, age=0, sex=''):
        self.name = name
        self.age = age
        self.sex = sex

    def eat(self):
        print('人在吃饭')


class Staff(Person):
    # init方法的参数：保证在创建对象的时候就可以给某些属性赋值
    def __init__(self, name='', age=0, salary=0):
        super().__init__(name, age)
        self.salary = salary

    def eat(self):
        print('员工在吃饭')

class Scientist(Person):
    def eat(self):
        print('科学家在吃饭')


if __name__ == '__main__':
    p1 = Person('李四',sex='女')
    p1.eat()

    s1 = Staff(age=18)
    s1.sex = '男'
    print(s1.name)
    s1.salary = 10000
    print(s1.salary)
    s1.eat()

3.运算符的重载

3.1重载

一个类中可以有多个名字相同的方法，但是参数不一样，就叫重载。python中不支持

3.2运算符重载

重新定义运算符运算的过程

>(_gt_) <(__lt__) +(__add__) -(__sub__)

大于和小于只需要重载其中的一个，另外一个的结果，直接是重载的结果取反。

class Student2:
    def __init__(self, name='', age=0, height=0):
        self.name = name
        self.age = age
        self.height = height

    #   重载: >
    """
    self > other
    """
    def __gt__(self, other):
        # 比较对象1>对象2的时候是比较的他们的height属性
        return self.height > other.height
        # return self.age > other.age
        # return id(self) > id(other)

    # 重载：<
    def __lt__(self, other):
        return self.age < other.age

    # 重载: +
    def __add__(self, other):
        return self.age + other.age

    # 重载: -
    def __sub__(self, other):
        return self.height - other.height


if __name__ == '__main__':
    stu = Student()
    stu.run('余婷')

    stu1 = Student2('aa', 18, height=170)
    stu2 = Student2('bb', 20, height=140)

    if stu1 > stu2:
        print('学生1大于学生2啊啊')

    if stu1 < stu2:
        print('学生1大于学生2')
    else:
        print('学生2小于学生1')

    print(stu1 + stu2)
    print(stu1-stu2)

4.包的使用

封装：

对一个功能的封装 --> 用函数

对多个功能的封装 --> 模块和类

对多个数据进行封装 --> 类，字典

对多个类进行封装 --> 模块

对多个模块进行封装 —>包(文件夹)

导入某个包中的某个模块

from package1 import my_math

导入某个包的某个模块中的某个函数和类

from package1.my_math import sum