继承粗体文本
标签(空格分隔): 继承
什么是继承:
继承是指类与类之间的关系,是一种什么“是”什么的关系,继承的功能之一就是用来解决代买重用问题,继承是一种创建新类的方式,在python中,新建的类是可以继承多个父类,父类又可以成为基类或者超类,新建的类称为派生类或者子类;
- python中的继承分为:单继承和多继承:
派生
派生:是在继承中,子类有自己的特点,有自己的东西,即使是同一个方法,子类也可以有自己的特色;
继承的实现原理:
继承的原则:
深度优先,广度优先;
子类继承后,对方法重写
如果子类中有的方法,并且重写了,在实例化的时候,还是先用子类的方法,如果子类找不到就用,继承来的;
- 继承是指的类与类之间的关系;
例如:选课系统:
选课系统里面:有老师,学生,这些可以定义为类;
class Teacher:
school ='luffycity'
def __init__(self,name,age,sex,level,salary):
self.name=name
self.age=age
self.sex=sex
self.level=level
self.salary=salary
def teach(self):
print('%s is teaching '%self.name)
class Student:
school ='luffycity'
def __init__(self,name,age,sex,class_time):
self.name=name
self.age=age
self.sex=sex
self.class_time=class_time
def learn(self):
print(%s is learning '%self.name)
上述代码会发现我们这里面有很多的重复代码,会有很多的重复的代码,所以针对类之间的重复的代码,我们可以使用继承,把相同的功能,封装,然后继承,如上述我们可以,定义一个people,然后老师和学生继承就好了;
so:如下代码;
class People:
school = 'luffycity'
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
class Teacher(People):
def __init__(self,name,age,sex,level,salary):
super().__init__(name,age,sex)
self.level=level
self.salary=salary
def teach(self):
print('%s is teaching '%self.name)
class Student:
school ='luffycity'
def __init__(self,name,age,sex,class_time):
super().__init__(name,age,sex)
self.class_time=class_time
def learn(self):
print(%s is learning '%self.name)
teacher1 = Teacher('www',18,'male',10,3000)
student1=Student('zhangsan',28,'feamal','18:34:45')
如上的代码如果:老师有课程,课程周期,课程价格的属性的时候,怎么办呢,代码如下:我们可以给__init__增加属性
class People:
school = 'luffycity'
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
class Teacher(People):
def __init__(self,name,age,sex,level,salary,course_name,course_price,course_period):
super().__init__(name,age,sex)
self.level=level
self.salary=salary
self.course_name=course_name
self.course_price=course_price
self.course_period=course_period
def teach(self):
print('%s is teaching '%self.name)
class Student:
school ='luffycity'
def __init__(self,name,age,sex,class_time):
super().__init__(name,age,sex)
self.class_time=class_time
def learn(self):
print(%s is learning '%self.name)
teacher1 = Teacher('www',18,'male',10,3000,'python',3000,'dkkd')
teacher1 = Teacher('aaa',18,'male',10,3000,'python',3000,'dkkd')
如上述的代码会有很多,关于课程的信息,写了很多重复的代码;
这样我们可以把课程单独的定义一个类:
class People:
school = 'luffycity'
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
class Teacher(People):
def __init__(self,name,age,sex,level,salary,):
super().__init__(name,age,sex)
self.level=level
self.salary=salary
def teach(self):
print('%s is teaching '%self.name)
class Student:
school ='luffycity'
def __init__(self,name,age,sex,class_time):
super().__init__(name,age,sex)
self.class_time=class_time
def learn(self):
print(%s is learning '%self.name)
class Course:
def __init__(self,course_name,course_price,course_period)
self.course_name =course_name
self.course_price=course_price
self.course_period =course_period
def tell_info(self):
print('课程名称<%s> 课程价格<%s> 可传给你周期<%s>'%(self.course_name,self.course_price,self.course))
teacher1.course.tell_info()
这就是组合
teacher1 =Teacher('alex',18,'male',10,3000,)
teacher1.course='python'
teacher2.course='python'
### 多态
多态指的是一类事物有多种形态,比如动物有多种形态:人,狗,猪
``` python
import abc
class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
@abc.abstractmethod
def talk(self):
pass
class People(Animal): #动物的形态之一:人
def talk(self):
print('say hello')
class Dog(Animal): #动物的形态之二:狗
def talk(self):
print('say wangwang')
class Pig(Animal): #动物的形态之三:猪
def talk(self):
print('say aoao')
研究多态,就是研究同一种事物多种状态,
多态性:指的是可以在不考虑实例的类型的情况下,而直接使用对象,
peo1=People()
dog1=Dog()
pig1=Pig()
peo1.talk()
dog1.talk()
pig1.talk()
以上的多态性,指的是动态的多态性,多态性,不用考虑具体的实例类型,就可以直接用;
def func(animal):
animal.talk()
func(peo1)
func(pig1)
func(dog1)
二 为什么要用多态性(多态性的好处)
其实大家从上面多态性的例子可以看出,我们并没有增加什么新的知识,也就是说python本身就是支持多态性的,这么做的好处是什么呢?
1.增加了程序的灵活性
以不变应万变,不论对象千变万化,使用者都是同一种形式去调用,如func(animal)
2.增加了程序额可扩展性
通过继承animal类创建了一个新的类,使用者无需更改自己的代码,还是用func(animal)去调用
Python崇尚鸭子类型,即‘如果看起来像、叫声像而且走起路来像鸭子,那么它就是鸭子’
python程序员通常根据这种行为来编写程序。例如,如果想编写现有对象的自定义版本,可以继承该对象
也可以创建一个外观和行为像,但与它无任何关系的全新对象,后者通常用于保存程序组件的松耦合度。
例1:利用标准库中定义的各种‘与文件类似’的对象,尽管这些对象的工作方式像文件,但他们没有继承内置文件对象的方法
#二者都像鸭子,二者看起来都像文件,因而就可以当文件一样去用
class TxtFile:
def read(self):
pass
def write(self):
pass
class DiskFile:
def read(self):
pass
def write(self):
pass
例2:序列类型有多种形态:字符串,列表,元组,但他们直接没有直接的继承关系
#str,list,tuple都是序列类型
s=str('hello')
l=list([1,2,3])
t=tuple((4,5,6))
#我们可以在不考虑三者类型的前提下使用s,l,t
s.__len__()
l.__len__()
t.__len__()
len(s)
len(l)
len(t)
封装
从封装本身的意思去理解,封装就好像是拿来一个麻袋,把小猫,小狗,小王八,还有alex一起装进麻袋,然后把麻袋封上口子。照这种逻辑看,封装=‘隐藏’,这种理解是相当片面的
如何实现隐藏:
- 在python中用双下划线开头的方式将属性隐藏起来(设置成私有的)
class A:
__N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N
def __init__(self):
self.__X=10 #变形为self._A__X
def __foo(self): #变形为_A__foo
print('from A')
def bar(self):
self.__foo()
print('from bar')
#只有在类内部才可以通过__foo的形式访问到.
#A._A__N是可以访问到的,即这种操作并不是严格意义上的限制外部访问,仅仅只是一种语法意义上的变形
注意:以上的__N是隐藏的属性,注意python里面,以__开头的是隐藏,以__开头,__结尾是python内置的属性和方法,这点大家切记!,不要搞混了;
变形的特点:
1.外部无法直接访问obj.__attrName
2.在类的内部可不可以obj.__AttriName,答案是可以的
3.子类无法覆盖父类__开头的属性;(因为他两个不是一个名字)
封装的意义
1.封装数据属性:明确的区分内外
class People:
def __init__(self,name,age):
self.__name =name
self.__age=age
p=People('egon',18)
P.__name
数据属性分装之后外部是不可以访问的,在内部是可以,但是外部可以间接的访问,我们可以在类的内部开一个接口,通过接口访问,
class People:
def __init__(self,name,age):
self.__name =name
self.__age=age
def tell_info(self):
print('Name:<%s> Age:<%s>' %(self.__name , self.__age))
p=People('egon',18)
p.tell_info()
如上述的代码,我们把隐藏的属性放在:tell_info()中,外部的实例化对象,要想访问,就通过实例对象.tell_info()这种方法,这就要通过接口方法来访问的,方便快捷;
2.同样上述的代码,用户不能对name,age直接进行修改了,我们需要开一个接口可以供用户进行修改;
class People:
def __init__(self,name,age):
self.__name =name
self.__age=age
def tell_info(self):
print('Name:<%s> Age:<%s>' %(self.__name , self.__age))
def set_info(self,name,age):
if not isinstance(name,str):
print("名字是字符串")
return
if not isinstance(age,str):
print("年龄是字符串")
return
self.__name =name
self.__age=age
p=People('egon',18)
p.tell_info()
P.set_info('EGON',38)#这里我们用的开的接口来修改的
P.set_info('egon','12')
- 这就是我们数据属性的封装,明确的区分内外,控制外部对影藏属性的操作行为;
封装方法的目的
- 为了:隔离复杂度;
例如我有一个取款的例子:
class ATM:
def __card(self):
print('插卡')
def __auth(self):
print('用户认证')
def __input(self):
print('输入取款金额')
def __print——bill(self):
print('打印账单')
def __take_money(self):
print('取款')
def withdraw(self):
self.__card()
self.__auth()
self.__input()
self.__print_bill()
self.__take_money()
a=ATM()
a.withdraw()
>* 如上述的代码可以看出,我们外部的实例通过,withdraw可以访问完全;
封装与扩展性:
以前我们说过:面向对象的优点有:可扩展性高,其实封装也是可扩展性的高的一个方面;
class Room:
def __init__(self,namek,owner,height,weight,length)
self.name = name
self.owner=owner
#如果只想让用户访问:房间的长度和宽度,这里我们就可以把宽度和长度变为隐藏;
self.__weight=weight
self.__length=length
r=Room('房间','wo',10,10)
1.如果问题来了,我们要只想访问房间的面积而不是房间的属性呢?
class Room:
def __init__(self,namek,owner,height,weight,length)
self.name = name
self.owner=owner
#如果只想让用户访问:房间的长度和宽度,这里我们就可以把宽度和长度变为隐藏;
self.__weight=weight
self.__length=length
def tell_area(self):
return self._weight*self.__length
r=Room('房间','wo',10,10)
print(r.tell_area())
如上述我们使用者,只需要关心的是:r.tell_area()究竟里面的逻辑如何我们不用管,这就为我们提供了方便,类的扩展性;
- 如果计算房间的体积呢?
class Room:
def __init__(self,namek,owner,height,weight,length,height)
self.name = name
self.owner=owner
#如果只想让用户访问:房间的长度和宽度,这里我们就可以把宽度和长度变为隐藏;
self.__weight=weight
self.__length=length
self.__height=height
def tell_area(self):
return self._weight*self.__length*self.__height
r=Room('房间','wo',10,10)
print(r.tell_area())
同样对于使用者来说,他们不需关心内部的处理逻辑,他们只需要调用就好了;
property的使用:
例如:如下描述:
实现BMI指数程序:
class People:
def __init__(self,name,weiht,height):
self.name=name
self.weight=weigth
self.height=height
P=People('ll',1.81,75)
bmi=p.weight/(p.height ** 2)
#或者可以写成如下的:
p.bmi =p.weight / (p.height **2)
print(p.bmi)
问题:
如上述的方法bmi,虽然我们实现了,但是我们每次都要定义bmi,是不是很麻烦,而且bmi不是固定的,是随着人的身高体重变化的,而不是一成不变的,那么问题来了,我们怎么实现简单化呢?
- 这里我们可以把bmi,定义成为方法,然后放置在类里面 ,这样以后的实例只需要调用这个方法就好了,不用每次实例化去计算了;
class People:
def __init__(self,name,weiht,height):
self.name=name
self.weight=weigth
self.height=height
def bmi(self):
return self.weight/(p.height ** 2)
P=People('ll',1.81,75)
print(p.bmi())#bmi后边的()意味着调用函数
如上述的代码,对于用户而言,他把bmi看成指数,加()他们反而不懂,或者说是会误解,对于用户他们就把指数bmi当成了一个名词,而不是()的方法;用户最终想实现的其实就是p.bmi
所以要实现p.bmi我要在class类里面,bmi()上边加个,装饰器:
class People:
def __init__(self,name,weiht,height):
self.name=name
self.weight=weigth
self.height=height
@property
def bmi(self):
return self.weight/(p.height ** 2)
P=People('ll',1.81,75)
print(p.bmi())#bmi后边的()意味着调用函数
补充一个知识点:property的使用:
比如自己定义一个property的用法;
class People:
def __init__(sefl,name):
self.__name=name
p =People('egon')
如上述我们肯定获取不到名字怎么办呢?
答案:我们肯定要通过接口来获取名字
class People:
def __init__(sefl,name):
self.__name=name
def get_name(self):
return self.__name
p =People('egon')
print(p.get_name())
然后对于使用者而言:他们就想访问属性而已,不用通过方法,要不然用户会懵逼;
那么问题来了,我们怎么来搞呢?(答案只有加装饰器了,如下图代码)
class People:
def __init__(sefl,name):
self.__name=name
@property
def get_name(self):
return self.__name
p =People('egon')
print(p.name)
这里我们通过property来说明,另一个property的用法:
class People:
def __init__(sefl,name):
self.__name=name
@property
def name(sefl):
return self.__name
@name.setter
def name(self,val):
if not isinstance(val,str):
print('名字必须是字符串类型的')
return
self.__name =val
@name.deleter
def name(self):
print('不让删除')
p =People('egon')
p.name #这里触发的是第一个,return self.__name
p.name='DDD'#这个是访问行为,触发的是def name(self,val),如上述的修改的逻辑
del p.name#删除属性
如上述所述:我们之要掌握,不需要掌握太多;
@property
def name(sefl):
return self.__name
- 总结,如果说一些东西不能像属性一样,需要定一个方法来实现,但是用户又想把这些当做属性来访问,而不是方法,()之类的东西,所以要这里我们需要使用property装饰之类东西来满足需要;
这里上述的
@property
def name(sefl):
return self.__name
- 就是一些东西无法通过属性直接访问的,所以就定义一个方法,然后呢,我们用户又不懂什么方法不方法的,用户要按照属性一个的访问,所以这时候就用到了装饰器;