1.重写

继承后子类可以拥有除父类继承以外的其他内容
继承后，父类不能使用在子类中添加的属性和方法

1）.方法

在子类中可以直接添加其他的方法
重写：
a.重新实现从父类继承下来的方法，重写后，子类再调用这个方法的时候，就调用子类的
b.保留父类实现的功能，再添加新的功能
对象和类调用方法的过程：先看当前类是否存在这个
方法，没有才看父类有没有这个方法，如果父类没有就看父类的父类有没有，直到找到基类(object)位置

class Animal:
    '''动物类'''
    def __init__(self):
        self.age=0
        self.color=''
    def eat(self):
        print('吃东西')
    def shout(self):
        print('叫')

    @classmethod
    def get_number(cls):
        print('101')
        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):
        return super().get_number()
        # return 1000



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

结果：

汪汪汪~
看家
吃东西
吃骨头
101
101
100

2.添加属性

对象属性的基础：通过继承init方法来继承对象的属性给当前类添加对象属性，重写init方法。
注意：如果要保留父类的对象属性，需要使用super()
去调用父类的init方法
多态：同一个事物有多种形态。
方法多态：子类继承父类的方法，可以对方法进行重写，一个方法就有多种形态(多态的表现)
类的多态：继承产生多态

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

if __name__ == '__main__':
    s1=Staff('30')
    # s1.name='张三'
    s1.sex='男'
    print(s1.name,s1.age,s1.salary,s1.sex)

结果：

30 0 0 男

练习：声明人类，有属性，名字、年龄、性别、身高
要求创建人的对象的时候可以给名字、姓名、年龄赋初值
再创建学生类继承自人类，拥有人类的所有属性，再添加学号、成绩、电话属性
要求创建学生对象的时候可以给名字、年龄和电话赋初值

class Person:
    def __init__(self,name='',age=20,sex=1.5):
        self.name=name
        self.age=age
        self.sex=sex
        self.height=''
class Student(Person):
    def __init__(self,name='',age=20,tel=''):
        super().__init__(name,age)
        self.id=''
        self.score=0
        self.tel=tel

if __name__ == '__main__':

    s=Student('小明',18,'12434')
    print(s.name,s.sex,s.age,s.tel)
    list1=[1,2,3]
    list2= [4,5, 6]
    list1=list1+list2
    print(list1)

结果：

小明 1.5 18 12434
[1, 2, 3, 4, 5, 6]

3.运算符重载

1）重载：一个类中可以有多个名字相同的方法，就是重载。python中不支持重载

2)运算符重载(重新定义运算符运算的过程)

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

+,-

class Student2:
    def __init__(self,name='',age=0,height=0):
        self.name=name
        self.age=age
        self.height=height
    # 重载:>
    def __gt__(self, other):
        # 比较对象1>对象2的时候是比较的他们的height属性
        return self.height>other.height
    # 重载：<
    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__':
    s=Student()
    s.run('小人')
    s2=Student2('aa',18,height=170)
    s3 = Student2('bb', 10, height=150)
        if s2>s3:
        print('学生1大于学生2')
    if s2<s3:
        print('学生1小于学生2')
    print(s2+s3)
    print(s2 - s3)

结果：

学生1大于学生2
学生1小于学生2
38
20

4.python内存管理原理

内存中两个特殊的区域：栈、堆
栈：栈中的内存是系统自动管理(内存的开辟和内存的释放)
--作用域结束，内存就释放
堆：堆中的内存都需要写程序去开辟和释放的(python中这个过程自动化)
原理：堆中的数据到底是什么时候释放的
看一个对象有几个引用，当一个对象没有引用的时候，值对应的内存空间就会被释放
(引用机制)

引用:存储对象地址的变量
删除对象的唯一引用，对象就会被销毁

5.封装：

05-包的使用.py
对一个个功能的封装-->用函数
对多个功能的封装-->模块和类
对数据进行封装-->类或者字典
对多个类进行封装-->模块
对多个模块进行封装-->包

# 导入包
import package1
# 导入某个包中的模块
from package1 import My_math
# 导入某个包某个模块的某个函数和类
from package1.My_math import sum,Math

if __name__ == '__main__':
    sum()
    m=Math('小明')
    print(m.name)
    package1.My_math.sum()
    My_math.sum()

#包package1
#My_math.py
def sum():
    print('吃肉')
class Math:
    def __init__(self,name):
        self.name=name
if __name__ == '__main__':
    pass