类的析构、继承
析构方法
实例被销毁的时候自动调用。网络编程用的多。
class Dog(object):
def __init__(self,name):
self.name = name
self.__weight = 100
def sayhi(self):
print('my wigth is ', self.__weight,)
def __del__(self):
print('del.........')
d = Dog('二哈')
del d #del.........
print('-------------------') #-------------------
del d 并没有真正的把这个对象删除，只是把对象的引用删除了。同时垃圾回收机制把一个没有引用的空间给删除了，在删除之前执行的__del()__.
继承
使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。
通过继承创建的类称作子类 或者派生类。
被继承的类称作基类、父类或者超类。
某些oop语言中，一个子类可以继承多个基类。但是，一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。
继承的实现有两种：实现继承和接口继承
1、实现继承是指基类的属性和方法而无需额外编码的能力
2、接口继承是指使用属性和方法的名称、但是子类必须提供实现的能力。也就是子类重构父类的方法。
使用继承时，需考虑两个类之间的关系是属于关系。
抽象类仅定义将由子类创建的一般属性和方法。
OO开发范式大致为：划分对象-》抽象类-》将类组织成为层次结构（继承和合成）->用类与实例进行设计和实现几个阶段。
简单的继承：
class Person(object):
def talk(self):
print('person is talking...')
class BlackPerson(Person): #继承Person这个类
pass
b = BlackPerson()
b.talk() #person is talking...
重新父类：
class Person(object):
def talk(self):
print('person is talking...')
class BlackPerson(Person):
def talk(self):
print('balabala...')
b = BlackPerson()
b.talk() #balabala...
重写了就调用自己的，没有重新就调用父类的。
如果父类有构造方法，子类继承父类之后也会继承父类的构造方法，如果子类重写了就不用父类的构造方法。
class Person(object):
def __init__(self,name,age):
self.name = name
self.age = age
def talk(self):
print('person is talking...')
class BlackPerson(Person):
def talk(self):
print('balabala...')
b = BlackPerson() #TypeError: __init__() missing 2 required positional arguments: 'name' and 'age'
b.talk()
继承了父类的构造方法，实例化的时候也必须要传递参数。
class Person(object):
def __init__(self,name,age):
self.name = name
self.age = age
def talk(self):
print('person is talking...')
class BlackPerson(Person):
def talk(self):
print('balabala...')
b = BlackPerson('jim',20)
b.talk() #balabala...
重写构造函数
class Person(object):
def __init__(self,name,age):
self.name = name
self.age = age
def talk(self):
print('person is talking...')
class BlackPerson(Person):
def __init__(self,name):
self.name = name
def talk(self):
print('balabala...')
b = BlackPerson('jim')
b.talk() #balabala...
子类重写父类构造，那么就会调用自己的构造，但是我又需要父类的构造函数，有些功能相同的代码不想重写。这个时候可以使用先继承在重构。
先继承在重构
class Person(object):
def __init__(self,name,age):
self.name = name
self.age = age
def talk(self):
print('person is talking...')
class WhitePerson(Person):
pass
class BlackPerson(Person):
def __init__(self,name,age,strength): #先继承，在重构 子类重构父类方法，实例化的时候参数都传到子类，self就是b
Person.__init__(self,name,age) #这里调用父类的构造方法 这里的self,name,age 都来自与子类
print(self.name,self.age) # jim 20
def talk(self):
print('balabala...')
b = BlackPerson('jim','20','500')
b.talk()
子类的实例传到父类，让父类赋值。
子类调用父类的方法
class Person(object):
def __init__(self,name,age):
self.name = name
self.age = age
def talk(self):
print('person is talking...')
class BlackPerson(Person):
def __init__(self,name,age,strength): #先继承，在重构 子类重构父类方法，实例化的时候参数都传到子类，self就是b
Person.__init__(self,name,age) #这里调用父类的构造方法 这里的self,name,age 都来自与子类
def talk(self):
Person.talk(self)
print('balabala...')
b = BlackPerson('jim','20','500')
b.talk() #person is talking... #balabala...
小练习：
算下学校老师和学生的注册人数，并打印用户信息。
class SchoolMember(object):
'''学校成员基类'''
member = 0 # 计数器
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
self.enroll()
def enroll(self):
'''注册'''
print('just enerolled a new school member [%s]'% self.name)
SchoolMember.member += 1 #实例本身有就调用本身的，没有就调用全局的
def tell(self):
print('----%s info-----'% self.name)
for k,v in self.__dict__.items():
print('\t',k,v)
def __del__(self):
print('%s退学了..'%self.name)
SchoolMember.member -= 1
class Teacher(SchoolMember):
'''讲师类'''
def __init__(self,name,age,sex,salary,course):
SchoolMember.__init__(self,name,age,sex)
self.salary = salary
self.course = course
def teaching(self):
print('Teacher [%s] is teaching [%s]'%(self.naem,self.course))
class Student(SchoolMember):
'''学生类'''
def __init__(self,name,age,sex,course,tuition):
SchoolMember.__init__(self,name,age,sex)
self.course = course
self.tuition = tuition
self.amount = 0
def pay_tuition(self,amount):
print('student [%s] has just paied [%s]'%(self.name,amount))
self.amount += amount
t1 = Teacher('jim',20,'M',5000,'python')
s1 = Student('Lily',22,'W','python',300000)
s2 = Student('Lilei',23,'M','python',200000)
t1.tell()
s1.tell()
s2.tell()
print(SchoolMember.member)
del s2
print(SchoolMember.member)
just enerolled a new school member [jim] just enerolled a new school member [Lily] just enerolled a new school member [Lilei] ----jim info----- age 20 course python sex M salary 5000 name jim ----Lily info----- age 22 course python sex W tuition 300000 amount 0 name Lily ----Lilei info----- age 23 course python sex M tuition 200000 amount 0 name Lilei 3 Lilei退学了.. 2 Lily退学了.. jim退学了..
多继承
class SchoolMember(object):
'''学校成员基类'''
member = 0 # 计数器
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
self.enroll()
def enroll(self):
'''注册'''
print('just enerolled a new school member [%s]'% self.name)
SchoolMember.member += 1 #实例本身有就调用本身的，没有就调用全局的
def tell(self):
print('----%s info-----'% self.name)
for k,v in self.__dict__.items():
print('\t',k,v)
def __del__(self):
print('%s退学了..'%self.name)
SchoolMember.member -= 1
class School(object):
def open_branch(self,addr):
print('openning a new branch in ',addr)
class Teacher(SchoolMember,School): #多继承
'''讲师类'''
def __init__(self,name,age,sex,salary,course):
# SchoolMember.__init__(self,name,age,sex)
super(Teacher,self).__init__(name,age,sex)
self.salary = salary
self.course = course
def teaching(self):
print('Teacher [%s] is teaching [%s]'%(self.naem,self.course))
class Student(SchoolMember):
'''学生类'''
def __init__(self,name,age,sex,course,tuition):
SchoolMember.__init__(self,name,age,sex)
self.course = course
self.tuition = tuition
self.amount = 0
def pay_tuition(self,amount):
print('student [%s] has just paied [%s]'%(self.name,amount))
self.amount += amount
t1 = Teacher('jim',20,'M',5000,'python')
t1.open_branch('SZ')
print(SchoolMember.member)
执行结果
just enerolled a new school member [jim] openning a new branch in SZ 1 jim退学了..
新式类VS经典类
接着上面的例子练习：
修改Teacher类中调用父类构造的方法。其它代码不修改
# SchoolMember.__init__(self,name,age,sex) #经典类的写法 super(Teacher,self).__init__(name,age,sex) #新式类的写法
-------------------------------------------------
t1 = Teacher('jim',20,'M',5000,'python') #学生的不调用
t1.tell()
print(SchoolMember.member)
执行结果：
just enerolled a new school member [jim] ----jim info----- course python name jim salary 5000 age 20 sex M 1 jim退学了..
可以看到效果和之前的一样 .super这种写法是一种新式类的写法。
新式类和经典类的区别
1.语法
class Person(object): #新式类
super class Person: #经典类
ParentClass.__init__
2 多继承时的继承顺序
看个小例子：
四个类继承顺序如下：
新式类写法
class A(object):
def __init__(self):
self.n = 'A'
class B(A):
def __init__(self):
self.n = 'B'
class C(A):
def __init__(self):
self.n = 'C'
class D(B,C):
def __init__(self):
self.n = 'D'
d = D()
print(d.n) #D
d把所有的父类方法重新了，打印肯定是它自己的
如果D没有构造函数,那么这里会打印谁的？
class A(object):
def __init__(self):
self.n = 'A'
class B(A):
def __init__(self):
self.n = 'B'
class C(A):
def __init__(self):
self.n = 'C'
class D(B,C):
pass
'''
def __init__(self):
self.n = 'D'
'''
d = D()
print(d.n) #B
继承顺序从左往右。所有先继承B
如果B没有构造函数，所以会继承C的，如果C也没有的话就会继承A的，这种叫广度查找，会把一个层级的查找完
class A(object):
def __init__(self):
self.n = 'A'
class B(A):
pass
class C(A):
def __init__(self):
self.n = 'C'
class D(B,C):
pass
d = D()
print(d.n) #C
经典类写法
class A:
def __init__(self):
self.n = 'A'
class B(A):
def __init__(self):
self.n = 'B'
class C(A):
def __init__(self):
self.n = 'C'
class D(B,C):
pass
d = D()
print(d.n) #B
同样去掉B的构造函数
class A:
def __init__(self):
self.n = 'A'
class B(A):
pass
class C(A):
def __init__(self):
self.n = 'C'
class D(B,C):
pass
d = D()
print(d.n)#C
去掉C的构造函数
class A:
def __init__(self):
self.n = 'A'
class B(A):
pass
class C(A):
pass
class D(B,C):
pass
d = D()
print(d.n)#A
并没有什么区别，继承顺序也是一样的。
在Python2.7下，如果B没有构造函数，会直接找A,并不会找C,r如果A没有才会找C，这种叫深度查找。
浙公网安备 33010602011771号