1.重写
继承后：子类可以拥有除父类继承之外的内容的其他内容

1.关于方法
1）.在子类中直接添加其他的方法
2）.重写：
a.完全重写
重新实现从父类继承过来的方法,重写后，子类在调用这个方法的时候，就调用子类的
b.保留父类实现的功能,再添加新的功能

对象和类调用方法的过程：先看当前类是否存在这个方法，没有才看父类有没有这个方法：如果父类没有就看父类的父类，直到基类（object），最后还是没有就报错

class Animol(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(Animol):
    """狗类"""
    def look_after(self):
        print('看家')

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

    # 重写了父类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 = Animol()
    # 继承后，父类不能使用在子类中添加的方法
    an.shout()
    # an.look_after()  只能使用自己的方法和父类的方法
    an.eat()
wangwangwang
看家
吃东西
吃骨头
叫
吃东西

2.添加属性

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

给当前类添加对象属性：重写init方法。
注意：如果要保留父类的对象属性，需要使用super()去调用父类的init方法

子类要自己添加属性的话父类中的对应属性就不要赋初值
无关紧要就设置初值，如果对象之后都要从外面赋值的话就不给默认值，只给属性名
对象传值给类，类传值给父类

多态：同一事物有多种形态（表现）
比如：子类继承父类的方法，可以对方法进行重写，这样一个方法就有多个形态（多态的表现）
类的多态;继承产生多态

class Person(object):
    def __init__(self,name,age=0):
        self.name = name
        self.age = age

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

if __name__ == '__main__':
    st1 = Staff(age=18)
    print(st1.age)
    st1.salary = 1000
    print(st1.salary)
18
1000

练习：
声明人类，有名字，性别，年龄和身高
要求创建人的时候可以给名字性别年龄赋初值

再创建学生类的继承自人类，拥有人类的所有属性，再添加学号，成绩，电话
要求创建学生对象的时候可以给名字，电话，年龄赋初值

#子类要自己添加属性的话父类中的对应属性就不要赋初值
class Person2(object):
    def __init__(self,name,sex='男',age=18):
        self.name = name
        self.age = age
        self.height =0
        self.sex = sex

class Student(Person2):
    def __init__(self,name,tel='00',age=0):
        super().__init__(name,age=age)
        self.study_id ='00'
        self.score = 0
        self.tel =tel
        self.name = name


stu =Student('李四')
print(stu.age)
print(stu.name)
0
李四

3.运算符的重构

1.重载：一个类中可以有多个名字相同的名字，但是参数不一样，就叫重载

class Student(object):

    # python中不支持方法的重载
    # def run(self):
    #     print('人在跑')
    def run(self,name):
        print('%s在跑'%name)

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

2.运算符重载（重新定义运算符运算的方法）

,<
大于和小于符号只需要重载其中一个，另一个的结果就是结果取反
+,-

class Student2(object):
    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) > other.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

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

if stu1>stu2:
    print('学生1比学生2高')

print(stu1+stu2)
学生1比学生2高
学生1比学生2小
38

4.内存管理

python内存管理原理

内存中有两个特殊的区域：栈，堆
栈：栈中的内存是系统自动管理(内存的开辟和释放) ---作用域结束，内存释放
堆：堆中的内存都是需要写程序去开辟和释放的(python中这个过程自动化了)

原理？：堆中的数据到底是什么时候释放的
看一个对象有几个引用，当一个值没有引用的时候，值对应的内存空间就会被释放
（引用计数机制）
引用：存储对象地址的变量

a = 10    #数字类型等于它本身存在栈里面
          #其他的储存在堆里面
b = [1,2,3]
c = {'a':1,'b':2}
d = (1,2,3)
e = {1,2,3}
class P:
    def __init__(self):
        name = 'aaa'

p = P()

# 销毁对象存储空间就是直接删除对象对应的所有引用
#注意：将对象添加到容器中，对象的引用会加1
p1 = {1,2,3,4,4}
a =[p1,100]
del p1

#del a[0]
#del a
#  覆盖内存空间
a[0] =None

5.包的使用

封装：
对一个功能的封装 --> 用函数
对多个功能的封装 --> 模块和类
对多个数据进行封装 ---> 类，字典
对多个类进行封装 --> 模块
对多个模块进行封装 --> 包

# 导入包
import package1

#导入包中的某一个某块
from package1 import file

#导入包中的某一个模块中的函数（方法）
from package1.file import run


if __name__ == '__main__':
    run()