前言

OOP的概念就不说了，想必都很了解了。

Oop的三大特点：继承、封装和多态。python作为动态语言的一种，不仅实现了静态语言的这三个特点的常规功能，也额外拓展了很多面向对象的新特性。

new-style class

python2前几个版本的时候，python还在用旧式类，现在已经基本都是新式类了。两者写法上的区别

class Myclass:
class Myclass(object):

新式类是直接或间接继承自object基类的，如果没有可以明显继承的父类，那就在括号中加上object来声明这是个新式类。相比旧式类，新式类最大的改动就是在多继承时，到父类寻找本类中不存在的属性时，从以前的深度优先搜索改为了广度优先搜索。这样改的原因，也是跟新式类的类继承的层级关系有关。对于Class A(B,C)，如果仍用广度优先搜索，会从B一直向上递归搜索到object基类，这样在继承较多类时，每次都会重复的去访问object基类，很降低效率。

初次之外，新式类也增加一些原来旧式类没有的新属性，比如__slots__ __setattr__ __class__等等很实用的属性。

封装

在这里需要结合之前的python-命名空间和作用域那篇文章来解释一下类对象的生效原理。

类在定义时，会在当前的局部作用域创建一个命名空间，也就是类名到类对象的映射，类中的属性都要通过类名作为前缀来引用。

对于类中定义的变量，由类变量和实例变量的分别。类变量对于所有实例都可见，而单独一个实例中的变量只对自己可见。

class Myclass(object):
    a = 1
    def __init__(self,b):
        self.b = b

A = Myclass(2)
B = Myclass(3)
A.a #1
B.a #1
A.a = 100
B.a #100
A.b #2
B.b #3

类中定义的函数，实例化对象中对用的函数我们都称为方法。方法与普通函数的区别就是，方法的第一个参数都是 self ，比如 a.f(param) 这个方法的本质，就是将实例化出来的 a 对象和方法参数组装成新的参数列表，来调用类中的函数 A.f(a,param)

由__word__ 声明的属性，都是特殊变量或者方法。一般情况下，我么都用不上。上面例子的 __init__ 的作用是在类实例化时，对实例进行初始化的特殊方法，相当于C++中的构造函数。实际中，往往通过这个方法来给实例化传递参数。

看下面这个类：

class Student(object):
    """
    test class
    """
    kind = 'school'

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

    def output(self):
        print(self.name)
        print(self.age)

    def setage(self,age):
        self.age = age

Allen = Student('Allen','22')
Peter = Student('Peter','23')

print(Allen.kind)
print(Peter.kind)

print(Allen.name,Allen.age)
print(Peter.name,Peter.age)

对于 Student 这个类，实例化了 Allen 和 Peter 两个对象，拥有各自的 name age 属性和共有的 kind 属性。封装的好处就是不用在类外关心具体的方法实现，抽象出操作方法提供出去就可以。比如上个例子中的 output 方法，也可以通过 setage 来重新设置实例对象的 age 属性。

当然，在C++中有private和public变量的区分，目的也是为了保护某些比较重要的变量不被随意或者无意的修改掉。python 在这方面也提供了访问限制。

在类属性前，添加单下划线 _ 来声明这个变量是private变量。如果你看到类属性带有下划线，正确的做法是不要去使用它。但这全靠自觉！加载其他模块时，不会去加载带 _ 声明的变量和方法。python并不会真的去隐藏掉属性，都是靠着这些约定俗成的规定来避免麻烦。

当继承关系比较深之后，对新类的属性命名会很令人头疼。因为你要考虑到新的命名会覆盖掉不知道父类中的哪个属性。遇到这种情况，可以在属性前加上双下划线 __ ，python解释器会将此类变量解析为 _classname__word，这样前缀有着不同类的命名会避免覆盖父类属性的麻烦。比如上面的例子，将所有的self.name 改为 self.__name ，再通过 Allen.__name 去访问时，是会报错的，因为已经被解释器改掉了变量名。当然可以在类内，添加 getage() 方法来访问。类内属性的命名还是可以通过 self.__name 来访问的。(虽然在类外，也可以通过Allen._Allen__name来强行访问name属性，但很不推荐！后果自负)

继承

继承很简单，在class Myclass() 括号中，加上需要继承的类就可以，与java的单一继承不同，python是允许多继承的！也就是class A(B,C) 这样类A就同时继承了类B和类C。当然这边有个问题，当在调用类A中没有的属性时，是去哪个父类寻找？具体可以看这篇文章,直接看例子：

class A:
    def __init__(self):
        pass
    def save(self):
        print("This is from A")

class B(A):
    def __init__(self):

        pass
class C(A):
    def __init__(self):
        pass
    def save(self):
        print("This is from C")

class D(B,C):
    def __init__(self):
        pass

fun =  D()
fun.save()

很简单的小例子，如果来自A那就是深度优先搜索，来自C的话就是广度优先搜索。当然重写父类已有的方法会覆盖掉原有的实现，这就可以通过上面提到的双下划线命名机制来避免冲突。子类可以通过 super() 来调用父类中的方法。

可以通过 isinstance(object,class) 来判断对象是否是某类的实例。也可以通过issubclass(class1,class2)来判断class1是否是class2的子类

多态

python中的多态很强大，它支持了 duck typing。先看具有继承关系的类中的多态：

class Human(object):
    def out(self):
        print("I live on Earth")

class Asian(Human):
    def out(self):
        print('I live in Asia')

class Chinese(Asian):
    def out(self):
        print('I live in China')

def run(person):
    person.out()

A = Human()
B = Asian()
C = Chinese()

run(A)
run(B)
run(C)

结果：

I live on Earth
I live in Asia
I live in China

只定义了 run(person)这一个函数，却可以调用三个类中的方法，这就是多态的魅力。不关心传入对象的具体信息，只需要你实现了out方法，就是可以被调用的。当然对于有继承关系的类，只要你的父类中有实现，就可以被调用。

对于静态语言，函数在定义时就已经确定了，所以多态的威力还限制在只有继承关系的类中。对于python这种动态语言，只要你定义的对象拥有out()方法，甚至不需要你是函数定义参数的子类，就可以被调用。比如在上面例子中加入

class animals(object):
    def out(self):
        print('I am not person.')

输出

I live on Earth
I live in Asia
I live in China
I am not person.

animals并不是Humen的子类,只是因为实现了out()方法，就可以被run()函数调用。这就是著名的鸭子类型。动态语言中，并不要求严格的继承关系，只要这个对象 看起来像鸭子，走起路像鸭子，那就把它看成一只鸭子！

接触过网络编程的同学，应该很容易能联想到网络编程中也有相关的实现。比如读写文件，你会调用 open() read() write() 这些方法来操作file，但是还有很多特殊文件都可以通过这三个api来调用，比如socket描述符、pipe管道等等。这些东西都是长的像文件，那就可以被这些api调用！