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('101')
return 100
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):
return super().get_number()
# return 1000
if __name__ == '__main__':
dog=Dog()
dog.age=3
print(dog.color)
dog.shout()
dog.look_after()
dog.eat()
Animal.get_number()
print(Dog.get_number())
结果：
汪汪汪~
看家
吃东西
吃骨头
101
101
100
2.添加属性
对象属性的基础：通过继承init方法来继承对象的属性给当前类添加对象属性，重写init方法。
注意：如果要保留父类的对象属性，需要使用super()
去调用父类的init方法
多态：同一个事物有多种形态。
方法多态：子类继承父类的方法，可以对方法进行重写，一个方法就有多种形态(多态的表现)
类的多态：继承产生多态
class Person(object):
def __init__(self,name='a',age=0):
self.name=name
self.age=age
class Staff(Person):
# init方法的参数，保证在创建对象的时候就可以给
# 某些属性赋值
def __init__(self,name,age=0):
super().__init__(name,age)
self.salary=0
if __name__ == '__main__':
s1=Staff('30')
# s1.name='张三'
s1.sex='男'
print(s1.name,s1.age,s1.salary,s1.sex)
结果：
30 0 0 男
练习：声明人类，有属性，名字、年龄、性别、身高
要求创建人的对象的时候可以给名字、姓名、年龄赋初值
再创建学生类继承自人类，拥有人类的所有属性，再添加学号、成绩、电话属性
要求创建学生对象的时候可以给名字、年龄和电话赋初值
class Person:
def __init__(self,name='',age=20,sex=1.5):
self.name=name
self.age=age
self.sex=sex
self.height=''
class Student(Person):
def __init__(self,name='',age=20,tel=''):
super().__init__(name,age)
self.id=''
self.score=0
self.tel=tel
if __name__ == '__main__':
s=Student('小明',18,'12434')
print(s.name,s.sex,s.age,s.tel)
list1=[1,2,3]
list2= [4,5, 6]
list1=list1+list2
print(list1)
结果：
小明 1.5 18 12434
[1, 2, 3, 4, 5, 6]
3.运算符重载
1）重载：一个类中可以有多个名字相同的方法，就是重载。python中不支持重载
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__':
s=Student()
s.run('小人')
s2=Student2('aa',18,height=170)
s3 = Student2('bb', 10, height=150)
if s2>s3:
print('学生1大于学生2')
if s2<s3:
print('学生1小于学生2')
print(s2+s3)
print(s2 - s3)
结果：
学生1大于学生2
学生1小于学生2
38
20
4.python内存管理原理
内存中两个特殊的区域：栈、堆
栈：栈中的内存是系统自动管理(内存的开辟和内存的释放)
--作用域结束，内存就释放
堆：堆中的内存都需要写程序去开辟和释放的(python中这个过程自动化)
原理：堆中的数据到底是什么时候释放的
看一个对象有几个引用，当一个对象没有引用的时候，值对应的内存空间就会被释放
(引用机制)
引用:存储对象地址的变量
删除对象的唯一引用，对象就会被销毁
5.封装：
05-包的使用.py
对一个个功能的封装-->用函数
对多个功能的封装-->模块和类
对数据进行封装-->类或者字典
对多个类进行封装-->模块
对多个模块进行封装-->包
# 导入包
import package1
# 导入某个包中的模块
from package1 import My_math
# 导入某个包某个模块的某个函数和类
from package1.My_math import sum,Math
if __name__ == '__main__':
sum()
m=Math('小明')
print(m.name)
package1.My_math.sum()
My_math.sum()
#包package1
#My_math.py
def sum():
print('吃肉')
class Math:
def __init__(self,name):
self.name=name
if __name__ == '__main__':
pass
吃肉
小明
吃肉
吃肉
