标签：div 时间 charm iam 语言 mat 计算 方法 访问
继承
python讲师，
名字、性别、所在小组
自我介绍
授课：打开pycharm，输入一些代码，讲解知识。。。
java 讲师
名字，性别，所在小组
自我介绍
授课：打开eclipse，输入代码，讲解知识。。。
class pythonteacher:
def __init__(self,name,gender,group):
self.name=name
self.gender=gender
self.group=group
def introduce(self):
print("正在做自我介绍：我叫{}，{}，所在小组是{}".format(self.name,self.gender,self.group))
def teach(self):
print("打开pycharm")
print("输入代码")
print("讲解")
class javateacher:
def __init__(self,name,gender,group):
self.name=name
self.gender=gender
self.group=group
def introduce(self):
print("正在做自我介绍：我叫{}，{}，所在小组是{}".format(self.name,self.gender,self.group))
def teach(self):
print("打开eclipse")
print("输入代码")
print("讲解")
"""
问题：两个类非常相似，代码大量重复，当修改某一个代码的时候，会造成大量的修改。
"""
"""
一、继承的定义
继承实现的是一种[一般]和[特殊]之间的关系
场合：如果两个类型之间存在一般和特殊的关系，水果、苹果、香蕉
一般类：父类
特殊类：子类
当子类继承父类的时候，子类可以继承父类中所定义成员（类属性、类方法、实例属性、实例方法、静态方法）
跟自己拥有这些成员一样去使用
"""
二、 继承的实现
1. 继承方式：显示继承，隐式继承
(1) 显示继承
# 语法class B(父类)：
# pass
class Fruit:
def show(self):
print("水果")
class Apple(Fruit):
pass
f=Fruit()
f.show()
a=Apple()
a.show()
# 继承的意义
# 父类有一些方法（产业），子类可以直接拿来用。
(2) 隐式继承
# 在python中，如果没有写明()里去继承哪一个父类，叫隐式继承，继承的是object这个类
2. 两个内建函数
# 用来判断父子关系或者是否属于某个类的对象
# isinstance 用来判断object对象是不是某一个type类(包含了父类)产生,返回值布尔类型
isinstance(object,type)
isinstance(f,Fruit)
isinstance(a,Fruit)
isinstance(a,Apple)
isinstance(f,Apple) #False
# issubclass(a,b) 判断a是不是b的子类，返回值布尔类型
# 自己也算是自己的子类
# issubclass(子类，父类)
issubclass(Apple,Fruit)
issubclass(Fruit,Fruit)
issubclass(Apple,object)
issubclass(Fruit,object)
# 应用场景
# 学生Student
class Student:
pass
class student_little(Student):
pass
class student_middle(Student):
pass
class student_big(Student):
pass
c=student_little()
# 当我需要判断是不是学生类型才行？
# type(p)==Student or type(p)==student_big
print(issubclass(type(c),Student))
print(isinstance(c,Student))
3. 成员的继承
# 类属性、类方法、实例属性、实例方法、静态方法
(1). 类属性、类方法、实例方法、静态方法
class Bike:
brand="飞鸽"
@classmethod
def copybike(cls):
print("仿造一辆自行车")
def bybike(self):
print("骑自行车")
print("双手扶把...")
@staticmethod
def sm():
print("这是static方法")
class Sonbike(Bike):
def bybike(self):
print("双手扶把")
print("骑自行车")
pass
s=Sonbike()
# 调用类属性和方法
print(Sonbike.brand)
sonbike.copybike()
# 实例方法和静态方法
s.bybike()
Sonbike.sm()
(2) 方法的重写
# 当子类继承父类时候，子类的方法需要覆盖父类的方法，叫做方法的重写
# 当子类对象访问方法的时候，如果子类重写了父类的方法，会访问子类自己的方法，
# 否则（没有重写），那么会访问父类的方法
class bike:
brand="飞鸽"
@classmethod
def copybike(cls):
print("仿造一辆自行车")
def bybike(self):
print("骑自行车")
print("双手扶把...")
@staticmethod
def sm():
print("这是static方法")
class sonbike(bike):
# 对父类的bybike进行重写
def bybike(self):
print("子类的bybike方法")
# print("骑自行车")
# print("双手扶把")
super().bybike()
s=sonbike()
# 调用类属性和类方法
print(sonbike.brand)
sonbike.copybike()
# 实例方法和静态方法
s.bybike()
sonbike.sm()
# 当父类的方法中有部分内容是可以被重用，可以super().父类的方法
# super()代表父类产生的对象
(3) 实例属性的继承
class bike:
def __init__(self):
self.color="蓝色"
self.size=24
brand="飞鸽"
@classmethod
def copybike(cls):
print("仿造一辆自行车")
def bybike(self):
print("骑自行车")
print("双手扶把...")
@staticmethod
def sm():
print("这是static方法")
class sonbike(bike):
def __init__(self):
# self.color="白色"
self.ischangev=True
super().__init__()
# 对父类的bybike进行重写
def bybike(self):
print("子类的bybike方法")
# print("骑自行车")
# print("双手扶把")
super().bybike()
s=sonbike()
# 调用类属性和类方法
print(sonbike.brand)
sonbike.copybike()
# 实例方法和静态方法
s.bybike()
sonbike.sm()
print("sonbike",s.color)
print(s.color)
print(s.size)
print(s.ischangev)
class People:
# 初始化函数
def __init__(self,name,age,weight):
self.name=name
self.age=age
self.weight=weight
#对象函数
def sleep(self):
print("这是People类中的sleep函数")
# 根据工作时间，计算体重是否减少的功能函数
def work_time(self,time):
# 如果工作时间在8-12小时范围内，体重-2
# 如果工作时间超过12小时，体重-5
if 8<time<=12:
#体重-2
self.weight-=2
elif time>12:
# 体重-5
self.weight-=5
# 声明Man类，继承自People类
class Man(People):
# Man类中的初始化函数
def __init__(self,name,age,sex,weight,height):
# 调用父类的初始化，将父类中的属性进行初始化，并且将self对象作为参数传递到父类的初始化函数中
super(Man,self).__init__(name,age,weight)
# 初始化当前类拥有的属性
self.sex=sex
self.height=height
def somking(self):
print("这是Man中smoking函数")
# 1. 完全重写一个sleep函数
def sleep(self):
# 在这个sleep函数中，可以执行和父类完全不同的功能
print("这是一个Man类中的sleep函数")
# 2. 重写work_time函数
def work_time(self,time):
# 2.1 根据实际计算体重
# 先去执行父类中work_time()函数，计算体重
super(Man, self).work_time(time)
# 2.2 根据体重 判断身材是否标准
# 再去添加额外的功能代码
# 身高-105=体重 身材标准
# 身高-105>体重 身材偏瘦
# 身高-105<体重 身材偏胖
result=self.height-105
if result>self.weight:
print("身材偏瘦")
elif result<self.weight:
print("身材偏胖")
else:
print("身材标准")
# 创建People对象p1
p1=People("张三",22,180)
p1.sleep()
p1.work_time(13)
print("p1工作之后的体重：{}".format(p1.weight))
m=Man("李四",23,"男",75,180)
m.sleep()
m.somking()
# m在执行work_time函数时，除了要计算体重之外，还要判断身材是否标准
m.work_time(9)
print("m工作之后的体重：{}".format(m.weight))
4. 私有属性的继承
class Father:
def __m(self):
print("这是父类的私有方法")
class Son(Father):
def p(self):
self._Father__m() # 不建议子类中使用“真名”去访问
son=Son()
son.p()
5. 多继承
# python支持多继承(多个父类)
# 正方形 特殊的矩形
# 正方形 特殊的菱形
class Rectangle:
def area(self):
print("这是求矩形面积的方法")
class Diamond:
def area(self):
print("这是求菱形面积的方法")
# super().area()
class Square(Rectangle,Diamond):
def t(self):
# self.area()
# Rectangle.area(self)
super().area()
s=Square
s.t()
d=Diamond()
d.area()
# 第一种方式：可以使用继承顺序条件
# 第二种放肆，在调用方法的时候，可以指定父类.方法
# 继承：MRO原则：深度优先，一个分支一个分支的去找
# 如果一个对象调用方法是其中一个父类的方法，如果父类中没有继续向上继承的父类，也没有对应的方法
# 按照MRO原则会去找原来子类平行的父类中方法
多态：
运行期：真正的去执行py文件
编译期：py被解释器翻译的时候
python鸭子类型，动态，强类型语言
多态体现的是变量、属性、对象来说，体现了不同形式。
class Father:
def talk(self):
print("father talk")
class Son(Father):
def talk(self):
print("son talk")
f=Father()
s=Son()
s.talk()
f.talk()
标签：div 时间 charm iam 语言 mat 计算 方法 访问
原文地址：https://www.cnblogs.com/ztx695911088/p/9085341.html
