标签：lis 区分 image file 面向 利用 扩展性 BMI 取名字
标签（空格分隔）： 继承
什么是继承：
继承是指类与类之间的关系，是一种什么“是”什么的关系，继承的功能之一就是用来解决代买重用问题，继承是一种创建新类的方式，在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‘
```；
多态指的是一类事物有多种形态，比如动物有多种形态：人，狗，猪
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())同样对于使用者来说，他们不需关心内部的处理逻辑，他们只需要调用就好了；
例如：如下描述：
实现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
- 就是一些东西无法通过属性直接访问的，所以就定义一个方法，然后呢，我们用户又不懂什么方法不方法的，用户要按照属性一个的访问，所以这时候就用到了装饰器；
标签：lis 区分 image file 面向 利用 扩展性 BMI 取名字
原文地址：https://www.cnblogs.com/surewing/p/9733732.html
