Python学习之单继承与多继承

1. 继承

面向对象编程语言的一个主要功能就是“继承”。

继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

（1） 单继承：python同时支持类的继承。如果一种语言不支持继承，类就没什么意义。

类还允许派生，即用户可以创建一个子类，它也是类，而且继承父类（即基类）的所有特征和属性。

创建派生类的语法格式为：

class DerivedClassName(BaseClassName):

<statement-1>

...

<statement-N>

基类名BaseClassName必须与派生类定义在一个作用域内。除了用类名，还可以用表达式。

例如：单继承举例：

class people:

#定义基本属性

name=''

age=0

#定义私有属性，私有属性在类外部无法直接进行访问

__weight=0

#定义构造方法

def __init__(self,n,a,w):

self.name=n

self.age=a

self.__weight=w

def speak(self):

print("%s says:I am %d years old"%(self.name,self.age))

#单继承

class student(people):

grade=''

#调用父类的构造函数

def __init__(self,n,a,w,g):

people.__init__(self,n,a,w)   #student继承并使用people的__init__函数

self.grade=g                   #不同于people的参数g

#重写父类的方法

def speak(self):

#显示student的信息

print("%s says:I am %d years old,I am in Grade %d."%(self.name,self.age,self.grade))

s=student('Tom',10,90,3)        #实例化student类

s.speak()                        #显示student的speak方法

#运行结果：Tom says:I am 10 years old,I am in Grade 3.

（2） 多继承：某个类继承了多个父类

多继承的类定义语法格式如下：

class DerivedClassName(Base1,Base2,Base3):

<statement-1>

...

<statament-N>

#注意解析类属性的规则是，顺序是深度优先，从左到右。因此，如果在DerivedClassName(示例中的派生类)中没有找到这个属性，就会搜索Base1,然后递归的搜索其基类，如果最终没有找到，就搜索Base2,依次类推。深度优先不区分属性继承自基类还是直接定义。

例如：class people:

#定义基本属性

name=''

age=0

__weight=0

#定义构造方法

def __init__(self,n,a,w):

self.name=n

self.age=a

self.__weight=w

def speak(self):

print("%s says:I am %d years old"%(self.name,self.age))

#单继承

class student(people):

grade=''

#调用父类的构造函数

def __init__(self,n,a,w,g):

people.__init__(self,n,a,w)   #student继承并使用people的__init__函数

self.grade=g

def speak(self):

print("%s says:I am %d years old,I am in Grade %d."%(self.name,self.age,self.grade))

class speaker():

topic=''

name=''

def __init__(self,n,t):

self.name=n

self.topic=t

def speak(self):

print("I am %s,I am a speaker,my topic is %s"%(self.name,self.topic))

class sample(speaker,student):

a=''

def __init__(self,n,a,w,g,t):

student.__init__(self,n,a,w,g)

speaker.__init__(self,n,t)

test_1=sample("Tom",12,90,3,"One World One Dream")

test_1.speak()

#执行结果：I am Tom,I am a speaker,my topic is one World One Dream.

（3） 补充：

1.方法重写

如果父类方法的功能不能满足需求，可以在子类里重写父类的方法。

例如：

class Parent:               #定义父类

def myMethod(self):

print('调用父类方法')

class Child(Parent):          #定义子类

def myMethod(self):

print('调用子类方法')

Child_1=Child()                     #子类实例

Child_1.myMethod()                      #子类调用重写方法

输出：调用子类方法

2. if__name__=’__main__’的作用

这条语句的意思是，让程序员写的脚本模块既可以导入到别的模块中调用，也可以在模块中自己执行。

例如 #y1htext.py

def main():

print('hello world,I am in %s now.' %__name__)

if __name__=='__main__':

main()                      运行结果：hello world,I am in __main__now.

在这个文件中定义了一个main()函数，如果执行该.py文件，则if语句中的内容被执行，成功调用main()函数。

从另一个模块导入该模块，这个模块的名字是test1.py

#test1.py

from y1htext import main

mian()         #相同的运行结果

3. 运算符重载:用于新类的运算符的实现。

运算符重载是针对新类型数据的实际需要，对原有运算符进行适当的改造，一般来说，重载的功能应当与原有功能相类似，不能改变原运算符的操作对象个数，同时至少要有一个操作对象是自定义类型。

Python支持运算符重载，它的运算符重载就是通过重写这些python内建方法来实现的。这些内建方法都是以双下划线开头和结尾的，Python通过这种特殊的命名方式来拦截操作符，以实现重载。

例如：+用__add__方法，+=用__iadd__方法，...,*用__mul__方法等

当Python的内置操作运用于类对象时，Python会去搜索并调用对象中指定的方法来完成操作。运算符重载是通过创建运算符函数实现的，运算符重载实际是一个函数，所以运算符的重载实际上是函数的重载。

例如：运算符重载

class Computation():

def __init__(self,value):

self.value=value

def __add__(self,other):

return(self.value+other.value)

def __sub__(self,other):

return(self.value-other.value)

c1=Computation(10)

c2=Computation(10)

print(c1+c2)

print(c1-c2)  #“-”在作用于类对象，实现减法运算符的重载

说明：如果类实现了__add__的方法，当类的对象出现在“+”运算符中时，会调用这个方法；如果类实现了__sub__方法，当类的对象出现在“-”运算符中时，会调用这个方法。重载这两个方法就是可以在普通的类对象上添加“+”和“-”运算。

（4） isinstance函数（Python语言的一个内建函数）

语法：isinstance(object,type) 函数是Python语言的一个内建函数

作用是：判断一个对象或者变量是否是一个已知的类型。

①　针对类来说，如果参数是object是type类的实例（判断一个对象是否为该类的实例）或者object是type类的子类的一个实例，则返回True.如果object不是一个给定类型的对象，则返回结果是False.

class objA:

pass

class objB(objA):

pass

A=objA()

B=objB()

print(isinstance(A,objA))

print(isinstance(B,objA))

print(isinstance(A,objB))

print(isinstance(B,objB))

②　针对变量来说，第一个参数(object)为变量，第二个参数（type）为类型名或者由变量名组成的一个元组（如（int,list,float））,其返回值为布尔型（Ture或False）.若第一个参数为一个元组，则变量类型与元组类型名之一相同时即返回True.

a=2

print(isinstance(a,int))

print(isinstance(a,str))

print(isinstance(a,(str,int,list)))

（5） super()函数

当存在继承关系的时候，有时候需要在子类中调用父类的方法。如果修改父类名称，那么在子类中会涉及多处修改。

Python引入了super（）机制，语法格式如下：

super(type[,object-or-type])

例如：

class A(object):

def __init__(self):

print('enter A')

print('leave A')

class BA.:    #B继承A

def __init__(self):

print("enter B")

super(B,self).__init__()   #python2对其理解为：super(B,self)首先找到B的父类（就是类A），然后把类B的对象self转换为类A的对象，然后被转换的类A对象调用自己的__init__函数。Python3.x可以不加参数而直接写为super().__init__，并且可以像父类中的属性赋值。

print("leave B")

b=B()