一、重写

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

1.关于方法

• a.在子类中可以直接添加其他的方法
• b.完全重写：
  重新实现从父类继承下来的方法，重写后，子类再调用的方法的时候，就调用子类的方法
• c.保留父类实现的功能，添加新的功能

对象和类调用方法的过程：先看当前类是否存在这个方法，没有才查看父类有没有这个方法
如果父类没有就看父类的父类有没有，直到找到基类(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('66')

class Dog(Animal):
    """狗类"""

    def look_after(self):
        print('看家')
    #重写父类的shout
    def shout(self):
        print('汪汪汪')
    def eat(self):
        #保留父类eat的功能
        super().eat()
        print('吃骨头')
    @classmethod
    def get_number(cls):
        #保留父类的类方法的功能的时候，还是super(),.类方法
        print(super().get_number())
dog = Dog()

dog.age = 2
print(dog.age)

dog.look_after()
dog.shout()
an = Animal()
#继承后，父类不能使用子类的方法和属性
# an.look_after
dog.eat()



if __name__ == '__main__':
    pass

结果

2
看家
汪汪汪
吃东西
吃骨头

二、添加属性

"""
对象属性的继承：通过继承init方法继承的对象的属性
给当前类添加对象属性：重写init方法
注意：如果要保留父类的对象属性，需要使用super（）去调用父类的init方法

多态：同一个事物有多重形态.
方法的多态：子类继承父类的方法，可以对方法进行重写，一个方法就有多种形态9对台的表现)
类的多态：继承产生多态

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

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


if __name__ == '__main__':
    s1 = Staff('张三')
    s1.salary = 100
    print(s1.name)
    print(s1.salary)



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


class  Person:
    def __init__(self,name,age= 16,sex= '男'):
        self.name = name
        self.age = age
        self.sex = sex
        self.height = 0
class Student(Person):
    def __init__(self,name,age=0,score = 11):
        super().__init__(name,age= age)
        self.stu_id = ''
        self.score = score
        self.number = 0
p2 = Person('张三')
stu1 = Student('李四')

print(stu1.name)

结果

张三
100
李四

三、运算符的重载

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

class Student:
    #python不支持方法的重载

    # def run(self):
    #     print('人在跑')
    def run(self,name):
        print('%s在跑'%name)

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__':
    stu1 = Student2('aa',17,height = 140)
    stu2 = Student2('bb',13,height=130)

    if stu1>stu2:
        print('====')
    # print(stu2+stu1)
    if stu1<stu2:
        print('学生1大于学生2')
    else:
        print('学生2小于学生1')
    print(stu1+stu2)
    print(stu1-stu2)
    print('abc'+'aac')

结果

====
学生2小于学生1
30
10
abcaac

四、python中的内存管理

python内存管理原理

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

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

class Person:
    def run(self):
        print('人在跑')


if __name__ == '__main__':
    p = Person()
    p.run()
    #删除对象的唯一的引用，对象就会被销毁
    del p
    # p.run()

    p1 = Person()
    p2 = p1
    del p2
    p1.run()

    #注意：将对象添加到容器中，对象的引用会加1
    p3 = Person()
    list1 = [p3]
    del p3
    list1[0].run()

    #del list1[0]
    # list1[0] = None

结果

人在跑
人在跑
人在跑

封装：
对功能的封装-->用函数
对多个功能的封装-->模块和类
对多个数据进行封装-->类、字典
对多个类进行封装 -->模块
对多个模块进行封装-->包(文件夹)

"""

导入某个包中的模块

from package1 import file

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

from package1.my_math import sum

if name == 'main':
pass