Python基础——PyCharm版本——第七章、面向对象编程

????????Python_Base:Chapter vii????????

​目录​

​​OOP​​

​​类和实例​​

​​封装​​

​​继承和多态​​

---

OOP

面向对象编程——Object Oriented Programming，简称OOP，是一种程序设计思想。OOP把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。

面向过程的程序设计把计算机程序视为一系列的命令集合，即一组函数的顺序执行。为了简化程序设计，面向过程把函数继续切分为子函数，即把大块函数通过切割成小块函数来降低系统的复杂度。

而面向对象的程序设计把计算机程序视为一组对象的集合，而每个对象都可以接收其他对象发过来的消息，并处理这些消息，计算机程序的执行就是一系列消息在各个对象之间传递。

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

我们以一个例子来说明面向过程和面向对象在程序流程上的不同之处。

假设我们要处理学生的成绩表，为了表示一个学生的成绩，面向过程的程序可以用一个dict表示：

std1 = { 'name': 'Michael', 'score': 98 }
std2 = { 'name': 'Bob', 'score': 81 }

而处理学生成绩可以通过函数实现，比如打印学生的成绩：

def print_score(std):
print('%s: %s' % (std['name'], std['score']))

如果采用面向对象的程序设计思想，我们首选思考的不是程序的执行流程，而是​​Student​​​这种数据类型应该被视为一个对象，这个对象拥有​​name​​​和​​score​​​这两个属性（Property）。如果要打印一个学生的成绩，首先必须创建出这个学生对应的对象，然后，给对象发一个​​print_score​​消息，让对象自己把自己的数据打印出来。

class Student(object):

def __init__(self, name, score):
self.name = name
self.score = score

def print_score(self):
print('%s: %s' % (self.name, self.score))

给对象发消息实际上就是调用对象对应的关联函数，我们称之为对象的方法（Method）。面向对象的程序写出来就像这样：

bart = Student('Bart Simpson', 59)
lisa = Student('Lisa Simpson', 87)
bart.print_score()
lisa.print_score()

面向对象的设计思想是从自然界中来的，因为在自然界中，类（Class）和实例（Instance）的概念是很自然的。Class是一种抽象概念，比如我们定义的Class——Student，是指学生这个概念，而实例（Instance）则是一个个具体的Student，比如，Bart Simpson和Lisa Simpson是两个具体的Student。

所以，面向对象的设计思想是抽象出Class，根据Class创建Instance。

面向对象的抽象程度又比函数要高，因为一个Class既包含数据，又包含操作数据的方法。

类和实例

面向对象最重要的概念就是类（Class）和实例（Instance），必须牢记类是抽象的模板，比如Student类，而实例是根据类创建出来的一个个具体的“对象”，每个对象都拥有相同的方法，但各自的数据可能不同。

仍以Student类为例，在Python中，定义类是通过​​class​​关键字：

class Student(object):
pass

​​class​​​后面紧接着是类名，即​​Student​​​，类名通常是大写开头的单词，紧接着是​​(object)​​​，表示该类是从哪个类继承下来的，继承的概念我们后面再讲，通常，如果没有合适的继承类，就使用​​object​​类，这是所有类最终都会继承的类。

定义好了​​Student​​​类，就可以根据​​Student​​​类创建出​​Student​​的实例，创建实例是通过类名+()实现的：

class Student(object):
pass
bart = Student()
print(bart)
print(Student)

可以看到，变量​​bart​​​指向的就是一个​​Student​​​的实例，后面的​​0x10a67a590​​​是内存地址，每个object的地址都不一样，而​​Student​​本身则是一个类。

可以自由地给一个实例变量绑定属性，比如，给实例​​bart​​​绑定一个​​name​​属性：

class Student(object):
pass
bart = Student()
bart.name = 'Blus li'
print(bart.name)

由于类可以起到模板的作用，因此，可以在创建实例的时候，把一些我们认为必须绑定的属性强制填写进去。通过定义一个特殊的​​__init__​​​方法，在创建实例的时候，就把​​name​​​，​​score​​等属性绑上去：

class Student(object):

def __init__(self, name, score):
self.name = name
self.score = score

注意：特殊方法“__init__”前后分别有两个下划线！！！

注意到​​__init__​​​方法的第一个参数永远是​​self​​​，表示创建的实例本身，因此，在​​__init__​​​方法内部，就可以把各种属性绑定到​​self​​​，因为​​self​​就指向创建的实例本身。

有了​​__init__​​​方法，在创建实例的时候，就不能传入空的参数了，必须传入与​​__init__​​​方法匹配的参数，但​​self​​不需要传，Python解释器自己会把实例变量传进去：

class Student(object):

def __init__(self, name, score):
self.name = name
self.score = score
bart = Student('Blus li', 97)
print(bart.name)
print(bart.score)

和普通的函数相比，在类中定义的函数只有一点不同，就是第一个参数永远是实例变量​​self​​，并且，调用时，不用传递该参数。除此之外，类的方法和普通函数没有什么区别，所以，你仍然可以用默认参数、可变参数、关键字参数和命名关键字参数。

封装

面向对象编程的一个重要特点就是数据封装。在上面的​​Student​​​类中，每个实例就拥有各自的​​name​​​和​​score​​这些数据。我们可以通过函数来访问这些数据，比如打印一个学生的成绩：

class Student(object):
def __init__(self, name, score):
self.name = name
self.score = score
bart = Student('Blus li', 97)
def print_score(std):
print('%s: %s' % (std.name, std.score))
print_score(bart)

但是，既然​​Student​​​实例本身就拥有这些数据，要访问这些数据，就没有必要从外面的函数去访问，可以直接在​​Student​​​类的内部定义访问数据的函数，这样，就把“数据”给封装起来了。这些封装数据的函数是和​​Student​​类本身是关联起来的，我们称之为类的方法：

class Student(object):

def __init__(self, name, score):
self.name = name
self.score = score

def print_score(self):
print('%s: %s' % (self.name, self.score))

要定义一个方法，除了第一个参数是​​self​​​外，其他和普通函数一样。要调用一个方法，只需要在实例变量上直接调用，除了​​self​​不用传递，其他参数正常传入：

class Student(object):

def __init__(self, name, score):
self.name = name
self.score = score

def print_score(self):
print('%s: %s' % (self.name, self.score))

bart=Student("Blue Li",96);
bart.print_score()

和普通的函数相比，在类中定义的函数只有一点不同，就是第一个参数永远是实例变量​​self​​，并且，调用时，不用传递该参数。除此之外，类的方法和普通函数没有什么区别，所以，你仍然可以用默认参数、可变参数、关键字参数和命名关键字参数。

继承和多态

在OOP程序设计中，当我们定义一个class的时候，可以从某个现有的class继承，新的class称为子类（Subclass），而被继承的class称为基类、父类或超类（Base class、Super class）。

比如，我们已经编写了一个名为​​Animal​​​的class，有一个​​run()​​方法可以直接打印：

class Animal(object):
def run(self):
print('Animal is running...')

当我们需要编写​​Dog​​​和​​Cat​​​类时，就可以直接从​​Animal​​类继承：

class Dog(Animal):
pass

class Cat(Animal):
pass

对于​​Dog​​​来说，​​Animal​​​就是它的父类，对于​​Animal​​​来说，​​Dog​​​就是它的子类。​​Cat​​​和​​Dog​​类似。

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

dog = Dog()
dog.run()

cat = Cat()
cat.run()

运行结果如下：

Animal is running...
Animal is running...

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

class Dog(Animal):

def run(self):
print('Dog is running...')

def eat(self):
print('Eating meat...')

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

class Dog(Animal):

def run(self):
print('Dog is running...')

class Cat(Animal):

def run(self):
print('Cat is running...')

再次运行，结果如下：

Dog is running...
Cat is running...

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

要理解什么是多态，我们首先要对数据类型再作一点说明。当我们定义一个class的时候，我们实际上就定义了一种数据类型。我们定义的数据类型和Python自带的数据类型，比如str、list、dict没什么两样：

a = list() # a是list类型
b = Animal() # b是Animal类型
c = Dog() # c是Dog类型

判断一个变量是否是某个类型可以用​​isinstance()​​判断：

class Animal(object):
def run(self):
print('Animal is running...')
class Dog(Animal):
def run(self):
print('Dog is running...')

class Cat(Animal):
def run(self):
print('Cat is running...')
a = list() # a是list类型
b = Animal() # b是Animal类型
c = Dog() # c是Dog类型
print(isinstance(a, list))
print(isinstance(b, Animal))
print(isinstance(c, Dog))

看来​​a​​​、​​b​​​、​​c​​​确实对应着​​list​​​、​​Animal​​​、​​Dog​​这3种类型。

但是等等，试试：

class Animal(object):
def run(self):
print('Animal is running...')
class Dog(Animal):
def run(self):
print('Dog is running...')

class Cat(Animal):
def run(self):
print('Cat is running...')
a = list() # a是list类型
b = Animal() # b是Animal类型
c = Dog() # c是Dog类型
print(isinstance(c, Animal))

看来​​c​​​不仅仅是​​Dog​​​，​​c​​​还是​​Animal​​！

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

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

class Animal(object):
def run(self):
print('Animal is running...')
class Dog(Animal):
def run(self):
print('Dog is running...')

class Cat(Animal):
def run(self):
print('Cat is running...')
b = Animal()
print(isinstance(b, Dog))

​​Dog​​​可以看成​​Animal​​​，但​​Animal​​​不可以看成​​Dog​​。

要理解多态的好处，我们还需要再编写一个函数，这个函数接受一个​​Animal​​类型的变量：

def run_twice(animal):
animal.run()
animal.run()

当我们传入​​Animal​​​的实例时，​​run_twice()​​就打印出：

class Animal(object):
def run(self):
print('Animal is running...')
class Dog(Animal):
def run(self):
print('Dog is running...')

class Cat(Animal):
def run(self):
print('Cat is running...')
def run_twice(animal):
animal.run()
animal.run()
run_twice(Animal())

当我们传入​​Dog​​​的实例时，​​run_twice()​​就打印出：

class Animal(object):
def run(self):
print('Animal is running...')
class Dog(Animal):
def run(self):
print('Dog is running...')

class Cat(Animal):
def run(self):
print('Cat is running...')
def run_twice(animal):
animal.run()
animal.run()
run_twice(Dog())

 看上去没啥意思，但是仔细想想，现在，如果我们再定义一个​​Tortoise​​​类型，也从​​Animal​​派生：

class Animal(object):
def run(self):
print('Animal is running...')
class Dog(Animal):
def run(self):
print('Dog is running...')

class Cat(Animal):
def run(self):
print('Cat is running...')
class Tortoise(Animal):
def run(self):
print('Tortoise is running slowly...')
def run_twice(animal):
animal.run()
animal.run()
run_twice(Tortoise())

你会发现，新增一个​​Animal​​​的子类，不必对​​run_twice()​​​做任何修改，实际上，任何依赖​​Animal​​作为参数的函数或者方法都可以不加修改地正常运行，原因就在于多态。

多态的好处就是，当我们需要传入​​Dog​​​、​​Cat​​​、​​Tortoise​​​……时，我们只需要接收​​Animal​​​类型就可以了，因为​​Dog​​​、​​Cat​​​、​​Tortoise​​​……都是​​Animal​​​类型，然后，按照​​Animal​​​类型进行操作即可。由于​​Animal​​​类型有​​run()​​​方法，因此，传入的任意类型，只要是​​Animal​​​类或者子类，就会自动调用实际类型的​​run()​​方法，这就是多态的意思：

对于一个变量，我们只需要知道它是​​Animal​​​类型，无需确切地知道它的子类型，就可以放心地调用​​run()​​​方法，而具体调用的​​run()​​​方法是作用在​​Animal​​​、​​Dog​​​、​​Cat​​​还是​​Tortoise​​​对象上，由运行时该对象的确切类型决定，这就是多态真正的威力：调用方只管调用，不管细节，而当我们新增一种​​Animal​​​的子类时，只要确保​​run()​​方法编写正确，不用管原来的代码是如何调用的。这就是著名的“开闭”原则：

对扩展开放：允许新增​​Animal​​子类；

对修改封闭：不需要修改依赖​​Animal​​​类型的​​run_twice()​​等函数。

继承还可以一级一级地继承下来，就好比从爷爷到爸爸、再到儿子这样的关系。而任何类，最终都可以追溯到根类object，这些继承关系看上去就像一颗倒着的树。比如如下的继承树：

┌───────────────┐
│ object │
└───────────────┘
│
┌────────────┴────────────┐
│ │
▼ ▼
┌─────────────┐ ┌─────────────┐
│ Animal │ │ Plant │
└─────────────┘ └─────────────┘
│ │
┌─────┴──────┐ ┌─────┴──────┐
│ │ │ │
▼ ▼ ▼ ▼
┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐
│ Dog │ │ Cat │ │ Tree │ │ Flower │