- 继承
面向对象编程语言的一个主要功能就是“继承”。
继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。
（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()