python面向对象
面向对象编程——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))
给对象发消息实际上就是调用对象对应的关联函数，我们称之为对象的方法
bart = Student('Bart Simpson', 59)
lisa = Student('Lisa Simpson', 87)
bart.print_score()
lisa.print_score()
类（Class）和实例（Instance）
在上面的例子中Student就是一个类，而bart,lisa就是一个个具体的Student实例。
牢记类是抽象的模板，比如Student类，而实例是根据类创建出来的一个个具体的“对象”，每个对象都拥有相同的方法，但各自的数据可能不同。
在python中定义类是以Class关键字定义：
Class Student(object):
pass
Class后面紧接着是类名，即Student，类名通常是大写开头的单词，紧接着是(object)，表示该类是从哪个类继承下来的，继承的概念我们先不急，通常，如果没有合适的继承类，就使用object类，这是所有类最终都会继承的类。
当然我们有可能会见到下面这种定义：
Class Student:
pass
这是经典类，上面的叫新式类，在Python3中都使用新式类，默认不必显示的写object,但规范最好都写上。
定义好了Student类，就可以根据Student类创建出Student的实例，创建实例是通过类名+()实现的：
>>> bart = Student() >>> bart <__main__.Student object at 0x10a67a590> >>> Student <class '__main__.Student'>
变量bart指向的是一个Student的一个实例，后面的0x10a67a590则是内存地址，每个Object的内存地址都不相同，而Student本身则是一个类。
我们可以 自由的给实例变量绑定一个属性，例如给bart绑定一个name的属性：
>>> bart.name = 'Bart Simpson' >>> bart.name 'Bart Simpson'
由于类起到模板的作用，我们在创建类时就可以把认为必须要的属性强制写进去。通过定义一个__init__方法就可以把name，score绑上去：
class Student(object):
def __init__(self, name, score):
self.name = name
self.score = score
注意到__init__方法的第一个参数永远是self，表示创建的实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。
有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不需要传，Python解释器自己会把实例变量传进去：
>>> bart = Student('Bart Simpson', 59)
>>> bart.name
'Bart Simpson'
>>> bart.score
59
和普通的函数相比，在类中定义的函数只有一点不同，就是第一个参数永远是实例变量self，并且，调用时，不用传递该参数。除此之外，类的方法和普通函数没有什么区别，所以，你仍然可以用默认参数、可变参数、关键字参数和命名关键字参数。
封装
面向对象编程最重要的一个特点就是封装，在上面的Student类中，每个实例就拥有各自的name和score这些数据。我们可以通过函数来访问这些数据，比如打印一个学生的成绩：
>>> def print_score(std):
... print('%s: %s' % (std.name, std.score))
...
>>> print_score(bart)
Bart Simpson: 59
但是既然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不用传递，其他参数正常传入：
>>> bart.print_score() Bart Simpson: 59
这样一来，我们从外部看Student类，就只需要知道，创建实例需要给出name和score，而如何打印，都是在Student类的内部定义的，这些数据和逻辑被“封装”起来了，调用很容易，但却不用知道内部实现的细节。
封装的另一个好处是可以给Student类增加新的方法，比如get_grade：
class Student(object):
...
def get_grade(self):
if self.score >= 90:
return 'A'
elif self.score >= 60:
return 'B'
else:
return 'C'
同样的，get_grade方法可以直接在实例变量上调用，不需要知道内部实现细节：
>>> bart.get_grade() 'C'
所以说，封装其实就是将对象的属性和实现细节隐藏起来，不允许外部直接访问，把方法暴露出去，让方法来操作或访问这些属性。
访问限制
但是，从前面Student类的定义来看，外部代码还是可以自由地修改一个实例的name、score属性：
>>> bart = Student('Bart Simpson', 98)
>>> bart.score
98
>>> bart.score = 59
>>> bart.score
59
如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线__，在Python中，实例的变量名如果以__开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问，所以，我们把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))
改完后，对于外部代码来说，没什么变动，但是已经无法从外部访问实例变量.__name和实例变量.__score了：
>>> bart = Student('Bart Simpson', 98)
>>> bart.__name
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute '__name'
这样就确保了外部代码不能随意修改对象内部的状态，这样通过访问限制的保护，代码更加健壮。
双下划线开头的实例变量是不是一定不能从外部访问呢？答案是No:
>>> bart._Student__name 'Bart Simpson'
其实在python中并没有私有属性这一说法，‘_’告诉别人我是一个私有属性，你不要访问，并没有一个语法上面的限制，还是能被外部代码访问，'__'虽然不能被访问，但是其实是python耍了一个小聪明，把属性名称给换了，如.__name换成了.Student.__name。
总的来说就是，Python本身没有任何机制阻止你干坏事，一切全靠自觉。
还有一个错误的写法：
>>> bart = Student('Bart Simpson', 98)
>>> bart.get_name()
'Bart Simpson'
>>> bart.__name = 'New Name' # 设置__name变量！
>>> bart.__name
'New Name'
表面上是修改成功了，其实没有，因为实际上这个__name变量和class内部的__name变量不是一个变量！内部的__name变量已经被Python解释器自动改成了_Student__name，而外部代码给bart新增了一个__name变量。
继承
在OOP程序设计中，当我们定义一个class的时候，可以从某个现有的class继承，新的class称为子类（Subclass），而被继承的class称为基类、父类或超类（Base class、Super class）。
比如我们编写了一个Animal类，并写了一个talk方法：
class Animal(object):
def talk(self):
print('Animal is talking')
然后我又写一个Dog和Cat类继承Animal类：
class Dog(Animal):
pass
class Cat(Animal):
pass
继承有什么好处，最大的好处就是实现了父类的功能：
dog = Dog() cat = Cat() dog.talk() cat.talk()
运行结果如下： Animal is talking Animal is talking
继承的第二个好处需要我们对代码做一点改进。按理说Dog和Cat在talk()时应该是‘Dog is talking’和‘Cat is talking’，做出如下修改：
class Dog(Animal):
def talk(self):
print('Dog is talking')
class Cat(Animal):
def talk(self):
print('Cat is talking')
再次运行结果如下：
Dog is talking Cat is talking
多态
多态可以说也是继承的一个好处：当子类和父类都存在相同的talk()方法时，我们说，子类的talk()覆盖了父类的talk()，在代码运行的时候，总是会调用子类的。
要理解多态的好处，还需要写一个例子，这个函数接受一个Animal类型的变量：
def talk_twice(animal):
animal.talk()
animal.talk()
当我们传入Dog和Cat实例时就打印出：
dog = Dog() cat = Cat() Animal.talk_twice(dog) Animal.talk_twice(cat) 运行结果 Dog is talking Dog is talking Cat is talking Cat is talking
这样的好处就是下一次我再定义一个类Pig继承Animal，不需要对talk_twice()进行修改就可以将Pig的实例传进去。
Python中其实是不支持多态或者说多态基本上用不上，python支持的是‘鸭子模型’，“只要像鸭子一样走路，叫声像鸭子的，都是鸭子”：
class Car(object):
def talk(self):
print('Car is talking')
然后调用talk_twice():
Animal.talk_twice(car)
输出结果：
Car is talking Car is talking
对于Python这样的动态语言来说，则不一定需要传入Animal类型。我们只需要保证传入的对象有一个run()方法就可以了。
