day14-面向对象3

01-重写

• 继承后，子类可以拥有除父类继承的内容以外的其他内容
  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):
     #  保留父类的类方法的功能的时候，还是super（）.类方法
        return 100

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

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

    @classmethod
    def get_number(cls):
        print(super().get_number())

if __name__ == '__main__':
    dog = Dog()
    dog.age = 3
    dog.eat()

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

02-添加属性

• 对象属性的继承：是通过继承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)
#         self.salary = 0
#
# if __name__ == '__main__':
#     s1 = Staff()
#     print(s1.name)
#     s1.salary = 10000
#     print(s1.salary)

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

class Person(object):
    def __init__(self,name,sex='',age=10):
        self.name = name
        self.age = age
        self.sex = sex
        self.height =0

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

stu1 = Student('李四')
print(stu1.age)

03-运算符的重载

• 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

• 重载: <

    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=180)
    stu2 = Student2('bb',10,height=160)
    if stu1 > stu2:
        print('学生1大于学生2')

04-python中的内存管理

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

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

引用

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


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

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

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

05-包的使用

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

• 导入包
  import package1
  -导入某个包中的某个模块
  from package1 import file
• 导入某个包的某个模块中的某个函数和类
  from package1.my_math import sum,Math