面向对象编程(Object Oriented Programming)简称OOP,是一种程序设计思想,即按照真实世界的思维方式构建软件系统。OOP把对象作为程序的基本单元,一个对象包含了数据和操作数据的函数。

在Python中,所有数据类型都可以视为对象,当然也可以自定义对象。自定义的对象数据类型就是面向对象中的类(Class)的概念。

如果你不是编程小白,多少会对面向对象编程是什么,有一定了解。经常有人问能不能用一句话解释下什么是”面向对象编程”,我们先来看看比较正式的说法。

把一组数据结构和处理它们的方法组成对象(object),把相同行为的对象归纳为类(class),通过类的封装(encapsulation)隐藏内部细节,通过继承(inheritance)实现类的特化(specialization)和泛化(generalization),通过多态(polymorphism)实现基于对象类型的动态分派。

面向对象编程中的常见概念

  • 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
  • 类变量:类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
  • 数据成员:类变量或者实例变量, 用于处理类及其实例对象的相关的数据。
  • 方法重写:如果从父类继承的方法不能满足子类的需求,可以对其进行改写,这个过程叫方法的覆盖(override),也称为方法的重写。
  • 局部变量:定义在方法中的变量,只作用于当前实例的类。
  • 实例变量:在类的声明中,属性是用变量来表示的。这种变量就称为实例变量,是在类声明的内部但是在类的其他成员方法之外声明的。
  • 继承:即一个派生类(derived class)继承基类(base class)的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如,有这样一个设计:一个Dog类型的对象派生自Animal类,这是模拟”是一个(is-a)”关系(例图,Dog是一个Animal)。
  • 实例化:创建一个类的实例,类的具体对象。
  • 方法:类中定义的函数。
  • 对象:通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法。

类和对象

类是对象的蓝图和模板,而对象是类的实例。这个解释虽然有点像用概念在解释概念,但是从这句话我们至少可以看出,类是抽象的概念,而对象是具体的东西。在面向对象编程的世界中,一切皆为对象,对象都有属性和行为,每个对象都是独一无二的,而且对象一定属于某个类(型)。当我们把一大堆拥有共同特征的对象的静态特征(属性)和动态特征(行为)都抽取出来后,就可以定义出一个叫做“类”的东西。

例如,在真实世界的校园里有学生和老师,学生有学号、姓名、所在班级等属性(数据),还有学习、提问、吃饭和走路等动作(方法)。那么在构建系统时,就会有学生、老师两个类。张老师、李老师两个相应的实体。同等张同学、李同学相应的实体

类定义

Python中的数据类型都是类,我们可以自定义类,即创建一种新的数据类型。Python中类的定义语法格式如右图所示。

  1. class Student(object):
  2. pass

Student类继承了object类,object类是所有类的根类,在Python中任何一个类(除object外)都直接或间接地继承了object,直接继承object时(object)部分的代码可以省略。

pass的作用:pass语句只用于维持结构的完整。在编程时若不想马上编写某些代码,又不想语法错位,就可以使用pass语句站位。

类的简单使用

  1. class Student(object):
  2. # __init__是一个特殊方法用于在创建对象时进行初始化操作
  3. # 通过这个方法我们可以为学生对象绑定name和age两个属性
  4. def __init__(self, name, age):
  5. self.name = name
  6. self.age = age
  7. def study(self, course_name):
  8. print('%s正在学习%s.' % (self.name, course_name))
  9. # PEP 8要求标识符的名字用全小写多个单词用下划线连接
  10. # 但是部分程序员和公司更倾向于使用驼峰命名法(驼峰标识)
  11. def watch_movie(self):
  12. if self.age < 18:
  13. print('%s只能观看《熊出没》.' % self.name)
  14. else:
  15. print('%s正在观看岛国爱情大电影.' % self.name)

对象的创建和使用

类相当于一个模板,依据这样的模板来创建对象,就是类的实例化,所以对象也被称为“实例”。

当我们定义好一个类之后,可以通过下面的方式来创建对象并给对象发消息。

  1. def main():
  2. # 创建学生对象并指定姓名和年龄
  3. stu1 = Student('骆昊', 38)
  4. # 给对象发study消息
  5. stu1.study('Python学习中')
  6. # 给对象发watch_av消息
  7. stu1.watch_movie()
  8. stu2 = Student('王大锤', 15)
  9. stu2.study('思想品德')
  10. stu2.watch_movie()
  11. if __name__ == '__main__':
  12. main()

访问可见性

在Class内部,可以有属性和方法,而外部代码可以通过直接调用实例变量的方法来操作数据,这样,就隐藏了内部的复杂逻辑。

但是,从前面Student类的定义来看,外部代码还是可以自由地修改一个实例的namescore属性:

  1. bart = Student('Bart Simpson', 59)
  2. bart.score
  3. # 59
  4. bart.score = 99
  5. bart.score
  6. # 99

如果要让内部属性不被外部访问,可以把属性的名称前加上两个下划线__,在Python中,实例的变量名如果以__开头,就变成了一个私有变量(private),只有内部可以访问,外部不能访问,所以,我们把Student类改一改:

  1. class Student(object):
  2. def __init__(self, name, score):
  3. self.__name = name
  4. self.__score = score
  5. def print_score(self):
  6. print('%s: %s' % (self.__name, self.__score))

改完后,对于外部代码来说,没什么变动,但是已经无法从外部访问实例变量.__name实例变量.__score了:

  1. bart = Student('Bart Simpson', 59)
  2. bart.__name
  3. """
  4. 报错
  5. Traceback (most recent call last):
  6. File "<stdin>", line 1, in <module>
  7. AttributeError: 'Student' object has no attribute '__name'
  8. """

这样就确保了外部代码不能随意修改对象内部的状态,这样通过访问限制的保护,代码更加健壮。

但是如果外部代码要获取和修改name和score怎么办?可以给Student类增加get_name、set_nameget_score、set_name这样的方法:

  1. class Student(object):
  2. # ...
  3. def get_name(self):
  4. return self.__name
  5. def get_score(self):
  6. return self.__score
  7. def set_name(self, name):
  8. self.__name = name
  9. def set_score(self, score):
  10. self.__score = score

你也许会问,原先那种直接通过bart.score = 99也可以修改啊,为什么要定义一个方法大费周折?因为在方法中,可以对参数做检查,避免传入无效的参数:

  1. class Student(object):
  2. def set_score(self, score):
  3. if 0 <= score <= 100:
  4. self.__score = score
  5. else:
  6. raise ValueError('bad score')

需要注意的是,在Python中,变量名类似__xxx__的,也就是以双下划线开头,并且以双下划线结尾的,是特殊变量,特殊变量是可以直接访问的,不是private变量,所以,不能用__name____score__这样的变量名。

有些时候,你会看到以一个下划线开头的实例变量名,比如_name,这样的实例变量外部是可以访问的,但是,按照约定俗成的规定,当你看到这样的变量时,意思就是,“虽然我可以被访问,但是,请把我视为私有变量,不要随意访问”。

双下划线开头的实例变量是不是一定不能从外部访问呢?其实也不是。不能直接访问__name是因为Python解释器对外把__name变量改成了_Student__name,所以,仍然可以通过_Student__name来访问__name变量:

但是强烈建议你不要这么干,因为不同版本的Python解释器可能会把__name改成不同的变量名。

最后注意下面的这种错误写法

  1. bart = Student('Bart Simpson', 59)
  2. bart.get_name()
  3. # 'Bart Simpson'
  4. bart.__name = 'New Name' # 设置__name变量!
  5. bart.__name
  6. # 'New Name'

表面上看,外部代码“成功”地设置了__name变量,但实际上这个__name变量和class内部的__name变量不是一个变量!内部的__name变量已经被Python解释器自动改成了_Student__name,而外部代码给bart新增了一个__name变量。不信试试:

  1. bart.get_name() # get_name()内部返回self.__name
  2. # 'Bart Simpson'

面向对象的特性

面向对象有三大特性:封装、继承和多态。

封装

封装性是面向对象重要的基本特性之一。封装隐藏了对象的内部细节,只保留有限的对外接口,外部调用者不用关心对象的内部细节,使得操作对象变得简单。

自己对封装的理解“隐藏一切可以隐藏的实现细节,只向外界暴露(提供)简单的编程接口”。我们在类中定义的方法其实就是把数据和对数据的操作封装起来了,在我们创建了对象之后,只需要给对象发送一个消息(调用方法)就可以执行方法中的代码,也就是说我们只需要知道方法的名字和传入的参数(方法的外部视图),而不需要知道方法内部的实现细节(方法的内部视图)。

继承

在现实世界中继承关系无处不在。例如猫与动物之间的关系:猫是一种特殊动物,具有动物的全部特征和行为,即数据和操作。

在面向对象中动物是一般类,被称为“父类”;猫是特殊类,被称为“子类”。特殊类拥有一般类的全部数据和操作,可称之为子类继承父类。

在Python中声明子类继承父类,语法很简单,定义类时在类的后面使用一对小括号指定它的父类就可以了。

比如,我们已经编写了一个名为Animal的class,有一个eat()方法可以直接打印:

  1. class Animal(object):
  2. def eat(self):
  3. print('Animal is eating...')

当我们需要编写DogCat类时,就可以直接从Animal类继承:

  1. class Dog(Animal):
  2. pass
  3. class Cat(Animal):
  4. pass

对于Dog来说,Animal就是它的父类,对于Animal来说,Dog就是它的子类。

继承有什么好处?最大的好处是子类获得了父类的全部功能。由于Animial实现了run()方法,因此,DogCat作为它的子类,什么事也没干,就自动拥有了run()方法:

  1. dog = Dog()
  2. dog.run()
  3. # Animal is eating...
  4. cat = Cat()
  5. cat.run()
  6. # Animal is eating...

当然,也可以对子类增加一些方法,比如Dog类:

  1. class Dog(Animal):
  2. def run(self):
  3. print('Dog is eating...')
  4. def eat(self):
  5. print('Eating meat...')

继承的第二个好处需要我们对代码做一点改进。你看到了,无论是Dog还是Cat,它们run()的时候,显示的都是Animal is running...,符合逻辑的做法是分别显示Dog is running...Cat is running...,因此,对DogCat类改进如下:

  1. class Dog(Animal):
  2. def run(self):
  3. print('Dog is running...')
  4. class Cat(Animal):
  5. def run(self):
  6. print('Cat is running...')
  7. """
  8. 再次运行,结果如下:
  9. Dog is running...
  10. Cat is running...
  11. """

当子类和父类都存在相同的run()方法时,我们说,子类的run()覆盖了父类的run(),在代码运行的时候,总是会调用子类的run()。这样,我们就获得了继承的另一个好处:多态。

多态

在多个子类继承父类,并重写父类方法后,这些子类所创建的对象之间就是多态的。这些对象采用不同的方式实现父类方法。

isinstance()

isinstance()主要作用判断一个变量是否是某个类型。

  1. a = list() # a是list类型
  2. b = Animal() # b是Animal类型
  3. c = Dog() # c是Dog类型
  4. isinstance(a, list)
  5. # True
  6. isinstance(b, Animal)
  7. # True
  8. isinstance(c, Dog)
  9. # True

但是等等,试试:

  1. isinstance(c, Animal)
  2. # True

看来c不仅仅是Dogc还是Animal

不过仔细想想,这是有道理的,因为Dog是从Animal继承下来的,当我们创建了一个Dog的实例c时,我们认为c的数据类型是Dog没错,但c同时也是Animal也没错,Dog本来就是Animal的一种!

所以,在继承关系中,如果一个实例的数据类型是某个子类,那它的数据类型也可以被看做是父类。但是,反过来就不行:

  1. b = Animal()
  2. isinstance(b, Dog)
  3. # False

Dog可以看成Animal,但Animal不可以看成Dog

静态语言 vs 动态语言

对于静态语言(例如Java)来说,如果需要传入Animal类型,则传入的对象必须是Animal类型或者它的子类,否则,将无法调用run()方法。

对于Python这样的动态语言来说,则不一定需要传入Animal类型。我们只需要保证传入的对象有一个run()方法就可以了:

  1. class Timer(object):
  2. def run(self):
  3. print('Start...')

这就是动态语言的“鸭子类型”,它并不要求严格的继承体系,一个对象只要“看起来像鸭子,走起路来像鸭子”,那它就可以被看做是鸭子。

Python的“file-like object“就是一种鸭子类型。对真正的文件对象,它有一个read()方法,返回其内容。但是,许多对象,只要有read()方法,都被视为“file-like object“。许多函数接收的参数就是“file-like object“,你不一定要传入真正的文件对象,完全可以传入任何实现了read()方法的对象。

面向对象进阶

数据封装、继承和多态只是面向对象程序设计中最基础的3个概念。在Python中,面向对象还有很多高级特性,允许我们写出非常强大的功能。

在前面的章节我们已经了解了面向对象的入门知识,知道了如何定义类,如何创建对象以及如何给对象发消息。为了能够更好的使用面向对象编程思想进行程序开发,我们还需要对Python中的面向对象编程进行更为深入的了解。

@property

在绑定属性时,如果我们直接把属性暴露出去,虽然写起来很简单,但是,没办法检查参数,导致可以把成绩随便改:

  1. s = Student()
  2. s.score = 9999

这显然不合逻辑。为了限制score的范围,可以通过一个set_score()方法来设置成绩,再通过一个get_score()来获取成绩,这样,在set_score()方法里,就可以检查参数:

  1. class Student(object):
  2. def get_score(self):
  3. return self._score
  4. def set_score(self, value):
  5. if not isinstance(value, int):
  6. raise ValueError('score must be an integer!')
  7. if value < 0 or value > 100:
  8. raise ValueError('score must between 0 ~ 100!')
  9. self._score = value
  10. def main():
  11. s = Student()
  12. # s.set_score(101)
  13. # s.set_score("test")
  14. if __name__ == '__main__':
  15. main()

现在,对任意的Student实例进行操作,就不能随心所欲地设置score了。这样写感觉有点小麻烦,有没有简单点的呢。有

有没有既能检查参数,又可以用类似属性这样简单的方式来访问类的变量呢?对于追求完美的Python程序员来说,这是必须要做到的!

还记得装饰器(decorator)可以给函数动态加上功能吗?对于类的方法,装饰器一样起作用。Python内置的@property装饰器就是负责把一个方法变成属性调用的:

  1. class Student(object):
  2. @property
  3. def score(self):
  4. return self._score
  5. @score.setter
  6. def score(self, value):
  7. if not isinstance(value, int):
  8. raise ValueError('score must be an integer!')
  9. if value < 0 or value > 100:
  10. raise ValueError('score must between 0 ~ 100!')
  11. self._score = value
  12. """
  13. >>> s = Student()
  14. >>> s.score = 60 # OK,实际转化为s.set_score(60)
  15. >>> s.score # OK,实际转化为s.get_score()
  16. 60
  17. >>> s.score = 9999
  18. Traceback (most recent call last):
  19. ...
  20. ValueError: score must between 0 ~ 100!
  21. """

把一个getter方法变成属性,只需要加上@property就可以了,此时,@property本身又创建了另一个装饰器@score.setter,负责把一个setter方法变成属性赋值,于是,我们就拥有一个可控的属性操作:

设置只读属性

定义只读属性,只定义getter方法,不定义setter方法就是一个只读属性:

  1. class Student(object):
  2. @property
  3. def birth(self):
  4. return self._birth
  5. @birth.setter
  6. def birth(self, value):
  7. self._birth = value
  8. @property
  9. def age(self):
  10. return 2015 - self._birth

上面的birth是可读写属性,而age就是一个只读属性,因为age可以根据birth和当前时间计算出来。

@property广泛应用在类的定义中,可以让调用者写出简短的代码,同时保证对参数进行必要的检查,这样,程序运行时就减少了出错的可能性。

__slots__

通常,动态语言允许我们在程序运行时给对象绑定新的属性或方法,当然也可以对已经绑定的属性和方法进行解绑定。但是如果我们需要限定自定义类型的对象只能绑定某些属性,可以通过在类中定义__slots__变量来进行限定。

为了达到限制的目的,Python允许在定义class的时候,定义一个特殊的__slots__变量,来限制该class实例能添加的属性:

  1. class Student(object):
  2. __slots__ = ('name', 'age') # 用tuple定义允许绑定的属性名称
  3. def main():
  4. s = Student() # 创建新的实例
  5. s.name = 'Michael' # 绑定属性'name'
  6. s.age = 25 # 绑定属性'age'
  7. s.score = 99 # 绑定属性'score' (报错:AttributeError: 'Student' object has no attribute 'score')
  8. if __name__ == '__main__':
  9. main()

由于'score'没有被放到__slots__中,所以不能绑定score属性,试图绑定score将得到AttributeError的错误。

使用__slots__要注意,__slots__定义的属性仅对当前类实例起作用,对继承的子类是不起作用的:

静态方法和类方法

我们在类中定义的方法都是对象方法,也就是说这些方法都是给对象发送消息的。

静态方法

实际上,我们写在类中的方法并不需要都是对象方法,例如我们定义一个“三角形”类,通过传入三条边长来构造三角形,并提供计算周长和面积的方法,但是传入的三条边长未必能构造出三角形对象,因此我们可以先写一个方法来验证三条边长是否可以构成三角形,这个方法很显然就不是对象方法,因为在调用这个方法时三角形对象尚未创建出来(因为都不知道三条边能不能构成三角形),所以这个方法是属于三角形类而并不属于三角形对象的。我们可以使用静态方法来解决这类问题,代码如下所示。

  1. from math import sqrt
  2. class Triangle(object):
  3. def __init__(self, a, b, c):
  4. self._a = a
  5. self._b = b
  6. self._c = c
  7. @staticmethod
  8. def is_valid(a, b, c):
  9. return a + b > c and b + c > a and a + c > b
  10. def perimeter(self):
  11. return self._a + self._b + self._c
  12. def area(self):
  13. half = self.perimeter() / 2
  14. return sqrt(half * (half - self._a) *
  15. (half - self._b) * (half - self._c))
  16. def main():
  17. a, b, c = 3, 4, 5
  18. # 静态方法和类方法都是通过给类发消息来调用的
  19. if Triangle.is_valid(a, b, c):
  20. t = Triangle(a, b, c)
  21. print(t.perimeter())
  22. # 也可以通过给类发消息来调用对象方法但是要传入接收消息的对象作为参数
  23. # print(Triangle.perimeter(t))
  24. print(t.area())
  25. # print(Triangle.area(t))
  26. else:
  27. print('无法构成三角形.')
  28. if __name__ == '__main__':
  29. main()

类方法

和静态方法比较类似,Python还可以在类中定义类方法,类方法的第一个参数约定名为cls,它代表的是当前类相关的信息的对象(类本身也是一个对象,有的地方也称之为类的元数据对象),通过这个参数我们可以获取和类相关的信息并且可以创建出类的对象,代码如下所示。

  1. from time import time, localtime, sleep
  2. class Clock(object):
  3. """数字时钟"""
  4. def __init__(self, hour=0, minute=0, second=0):
  5. self._hour = hour
  6. self._minute = minute
  7. self._second = second
  8. @classmethod
  9. def now(cls):
  10. ctime = localtime(time())
  11. return cls(ctime.tm_hour, ctime.tm_min, ctime.tm_sec)
  12. def run(self):
  13. """走字"""
  14. self._second += 1
  15. if self._second == 60:
  16. self._second = 0
  17. self._minute += 1
  18. if self._minute == 60:
  19. self._minute = 0
  20. self._hour += 1
  21. if self._hour == 24:
  22. self._hour = 0
  23. def show(self):
  24. """显示时间"""
  25. return '%02d:%02d:%02d' % \
  26. (self._hour, self._minute, self._second)
  27. def main():
  28. # 通过类方法创建对象并获取系统时间
  29. clock = Clock.now()
  30. while True:
  31. print(clock.show())
  32. sleep(1)
  33. clock.run()
  34. if __name__ == '__main__':
  35. main()

多重继承

继承是面向对象编程的一个重要的方式,因为通过继承,子类就可以扩展父类的功能。

如果对Java有了解的话,应该清楚Java中不能实现多继承。一个子类只能继承一个父类。但是可以通过多实现,实现相同的效果。

回忆一下Animal类层次的设计,假设我们要实现以下4种动物:

  • Dog - 狗狗;
  • Bat - 蝙蝠;
  • Parrot - 鹦鹉;
  • Ostrich - 鸵鸟。

如果按照哺乳动物和鸟类归类,我们可以设计出这样的类的层次:

  1. ┌───────────────┐
  2. Animal
  3. └───────────────┘
  4. ┌────────────┴────────────┐
  5. ┌─────────────┐ ┌─────────────┐
  6. Mammal Bird
  7. └─────────────┘ └─────────────┘
  8. ┌─────┴──────┐ ┌─────┴──────┐
  9. ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐
  10. Dog Bat Parrot Ostrich
  11. └─────────┘ └─────────┘ └─────────┘ └─────────┘

但是如果按照“能跑”和“能飞”来归类,我们就应该设计出这样的类的层次:

  1. ┌───────────────┐
  2. Animal
  3. └───────────────┘
  4. ┌────────────┴────────────┐
  5. ┌─────────────┐ ┌─────────────┐
  6. Runnable Flyable
  7. └─────────────┘ └─────────────┘
  8. ┌─────┴──────┐ ┌─────┴──────┐
  9. ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐
  10. Dog Ostrich Parrot Bat
  11. └─────────┘ └─────────┘ └─────────┘ └─────────┘

如果要把上面的两种分类都包含进来,我们就得设计更多的层次:

  • 哺乳类:能跑的哺乳类,能飞的哺乳类;
  • 鸟类:能跑的鸟类,能飞的鸟类。

这么一来,类的层次就复杂了:

  1. ┌───────────────┐
  2. Animal
  3. └───────────────┘
  4. ┌────────────┴────────────┐
  5. ┌─────────────┐ ┌─────────────┐
  6. Mammal Bird
  7. └─────────────┘ └─────────────┘
  8. ┌─────┴──────┐ ┌─────┴──────┐
  9. ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐
  10. MRun MFly BRun BFly
  11. └─────────┘ └─────────┘ └─────────┘ └─────────┘
  12. ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐
  13. Dog Bat Ostrich Parrot
  14. └─────────┘ └─────────┘ └─────────┘ └─────────┘

如果要再增加“宠物类”和“非宠物类”,这么搞下去,类的数量会呈指数增长,很明显这样设计是不行的。

正确的做法是采用多重继承。首先,主要的类层次仍按照哺乳类和鸟类设计:

  1. class Animal(object):
  2. pass
  3. # 大类:
  4. class Mammal(Animal):
  5. pass
  6. class Bird(Animal):
  7. pass
  8. # 各种动物:
  9. class Dog(Mammal):
  10. pass
  11. class Bat(Mammal):
  12. pass
  13. class Parrot(Bird):
  14. pass
  15. class Ostrich(Bird):
  16. pass

现在,我们要给动物再加上RunnableFlyable的功能,只需要先定义好RunnableFlyable的类:

  1. class Runnable(object):
  2. def run(self):
  3. print('Running...')
  4. class Flyable(object):
  5. def fly(self):
  6. print('Flying...')

对于需要Runnable功能的动物,就多继承一个Runnable,例如Dog

  1. class Dog(Mammal, Runnable):
  2. pass

对于需要Flyable功能的动物,就多继承一个Flyable,例如Bat

  1. class Bat(Mammal, Flyable):
  2. pass

通过多重继承,一个子类就可以同时获得多个父类的所有功能。

继承和多态

在已有类的基础上创建新类,这其中的一种做法就是让一个类从另一个类那里将属性和方法直接继承下来,从而减少重复代码的编写。提供继承信息的我们称之为父类,也叫超类或基类;得到继承信息的我们称之为子类,也叫派生类或衍生类。子类除了继承父类提供的属性和方法,还可以定义自己特有的属性和方法,所以子类比父类拥有的更多的能力,在实际开发中,我们经常会用子类对象去替换掉一个父类对象,这是面向对象编程中一个常见的行为,对应的原则称之为里氏替换原则。下面我们先看一个继承的例子。

  1. class Person(object):
  2. """人"""
  3. def __init__(self, name, age):
  4. self._name = name
  5. self._age = age
  6. @property
  7. def name(self):
  8. return self._name
  9. @property
  10. def age(self):
  11. return self._age
  12. @age.setter
  13. def age(self, age):
  14. self._age = age
  15. def play(self):
  16. print('%s正在愉快的玩耍.' % self._name)
  17. def watch_av(self):
  18. if self._age >= 18:
  19. print('%s正在观看爱情动作片.' % self._name)
  20. else:
  21. print('%s只能观看《熊出没》.' % self._name)
  22. class Student(Person):
  23. """学生"""
  24. def __init__(self, name, age, grade):
  25. super().__init__(name, age)
  26. self._grade = grade
  27. @property
  28. def grade(self):
  29. return self._grade
  30. @grade.setter
  31. def grade(self, grade):
  32. self._grade = grade
  33. def study(self, course):
  34. print('%s的%s正在学习%s.' % (self._grade, self._name, course))
  35. class Teacher(Person):
  36. """老师"""
  37. def __init__(self, name, age, title):
  38. super().__init__(name, age)
  39. self._title = title
  40. @property
  41. def title(self):
  42. return self._title
  43. @title.setter
  44. def title(self, title):
  45. self._title = title
  46. def teach(self, course):
  47. print('%s%s正在讲%s.' % (self._name, self._title, course))
  48. def main():
  49. stu = Student('王大锤', 15, '初三')
  50. stu.study('数学')
  51. stu.watch_av()
  52. t = Teacher('骆昊', 38, '砖家')
  53. t.teach('Python程序设计')
  54. t.watch_av()
  55. if __name__ == '__main__':
  56. main()

子类在继承了父类的方法后,可以对父类已有的方法给出新的实现版本,这个动作称之为方法重写(override)。通过方法重写我们可以让父类的同一个行为在子类中拥有不同的实现版本,当我们调用这个经过子类重写的方法时,不同的子类对象会表现出不同的行为,这个就是多态(poly-morphism)。

  1. from abc import ABCMeta, abstractmethod
  2. class Pet(object, metaclass=ABCMeta):
  3. """宠物"""
  4. def __init__(self, nickname):
  5. self._nickname = nickname
  6. @abstractmethod
  7. def make_voice(self):
  8. """发出声音"""
  9. pass
  10. class Dog(Pet):
  11. """狗"""
  12. def make_voice(self):
  13. print('%s: 汪汪汪...' % self._nickname)
  14. class Cat(Pet):
  15. """猫"""
  16. def make_voice(self):
  17. print('%s: 喵...喵...' % self._nickname)
  18. def main():
  19. pets = [Dog('旺财'), Cat('凯蒂'), Dog('大黄')]
  20. for pet in pets:
  21. pet.make_voice()
  22. if __name__ == '__main__':
  23. main()

在上面的代码中,我们将Pet类处理成了一个抽象类,所谓抽象类就是不能够创建对象的类,这种类的存在就是专门为了让其他类去继承它。

Python从语法层面并没有像Java或C#那样提供对抽象类的支持,但是我们可以通过abc模块的ABCMeta元类和abstractmethod包装器来达到抽象类的效果,如果一个类中存在抽象方法那么这个类就不能够实例化(创建对象)。上面的代码中,DogCat两个子类分别对Pet类中的make_voice抽象方法进行了重写并给出了不同的实现版本,当我们在main函数中调用该方法时,这个方法就表现出了多态行为(同样的方法做了不同的事情)。

定制类

看到类似__xxx__这种类型的,如__slots__的变量或者函数名就要注意,这些在Python中是有特殊用途的。除此之外,Python的class中还有许多这样有特殊用途的函数,可以帮助我们定制类。

__str__

可以简单理解为类的格式化。类似于Javaz中的 toString()

  1. class Student(object):
  2. def __init__(self, name):
  3. self.name = name
  4. # 如果不定义__str__打印出一堆<__main__.Student object at 0x000001A52E977C40>,不好看。
  5. # 只需要定义好__str__()方法,返回一个好看的字符串就可以了:
  6. def __str__(self):
  7. return 'Student object (name: %s)' % self.name
  8. def main():
  9. print(Student('Michael'))
  10. #不定义打印: <__main__.Student object at 0x000001A52E977C40>
  11. #定以后打印: Student object (name: Michael)
  12. if __name__ == '__main__':
  13. main()

但是细心的朋友会发现直接敲变量不用print,打印出来的实例还是不好看:

  1. class Student(object):
  2. def __init__(self, name):
  3. self.name = name
  4. def __str__(self):
  5. return 'Student object (name: %s)' % self.name
  6. def main():
  7. print(Student('Michael'))
  8. if __name__ == '__main__':
  9. main()

__repr__()

这是因为直接显示变量调用的不是__str__(),而是__repr__(),两者的区别是__str__()返回用户看到的字符串,而__repr__()返回程序开发者看到的字符串,也就是说,__repr__()是为调试服务的。

解决办法是再定义一个__repr__()。但是通常__str__()__repr__()代码都是一样的,所以,有个偷懒的写法:

  1. class Student(object):
  2. def __init__(self, name):
  3. self.name = name
  4. def __str__(self):
  5. return 'Student object (name=%s)' % self.name
  6. __repr__ = __str__

后续用到在补充……