1.重写
继承后：子类可以拥有除父类继承之外的内容的其他内容
1.关于方法
1）.在子类中直接添加其他的方法
2）.重写：
a.完全重写
重新实现从父类继承过来的方法,重写后，子类在调用这个方法的时候，就调用子类的
b.保留父类实现的功能,再添加新的功能
对象和类调用方法的过程：先看当前类是否存在这个方法，没有才看父类有没有这个方法：如果父类没有就看父类的父类，直到基类（object），最后还是没有就报错
class Animol(object):
"""动物类"""
def __init__(self):
self.age = 0
self.color = ''
def eat(self):
print('吃东西')
def shout(self):
print('叫')
@classmethod
def get_number(cls):
return 100
class Dog(Animol):
"""狗类"""
def look_after(self):
print('看家')
#重写父类的shout
def shout(self):
print('wangwangwang')
# 重写了父类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()
an = Animol()
# 继承后，父类不能使用在子类中添加的方法
an.shout()
# an.look_after() 只能使用自己的方法和父类的方法
an.eat()
wangwangwang
看家
吃东西
吃骨头
叫
吃东西
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__':
st1 = Staff(age=18)
print(st1.age)
st1.salary = 1000
print(st1.salary)
18
1000
练习：
声明人类，有名字，性别，年龄和身高
要求创建人的时候可以给名字性别年龄赋初值
再创建学生类的继承自人类，拥有人类的所有属性，再添加学号，成绩，电话
要求创建学生对象的时候可以给名字，电话，年龄赋初值
#子类要自己添加属性的话父类中的对应属性就不要赋初值
class Person2(object):
def __init__(self,name,sex='男',age=18):
self.name = name
self.age = age
self.height =0
self.sex = sex
class Student(Person2):
def __init__(self,name,tel='00',age=0):
super().__init__(name,age=age)
self.study_id ='00'
self.score = 0
self.tel =tel
self.name = name
stu =Student('李四')
print(stu.age)
print(stu.name)
0
李四
3.运算符的重构
1.重载：一个类中可以有多个名字相同的名字，但是参数不一样，就叫重载
class Student(object):
# python中不支持方法的重载
# def run(self):
# print('人在跑')
def run(self,name):
print('%s在跑'%name)
if __name__ == '__main__':
stu = Student()
stu.run('chenpeng')
chenpeng在跑
2.运算符重载（重新定义运算符运算的方法）
,<
大于和小于符号只需要重载其中一个，另一个的结果就是结果取反
+,-
class Student2(object):
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) > other.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
stu1 = Student2('aa',18,170)
stu2 = Student2('bb',20,168)
if stu1>stu2:
print('学生1比学生2高')
if stu1<stu2:
print('学生1比学生2小')
else:
print('学生1比学生2大')
print(stu1+stu2)
学生1比学生2高
学生1比学生2小
38
4.内存管理
python内存管理原理
内存中有两个特殊的区域：栈，堆
栈：栈中的内存是系统自动管理(内存的开辟和释放) ---作用域结束，内存释放
堆：堆中的内存都是需要写程序去开辟和释放的(python中这个过程自动化了)
原理？：堆中的数据到底是什么时候释放的
看一个对象有几个引用，当一个值没有引用的时候，值对应的内存空间就会被释放
（引用计数机制）
引用：存储对象地址的变量
a = 10 #数字类型等于它本身存在栈里面
#其他的储存在堆里面
b = [1,2,3]
c = {'a':1,'b':2}
d = (1,2,3)
e = {1,2,3}
class P:
def __init__(self):
name = 'aaa'
p = P()
# 销毁对象存储空间就是直接删除对象对应的所有引用
#注意：将对象添加到容器中，对象的引用会加1
p1 = {1,2,3,4,4}
a =[p1,100]
del p1
#del a[0]
#del a
# 覆盖内存空间
a[0] =None
5.包的使用
封装：
对一个功能的封装 --> 用函数
对多个功能的封装 --> 模块和类
对多个数据进行封装 ---> 类，字典
对多个类进行封装 --> 模块
对多个模块进行封装 --> 包
# 导入包
import package1
#导入包中的某一个某块
from package1 import file
#导入包中的某一个模块中的函数（方法）
from package1.file import run
if __name__ == '__main__':
run()
