前言

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

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

类和实例

面向对象最重要的概念就是类（Class）和实例（Instance）

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

1
2
3
4

class Student(object):
    pass

>>> bart = Student()

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

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

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

1
2
3

>>> bart.name = 'Bart Simpson'
>>> bart.name
'Bart Simpson'

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

1
2
3
4
5

class Student(object):

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

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

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

1
2
3
4
5

>>> bart = Student('Bart Simpson', 59)
>>> bart.name
'Bart Simpson'
>>> bart.score
59

和普通的函数相比，在类中定义的函数只有一点不同，就是第一个参数永远是实例变量self，并且，调用时，不用传递该参数。

访问限制

如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线，在Python中，实例的变量名如果以开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问：

1
2
3
4
5
6
7
8

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))

改完后，对于外部代码来说，没什么变动，但是已经无法从外部访问实例变量.name和实例变量.score了，有些类似于java的private。

这时我们想要访问它们，就需要getter/setter方法：

1
2
3
4
5
6
7
8

class Student(object):
    ...

    def set_score(self, score):
        self.__score = score

    def get_score(self):
        return self.__score

注意：在Python中，变量名类似xxx的，也就是以双下划线开头，并且以双下划线结尾的，是特殊变量，特殊变量是可以直接访问的，不是private变量。

类属性

可以直接在class中定义属性，这种属性是类属性，归Student类所有：

1
2

class Student(object):
    name = 'Student'

类属性，实例和类对象都可以访问，但是与Java不同的是，如果类属性和实例属性名称相同，实例属性优先级要更高：

1
2
3
4
5
6
7
8
9
10
11
12
13

 给实例绑定name属性
>>> s.name = 'Michael' 
 由于实例属性优先级比类属性高，因此，它会屏蔽掉类的name属性
>>> print(s.name)
Michael
 但是类属性并未消失，用Student.name仍然可以访问
>>> print(Student.name) 
Student
 如果删除实例的name属性
>>> del s.name 
 再次调用s.name，由于实例的name属性没有找到，类的name属性就显示出来了
>>> print(s.name)
Student

main函数

1
2

if __name__ == "__main__":
    print(Student.name)

继承

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

1
2
3

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

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

1
2
3
4
5

class Dog(Animal):
    pass

class Cat(Animal):
    pass

多态

在Animal类定义一个函数：

1
2
3

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

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

1
2
3
4
5
6
7

>>> run_twice(Animal())
Animal is running...
Animal is running...

>>> run_twice(Dog())
Dog is running...
Dog is running...

这样新增一个子类，我们就没必要在子类中新增类似的函数。

注意，虽然方法的参数是animal，但只要传进去的实例中含有run方法，都会执行，这是python作为动态语言与java的不同点。