怎么用python输面向对象_python 之面向对象

继承粗体文本

标签(空格分隔)： 继承

什么是继承：

继承是指类与类之间的关系，是一种什么“是”什么的关系，继承的功能之一就是用来解决代买重用问题，继承是一种创建新类的方式，在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('课程名称 课程价格 可传给你周期'%(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: Age:' %(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: Age:' %(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

就是一些东西无法通过属性直接访问的，所以就定义一个方法，然后呢，我们用户又不懂什么方法不方法的，用户要按照属性一个的访问，所以这时候就用到了装饰器；