OOP将对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。面向对象的程序设计是将计算机程序视为一组对象的集合，而每个对象都可以接受其他对象发过来的消息，并处理这些消息，计算机程序执行的就是一系列消息在个个对象之间的传递。
与之相对的是面向过程的编程，把计算机程序视为一系列的命令集合，即一组函数的顺序执行。为了简化程序设计，面向过程把函数继续切分为子函数，即把大块函数通过切割成小块函数来降低系统的复杂度。
三大特点：
数据封装、继承、多态。

类和对象

面向对象最重要的概念就是Class和instance。Class是抽象的模板，而instance是根据类创建出来的具体“对象“。
定义类：

class Student(object):   #如果没有合适的继承类，就使用object类，这是所有类最终都会继承的类。
     pass

根据类创建instance：

>>> bart = Student()
>>> bart
<__main__.Student object at 0x10a67a590>
>>> Student
<class '__main__.Student'>

为了在创建instance的时候将一些必须绑定的属性强制写入

class Student(object):

    def __init__(self, name, score):  #self表示指向创建的实例自身
        self.name = name
        self.score = score

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

数据封装

通过在实例上调用方法，我们就直接操作了对象内部的数据，但无需知道方法内部的实现细节。

访问限制

在Class内部，可以有属性和方法，而外部代码可以通过直接调用实例变量的方法来操作数据，这样，就隐藏了内部的复杂逻辑。
如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线，在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。

class Student(object):
    ...

    def set_score(self, score):
        if 0 <= score <= 100: #相比之前的直接修改，可以增加参数检查的环节
            self.__score = score
        else:
            raise ValueError('bad score')

特殊的：
1.需要注意的是，在Python中，变量名类似xxx的，也就是以双下划线开头，并且以双下划线结尾的，是特殊变量，特殊变量是可以直接访问的，不是private变量，所以，不能用name、score这样的变量名。
2.以一个下划线开头的实例变量名，比如_name，这样的实例变量外部是可以访问的，但是，按照约定俗成的规定，当你看到这样的变量时，意思就是，“虽然我可以被访问，但是，请把我视为私有变量，不要随意访问”。
3.双下划线开头的实例变量是不是一定不能从外部访问呢？其实也不是。不能直接访问__name是因为Python解释器对外把__name变量改成了_Student__name，所以，仍然可以通过_Student__name来访问__name变量。

#但是强烈建议你不要这么干，因为不同版本的Python解释器可能会把__name改成不同的变量名。
>>>bart._Student.__name
'Bart Simpson'

继承和多态

在OOP程序设计中，当我们定义一个类的时候可以从现有的Class中继承，新的Class称为subclass，被继承的类称为Base class。

#Base Class
class Animal(object):
    def run(self):
        print('Animal is running...')
#subclass
class Dog(Animal):
    pass

class Cat(Animal):
    pass

继承可以让subclass获得Base class的全部功能

dog = Dog()
dog.run()

cat = Cat()
cat.run()

结果是：

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

当然，也可以对子类增加一些方法。

class Dog(Animal):

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

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

当子类和父类都存在相同的run()方法时，我们说，子类的run()覆盖了父类的run()，在代码运行的时候，总是会调用子类的run()。

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

多态

在继承关系中，如果一个实例的数据类型是某个子类，那它的数据类型也可以被看做是父类，反之不成立。

>>> isinstance(c, Animal)
True

>>> b = Animal()
>>> isinstance(b, Dog)
False

#多态的例子
def run_twice(animal):
    animal.run()
    animal.run()
>>> run_twice(Animal())
Animal is running...
Animal is running...

#传入子类Dog的时候run执行的是子类的run函数
>>> run_twice(Dog())
Dog is running...
Dog is running...

#新创建一个类也是成立的
class Tortoise(Animal):
    def run(self):
        print('Tortoise is running slowly...')

>>> run_twice(Tortoise())
Tortoise is running slowly...
Tortoise is running slowly...

调用方只管调用，不管细节，而当我们新增一种Animal的子类时，只要确保run()方法编写正确，不用管原来的代码是如何调用的。这就是著名的“开闭”原则：
对扩展开放：允许新增Animal子类；
对修改封闭：不需要修改依赖Animal类型的run_twice()等函数。

静态语言和动态语言在多态上的区别

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

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

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

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

获取对象信息

使用Type()

>>> type(123)
<class 'int'>
>>> type('str')
<class 'str'>
>>> type(None)
<type(None) 'NoneType'>

>>> type(abs)
<class 'builtin_function_or_method'>
>>> type(a)
<class '__main__.Animal'>

比较两个变量的type类型是否相等：

>>> type(123)==type(456)
True
>>> type(123)==int
True
>>> type('abc')==type('123')
True
>>> type('abc')==str
True
>>> type('abc')==type(123)
False

判断一个对象是否是函数：

>>> import types      #使用types 模块中定义的常量
>>> def fn():
...     pass
...
>>> type(fn)==types.FunctionType
True
>>> type(abs)==types.BuiltinFunctionType
True
>>> type(lambda x: x)==types.LambdaType
True
>>> type((x for x in range(10)))==types.GeneratorType
True

使用isinstance()

如果继承关系是：

object -> Animal -> Dog -> Husky

判断：

>>> a = Animal()
>>> d = Dog()
>>> h = Husky()

>>> isinstance(h, Husky)
True

>>> isinstance(h, Dog)
True

>>> isinstance(d, Dog) and isinstance(d, Animal)
True

>>> isinstance(d, Husky)
False

能用type()判断的基本类型也可以用isinstance()判断：

>>> isinstance('a', str)
True
>>> isinstance(123, int)
True
>>> isinstance(b'a', bytes)
True

判断一个变量是否是某些类型中的一种：

>>> isinstance([1, 2, 3], (list, tuple))
True
>>> isinstance((1, 2, 3), (list, tuple))
True

使用isinstance可以将指定种类和它的子类一网打尽

使用dir()

获得一个种类所有的属性和方法可以通过dir()函数，他返回一个包含字符串的list。

>>> dir('ABC')        #一个字符串对象的所有属性和方法
['__add__', '__class__',..., '__subclasshook__', 'capitalize', 'casefold',..., 'zfill']

类似xxx的属性和方法在Python中都是有特殊用途的，比如len方法返回长度。在Python中，如果你调用len()函数试图获取一个对象的长度，实际上，在len()函数内部，它自动去调用该对象的len()方法，所以，下面的代码是等价的：

>>> len('ABC')
3
>>> 'ABC'.__len__()
3

将属性和方法列出来后,可以操作一个对象的状态。

>>> class MyObject(object):
...     def __init__(self):
...         self.x = 9
...     def power(self):
...         return self.x * self.x
...
>>> obj = MyObject()

测试属性：

>>>hasattr(obj,'x')
True
>>> obj.x
9
>>> hasattr(obj, 'y') # 有属性'y'吗？
False
>>> setattr(obj, 'y', 19) # 设置一个属性'y'
>>> hasattr(obj, 'y') # 有属性'y'吗？
True
>>> getattr(obj, 'y') # 获取属性'y'
19
>>> obj.y # 获取属性'y'
19

>>> getattr(obj, 'z') # 获取属性'z',由于属性不存在所以抛出错误
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'MyObject' object has no attribute 'z'


>>> getattr(obj, 'z', 404) # 获取属性'z'，如果不存在，返回默认值404
404

>>> hasattr(obj, 'power') # 有属性'power'吗？
True
>>> getattr(obj, 'power') # 获取属性'power'
<bound method MyObject.power of <__main__.MyObject object at 0x10077a6a0>>
>>> fn = getattr(obj, 'power') # 获取属性'power'并赋值到变量fn
>>> fn # fn指向obj.power
<bound method MyObject.power of <__main__.MyObject object at 0x10077a6a0>>
>>> fn() # 调用fn()与调用obj.power()是一样的
81

实例属性和类属性

给实例绑定属性的方法是通过实例变量，或者通过self变量：

class Student(object):
    def __init__(self, name):
        self.name = name

s = Student('Bob')
s.score = 90

可以直接在class中定义属性，这种属性是类属性

class Student(object):
    name = 'Student'

定义了一个类属性后，所有的实例也可以访问到。

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