python面向对象学习-类、继承、多重继承、初始化函数__init__、super方法

     本文主要涉及类的创建、私有、继承、检验父类的方法以及初始化函数即super方法的使用。
一、基础知识

#pyhton3.6
#类
class Person:
def setName(self,name):
self.name = name
def getName(self):
return self.name
def greet(self):
print("hello,world! I'm %s." %self.name)
foo = Person()
bar = Person()
foo.setName('l sk')
bar.setName('a sl')
foo.greet()
foo.name

out[13]:hello,world! I'm l sk.
'l sk'

#私有
class Secretive:
def __inaccessible(self):
print ('But you cant see me ')
def accessible(self):
print ('the secret is ')
self.__inaccessible(
s = Secretive()
s._Secretive__inaccessible()

out[20]:But you cant see me

# 继承
class Filter:
def init(self):
self.blocked = [1]
def filter(self,sequence):
return [x for x in sequence if x not in self.blocked]
class SPAMFilter(Filter):
def init(self):
self.blocked = ['SPAM']
f = Filter()
f.init()
f.filter([1,2,3])
out[37]:[2, 3]

#子类
s = SPAMFilter()
s.init()
s.filter(['SPAM','fda'])
out[39]:['fda']

#检验一个类是否为另一个类的子类
issubclass(SPAMFilter,Filter)
out[43]:True

#查找类的父类
SPAMFilter.__bases__
out[44]:(__main__.Filter,)

#检验对象是否为类的实例
isinstance(s,SPAMFilter)
out[50]:True

#从两个父类中继承--多重继承
class Calcutor:
def calculate(self,expression):
self.value = eval(expression)
class Talker:
def talk(self):
print("this is :",self.value)
class TalkingCalculator(Calcutor,Talker):
print("two")
tc = TalkingCalculator()
tc.calculate('1+2')
tc.talk()
out[52]:this is : 3

二、含有初始化函数的继承
1如果子类没有定义自己的初始化函数，父类的初始化函数会被默认调用；
但是如果要实例化子类的对象，则只能传入父类的初始化函数对应的参数，否则会出错
主要作用是要求用户在实例化对象的时候提供初始化函数里面的相应参数

#pyhton3.6
class Parent(object):
def __init__(self,data):
self.data = data
print("create an instance of:",self.__class__.__name__)
print("data attribute is: ",self.data)
class Child1(Parent):
pass
c1 = Child1("init Child")
out[58]:create an instance of: Child1
data attribute is:  init Child
c2 = Child1()  #不传参数报错
out[60]:TypeError: __init__() missing 1 required positional argument: 'data'

1. 如果子类定义了自己的初始化函数，而没有显示调用父类的初始化函数，则父类的属性不会被初始化。

#pyhton3.6
class Child2(Parent):
def __init__(self):
print("i have __init__")
c2 = Child2()
out[60]:i have __init__

1. 如果子类定义了自己的初始化函数，显示调用父类，子类和父类的属性都会被初始化

#pyhton3.6
class Child3(Parent):
def __init__(self):
print ("i have __init__")
super(Child3,self).__init__("data from Child3,but __init__ from parent")

c3 = Child3()
out[60]:i have __init__
create an instance of: Child3
data attribute is:  data from Child3,but __init__ from parent

三、super使用
在子类中，一般会定义与父类相同的属性（数据属性，方法），从而来实现子类特有的行为。也就是说，子类会继承父类的所有的属性和方法，子类也可以覆盖父类同名的属性和方法。有时候可能需要在子类中访问父类的一些属性：

#pyhton3.6
class Parent_super(object):
def fun(self):
print ("this fun is from parent")
class Child4(Parent_super):
def fun(self):
print("this fun is from child")
super(Child4,self).fun()
# super(Child4,self).fun()可以理解为：首先找到Child4的父类Parent_super，然后调用父类的fun()方法，
# 同时将Child的实例self传递给foo方法
child_super = Child4()
child_super.fun()
out[69]:this fun is from child
this fun is from parent