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('555')
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())
if __name__ == '__main__':
dog = Dog()
dog.age = 3
print(dog.color)
dog.shout()
dog.look_after()
dog.eat()
dog.get_number()
an = Animal()
# 继承后，父类不能使用在子类中添加的属性和方法
# an.look_after()
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__':
s1 = Staff()
print(s1.__dict__)
练习
"""
声明人类，属性：名字、年龄、性别、身高
要求创建人的对象的时候可以给名字、性别、年龄副初值
学生类：人类的所有属性，学号、成绩、电话
要求创建学生对象的时候可以给名字、年龄和电话赋初值
"""
class Person2:
def __init__(self, name='', age=0, sex=''):
self.name = name
self.age = age
self.sex = sex
self.height = 0
class Student(Person2):
def __init__(self, name='', age=0, tel=''):
super().__init__(name, age)
self.id = ''
self.score = 0
self.tel = tel
p1 = Person2('xx', 18, '男')
stu1 = Student('aa', 22, '123456')
print(p1.__dict__)
print(stu1.__dict__)
3.运算符的重载
1.重载：一个类中可以有多个名字相同的方法，python不支持重载
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()
stu.run('xx')
stu1 = Student2('aa', 18, height=166)
stu2 = Student2('bb', 10, height=140)
if stu1.age > stu2.age:
print('aaa')
if stu1 > stu2:
print('学生1比学生2高')
print(stu1+stu2)
4.python内存管理原理
内存中有两个特殊的区域：栈、堆
栈：栈中的内存是系统自动管理（内存的开辟和内存的释放） --- 作用域结束，内存就释放
堆：堆中的内存都需要写程序去开辟和释放（python中这个过程也已经自动化了）
原理：堆中的数据到底是声明时候释放的
看一个对象有几个引用，当一个对象没有引用的时候，值对应的内存空间就会被释放
(引用计数机制)
引用：存储对象地址的变量
class Person:
def __init__(self, name=''):
self.name = name
def run(self):
print('人在跑')
if __name__ == '__main__':
# 声明一个Person对象，存到p中
p = Person('p')
p.run()
# 删除对象的唯一引用，对象就会被删除
del p
# p.run()
# Person对象(0)，name='p1'
p1 = Person('p1')
p2 = p1
del p2
p1.run()
p1 = 'a'
# p1.run()
# 注意：将对象添加到容器中，对象的引用会加1
p3 = Person('p3')
lists = [p3]
del p3
lists[0].run()
5.包的使用
封装
对一个功能的封装 --> 用函数
对多个功能的封装 --> 模块和类
对多个数据进行封装 --> 类、字段
对多个类进行封装 --> 模块
对多个模块进行封装 --> 包(文件夹)
# 导入某个包中的某个模块
from packge1 import file
# 导入某个包的某个模块中的某个函数和类
from packge1.file import wirte,read
if __name__ == '__main__':
wirte()
file.wirte()
# packge1.jsonfile.json_read()
