EGOIST

一、重写

继承后，子类可以拥有除父类继承的内容以外的其他内容
1、关于方法
1）、在子类中可以直接添加其他的方法
2）、重写：
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):
        return 1100

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())

二、添加子类属性

对象属性的继承：是通过继承init方法来继承的对象属性给当前类添加对象属性：重写init方法，如果需要保留父类的对象属性，需要使用super()去调用父类的init方法（保留父类的功能super().父类方法）

def  __init__(self):
      super().__init__()
      self.属性名 = 值

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

class Person:
    def __init__(self, name='', age=2):
        self.name = name
        self.age = age

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

if __name__ == '__main__':
    s1 = Person()
    s1.__init__('wd', 12)
    print(s1.name, s1.age)

练习：

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

class Person2:
    """人类"""
    a = 10

    def __init__(self, name, sex, age):
        self.name = name
        self.age = age
        self.sex = sex
        self.height = 0


class Student(Person2):
    """学生类"""
    b = 100

    def __init__(self, name='', age=0, tel='00'):
        super().__init__(name, age=age, sex='女')
        self.study_id = '00'
        self.score = 0
        self.tel = tel


stu = Student('李四')
stu.sex = '男'
print(stu.age)
p1 = Person2('张三', '男', 18)
人在吃饭

10000
员工在吃饭
0

三、运算符的重载

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

    #   重载: >
    """
    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('qwer')

    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)

    print(100+200)
    print('abc'+'abc')

qwer在跑
学生1大于学生2啊啊
===学生2小于学生1
38
30
300
abcabc

四、Python中的内存管理

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

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

引用：存储对象地址的变量

class Person:
    def __init__(self, name):
        self.name = name
    def run(self):
        print(self.name,'人在跑')

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

    # Person对象(0)，name='p1'  0+1+1-1-1
    p1 = Person('p1')
    p2 = p1
    del p2
    p1.run()
    p1 = 'a'

    # 注意：将对象添加到容器中，对象的引用会加1
    p3 = Person('p3')
    lists = [p3, 100]
    del p3

    lists[0].run()
  删除对象引用的方法
  # del lists[0]
    # del lists
    lists[0] = None

五、包的使用

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

导入包
"""import package1"""

导入某个包中的某个模块
"""from package1 import my_math"""

导入某个包的某个模块中的某个函数和类
"""from package1.my_math import sum,math"""