面向对象四

面向对象：
继承：对于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法

举例：
#coding=utf-8
class Parent(object): # define parent class
parentAttr = 100
def init(self):
“父类构造方法，用于初始化工作”
print (“Calling parent constructor”)
def parentMethod(self):
print (‘Calling parent method’ )
def setAttr(self, attr):
Parent.parentAttr = attr
def getAttr(self):
print (“Parent attribute :”, Parent.parentAttr)

class Child1(Parent): # define child1 class
def init(self):
“子类构造方法，用于初始化子类本身数据的工作”
print (“Calling child1 constructor”)
def childMethod(self):
print (‘Calling child1 method’ )
Parent.parentMethod(self) #调用基类的方法，所以要加上参数self

class Child2(Parent): # define child2 class
#没有实现__init__方法，则会调用基类的__init__方法
def childMethod(self):
print (‘Calling child2 method’ )
self.parentMethod() #子类调用自己从父类那继承过来的父类的方法

#开始执行#
print(“1”+"*"20)
c1 = Child1() # 实例化子类 1
print(“2”+""20)
c2 = Child2() # 实例化子类 2
print(“3”+""20)
c1.childMethod() # 调用子类1的方法
print(“4”+""20)
c2.childMethod() # 调用子类2的方法
print(“5”+""20)
c1.parentMethod() # 子类实例对象调用父类方法
print(“6”+"“20)
c1.setAttr(200) # 再次调用父类的方法
print(“7”+"”*20)
c1.getAttr() # 再次调用父类的方法

执行结果：
1********************
Calling child1 constructor
2********************
Calling parent constructor
3********************
Calling child1 method
Calling parent method
4********************
Calling child2 method
Calling parent method
5********************
Calling parent method
6********************
7********************
Parent attribute : 200

注意：如果基类构造方法需要传入参数时，创建子类的实例对象时，就必须传入对应的参数，否则子类不实现构造方法的话，调用基类的构造方法，会报参数数量不匹配的错。

子类调用基类方法
1）Parent.parentMethod(self)
2）self.parentMethod()

第一种是直接用父类的类名.方法名去调用父类的方法，但是需要注意的是，这种调用方法必须将self作为参数传进去并且作为第一个参数，表示指向这
个类的实例本身。这种方法多用于方法重写时。
第二种是直接用self去调用父类的方法，为什么可以这样调用呢？因为一旦子类继承了父类，那么子类就拥有父类所有的公有方法和属性，所以此时父类的方法和属性就相当于子类自己了，所以可以直接用self去直接调用实例的方法，而不用再传入self参数了。

调用父类的__init__方法
1）在子类构造方法中再写一次这些属性
2）直接调用父类的构造方法完成。当然我们一般采用第二种发法。

子类调用基类的构造函数有两种方法，基本语法如下：
1）super(subclassName, self).init( [parameter1[,parameter2…]])
2）superclassName.init(self, [parameter1[,parameter2…]])
注意：
两次参数列表中的self参数都是必不可少的，如果基类的构造方法中有除了self参数外别的参数，调用时，也必须传入同等数量、同等类型的参数。当子类不定义自己的构造方法时，默认会自动调用父类的构造方法。Python中super函数只能在构造方法中使用。

举例：
#encoding=utf-8
class A(object):
name=’’
def init(self):
self.name=‘fosterwu’
def getName(self):
return 'A ’ + self.name

class C(A):
def init(self):
super(C, self).init() #调用基类构造方法

if name==‘main’:
c = C()
print(c.getName())

执行结果：
A fosterwu

举例2：
#coding=utf-8
class UniversityMember(object):
def init(self, name, age):
self.name = name
self.age = age
def getName(self):
return self.name
def getAge(self):
return self.age

class Student(UniversityMember):
def init(self, name, age, sno, Department):
#注意要显示调用父类构造方法，并传递参数self
UniversityMember.init(self, name, age)
self.sno = sno
self.Department = Department
def getSno(self):
return self.sno
def getDepartment(self):
return self.Department

s = Student(“fosterwu”, “18”, “CS”, 18)
print (s.name, s.age)
s.name = ‘superman’
print (s.name)
print (s.getName())
print (s.getAge())

执行结果：
fosterwu 18
superman
superman
18

类间的关系判断
方法：使用issubclass()或者isinstance()方法来检测类之间的关系。
1）issubclass() 函数
描述：issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类。
语法：issubclass(class, classinfo)
参数：class – 类；classinfo – 类
返回值：如果 class 是 classinfo 的子类返回 True，否则返回 False。
举例：
#coding=utf-8
class UniversityMember(object):
pass
class Student(UniversityMember):
pass
if issubclass(Student, UniversityMember) :
print (“Student类是UniversityMember类的子类”)
else :
print (“Student类不是UniversityMember类的子类”)

执行结果：
Student类是UniversityMember类的子类

2）isinstance()函数
描述：isinstance() 函数来判断一个对象是否是一个已知的类型；isinstance() 会认为子类是一种父类类型，考虑继承关系。
语法：isinstance(object, classinfo)
参数：object – 实例对象；classinfo – 可以是直接或间接类名、基本类型或者由它们组成的元组。
返回值：如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。
举例：
#coding=utf-8
class UniversityMember(object):
pass
class Student(UniversityMember):
pass

vm = UniversityMember() #创建父类的实例
s = Student() #创建子类的实例
if isinstance(vm, UniversityMember) :
print (“vm是UniversityMember类或其子类的实例对象”)
else :
print (“vm不是UniversityMember类或其子类的实例对象”)

if isinstance(s, UniversityMember) :
print (“s是UniversityMember类或其子类的实例对象”)
else :
print (“s不是UniversityMember类或其子类的实例对象”)

执行结果：
vm是UniversityMember类或其子类的实例对象
s是UniversityMember类或其子类的实例对象

多重继承
Python支持多重继承，也就是一个子类可以有多个父类，定义子类时，括号中写多个父类，并且父类间用逗号隔开。
多重继承特点：
1）多重继承中，子类在没有定义自己的构造方法时，以第一个父类为中心
2）如果子类重新定义了自己的构造方法，就不会调用父类的构造方法。但如果仍想调用父类的构造方法，这个时候可以调用指定父类的构造方法，调用方式为：superclassName.init(self, [parameter1[,parameter2…]] )
3）如果父类中有同名的方法时，通过子类的实例对象去调用的该方法也是第一个父类中的方法。调用方式Parent.parentMethod(self)

Python的类可以继承多个类，Java和C#中则只能继承一个类

python数据结构之图深度优先和广度优先：
首先有一个概念：回溯

回溯法(探索与回溯法)是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。

深度优先算法：

（1）访问初始顶点v并标记顶点v已访问。
（2）查找顶点v的第一个邻接顶点w。
（3）若顶点v的邻接顶点w存在，则继续执行；否则回溯到v，再找v的另外一个未访问过的邻接点。
（4）若顶点w尚未被访问，则访问顶点w并标记顶点w为已访问。
（5）继续查找顶点w的下一个邻接顶点wi，如果v取值wi转到步骤（3）。直到连通图中所有顶点全部访问过为止。

广度优先算法：

（1）顶点v入队列。
（2）当队列非空时则继续执行，否则算法结束。
（3）出队列取得队头顶点v；访问顶点v并标记顶点v已被访问。
（4）查找顶点v的第一个邻接顶点col。
（5）若v的邻接顶点col未被访问过的，则col入队列。
（6）继续查找顶点v的另一个新的邻接顶点col，转到步骤（5）。直到顶点v的所有未被访问过的邻接点处理完。转到步骤（2）

Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先
深度优先：
当类是经典类时，多继承情况下，会按照深度优先方式查找（py2才有）
广度优先：
当类是新式类时，多继承情况下，会按照广度优先方式查找

经典类和新式类，，新的必然包含了跟多的功能，也是之后推荐的写法，从写法上区分的话，如果 当前类或者父类继承了object类，那么该类便是新式类，否则便是经典类。

举例1：
class C1: #C1是经典类
pass
class C2(C1): #C2是经典类
pass

举例2：
class N1(object): #N1是新式类
pass
class N2(N1): #N2是新式类
pass

举例3：
class D:
def bar(self):
print (‘D.bar’)
class C(D):
def bar(self):
print (‘C.bar’)
class B(D):
def bar(self):
print (‘B.bar’)
class A(B, C):
def bar(self):
print (‘A.bar’)
a = A()
a.bar()

执行bar方法时

首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错

所以，查找顺序：A --> B --> C --> D

在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了

经典类：首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错

新式类：首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错

注意：在上述两种查找方法查找过程中，一旦找到，则寻找过程立即中断，便不会再继续找了

举例2：

-- coding:utf-8 --

class house(object):
def init(self, name):
print (“Calling house constructor”)
class car(object):
def init(self):
print (“Calling car constructor”)
class carHouse(house, car): #多重继承
pass
class busHouse(house, car) : #多重继承
def init(self) :
super(busHouse, self).init(“sr”) #这种方法只能调第一个父类的构造方法

c = carHouse(“ad”) #carHouse()没有构造函数，使用第一个父类的构造函数
print("*"*20)
b = busHouse()

执行结果：
Calling house constructor

---

Calling house constructor

举例3：

-- coding:utf-8 --

class house(object):
def init(self, name):
print (“Calling house constructor”)
class car(object):
def init(self):
print (“Calling car constructor”)
class carHouse(house, car): #多重继承
pass
class busHouse(house, car) : #多重继承
def init(self) :
car.init(self) #这种方法真正实现随意调用

c = carHouse(“ad”)
print("*"*20)
b = busHouse()

执行结果：
Calling house constructor

---

Calling car constructor

举例4：

-- coding:utf-8 --

class house(object):
def getHeight(self):
print (“调用house类的方法”)
class car(object):
def getHeight(self):
print (“调用car类的方法”)
class carHouse(house, car): #多重继承
def init(self) :
pass
def carHeight(self) :
self.getHeight() #这种方法默认调的也是第一个父类的方法

c = carHouse()
print(20*"*")
c.carHeight()

执行结果：
调用house类的方法

举例5：

-- coding:utf-8 --

class house(object):
def getHeight(self):
print (“调用house类的方法”)
class car(object):
def getHeight(self):
print (“调用car类的方法”)
class carHouse(house, car): #多重继承
def init(self) :
pass
def carHeight(self) :
car.getHeight(self) #真正实现了随心所欲的调取想调父类的方法

c = carHouse()
c.carHeight()

执行结果：
调用car类的方法