类和对象，作为面向对象编程的核心，在所有OOP语言里面都是重头戏，Python也不例外。
Python中的类和对象定义如下：

class foo:
    pass


f = foo()

以class关键字开头，定义了一个foo类，并使用foo()实例化成对象f，这里没有定义任何类内变量或者方法，所以使用pass关键字。

Python类的继承

出人意料的是，Python是支持多继承的，作为一门相对年轻的语言，这个特性可不多见了，毕竟从java开始，多继承就被认为是一种不好的设计，如果你读过《Effective C++》，那么你应该知道有些时候连继承都不是一种好的设计。
Anyway，我没有资格对Python的设计妄加评判，总之，Python的继承语法如下：

class Human:
    pass


class Father(Human):
    pass


class Mother(Human):
    pass


class Child(Father, Mother):
    pass

另外，当一个类没有指定任何基类时，它默认继承自内置类型object。
由于Python不存在protected约束，所以在实现多态时，有时需要你去进行一些约定，而无法从语法上保证安全性。
_前缀表示该成员是module级别的私有成员，无法被别的module访问，但是module内部是可以随意访问的。
__前缀则可以定义一个private的成员（变量跟方法都可以），派生类无法访问该成员，但是可以通过“名字改编”（name mangling）的技术间接访问：

class Human:
    __weight = 100

    def __say(self, arg):
        print(arg)


class Father(Human):
    pass


class Mother(Human):
    pass


class Child(Father, Mother):
    pass


print(Child().__weight) # 非法
Child().__say('hello') # 非法
print(Child()._Human__weight) # 合法，name mangling
Child()._Human__say('hello') # 合法，name mangling

这里使用的别名是指向源地址的，也就是说你对它做的赋值等行为都是有效的。
另外，当一个成员同时使用__作为前缀和后缀时，它不表示这个成员是个私有成员，而表示这是一个“魔法成员”，通常这是内建属性，当然你也可以自定义如果你不怕把自定义成员跟内建成员弄混的话（或者你本来就想扩展一下）。

Python类的内置属性

Python中的类，使用类名时本身也是一个type类的对象：

class foo:
    pass


print(type(foo))

可以看到foo的类型为type。
那么类本身作为对象，它就具有内置的属性，类内置属性很多很多，其中几个特殊属性（官网说的special attributes）如下：

可以看到，有些属性跟Python学习笔记（3）——函数中提到的callable类型的内置属性相同，作用也是一样的。
其中，__dict__包含了类的所有变量和方法，callable类型也有__dict__，但它通常是空的。
__bases__则包含了该类继承的所有基类（不包含基类的基类），如上一节的Human，它的__bases__是(<class 'object'>,)，而Child的__bases__则是(<class '__main__.father'>, <class '__main__.mother'>)。

Python类方法的定义和调用

Python类内方法的定义如下：

class foo:
    def bar(self):
        pass

跟普通函数的定义差不多，但是类内方法第一个参数必须是self（当然名字可以自定，self是某种默认的规则），该参数的作用类似java的this，不过Python需要显式定义。
当然你可以不定义这个参数：

class foo:
    def bar():
        pass

此时，bar便不再是一个普通的方法，你无法使用实例化的对象去调用它，因为实例化对象的调用形式foo().bar()会把对象本身作为第一个参数传递进去，如此调用你会获得一个错误：TypeError: bar() takes 0 positional arguments but 1 was given。
但是，使用类名去调用该函数是可以的：foo.bar()，这个形式相信大家都很熟悉了，这不就是静态方法吗？

Python静态方法、类方法

Python的静态方法定义如下：

class foo:
    @staticmethod
    def bar():
        pass

可以看到这里我们又用上了装饰器@staticmethod，看过前一章的朋友们对这个语法应该很熟悉了，在builtins.pyi文件中定义了这个装饰器类staticmethod（有的同学可能有疑问，装饰器不是函数吗？怎么类也可以当装饰器？这个后面再解释），具体作用就是给被装饰的方法添加了一些属性，所以事实上调用起来，加不加@staticmethod都可以成功执行，当然为了代码可读性一般都是加的。
除了静态方法之外，Python还有一种特殊的方法也是用类名调用的，被称作类方法（classmethod）：

class foo:
    @classmethod
    def bar(cls):
        pass

虽然调用形式都是foo.bar()，但是classmethod多一个cls参数，类似普通方法的self，cls会将类本身作为一个参数传进去，如果你需要对类本身的属性进行操作，那么你应该使用classmethod而非staticmethod，从这个角度看，classmethod更加接近C++的类静态函数。

Python虚函数

Python没有虚函数和纯虚函数，所以你也无法实现接口，当然你可以用某种手段实现类似的功能，比如装饰器：

def virtual(func):
    def wrapper(self):
        raise IOError('Not implement')
    return wrapper


class interface:
    @virtual
    def virtual_func(self): pass


class implement(interface):
    def virtual_func(self):
        print('hello')

以上写法，调用interface().virtual_func()会抛出一个IOError，而调用implement().virutal_func()则可以打印hello。

Python类的内置方法

Python类的主要内置方法如下：

别的不多说了，__getattr__比较有意思，通常我们获取一个对象的成员变量，若写错变量名，会抛出一个AttributeError，但是如果你重写了__getattr__，则可以自定义这一行为：

class foo:
    def __getattr__(self,name):
        return 'variable did not define'


print(foo().bar)

如上代码会打印字符串'variable did not define'而并不会报错，当然我们一般不希望变量在未定义之前就使用，所以最好还是抛出错误中止程序比较好。
__del__就是通常所说的析构函数，由于Python是自动GC的，和java相似，一个健康的设计不应该把释放资源的操作放进__del__，而是实现__enter__ __exit__方法并使用with关键字更加安全。
__new__和__init__则构成了构造函数，__new__是一个特殊的classmethod，它没有用@classmethod装饰，但是也接收类作为第一个参数，每当你实例化一个对象时，都会调用__new__，默认返回cls的一个实例，当然你可以通过修改__new__来使得它返回一个别的东西，当然一般不推荐这么做：

class foo:
    def __new__(cls):
        return 'hello'


print(foo())

类似上面的代码，将使得foo()对象变成一个'hello'字符串。
也许可以应用于过于冗长的函数或者类的别名？

class waibibabububububububu:
    def say_hi(self):
        print('hi')


class foo:
    def __new__(cls):
        return waibibabububububububu.__new__(waibibabububububububu)


foo().say_hi()

但是装饰器可以起到一样的效果，所以总的来说，没有必要去对__new__的返回类型作出修改，但是修改它的行为有可能是需要的，比如你需要实现一个单例模式时，这个以后再说。
另外可以看到，由于__new__没有使用@classmethod装饰，它并不会默认接收它的调用者作为第一个参数，所以这里显式地传递了一个类进去。
而__init__则是一个普通的成员方法，它默认接收调用它的实例self作为第一个参数，__init__的调用时机是在__new__内部创建实例时，也就是__new__返回之前就调用了__init__。
对于C++程序员来说__init__更接近于构造函数，大多数时候我们也只需要重写__init__，需要注意的是与C++不同，父类的__init__必须被显式调用才能执行：

class foo:
    def __init__(self):
        print('foo')


class bar(foo):
    def __init__(self):
        super().__init__()
        print('bar')

Python装饰器类

在函数一章中我们了解了用函数写的装饰器，而前面的staticmethod classmethod则是用类实现的装饰器，这是怎么做到的呢？
我们已经知道Python的函数本身也是一个callable对象，那么当一个普通对象具有和callable对象类似的属性时，这个对象也就可以作为函数使用了：

class decorator:

    def __init__(self, func):
        self.__func = func

    def __call__(self, *args, **kwds):
        print('decorate') 
        if self.__func is not None:
            self.__func(*args, **kwds)


@decorator
def foo(arg):
    print(arg)


foo('hello')

这里用到了Python类的一个内置方法：__call__，当你实现了一个类的__call__方法，那么这个类的对象就会成为一个callabe对象，可以使用后缀()的方式调用它的__call__方法。
而上面的装饰器严格等价于foo = decorator(foo)，即将foo类作为参数初始化了一个decorator对象，并将foo重新赋值为该对象，打印type(foo)，可以发现它的类型是<class '__main__.decorator'>。
带参的装饰器和复数个装饰器的例子可以参考函数一章，这里就不作展开了。只要记住@装饰器跟展开式是完全等价的，并且明白对象跟函数本质上是一样的，那么一切就都很好理解了。
下面是烧脑时间：

class decorator:

    def __init__(self, func):
        self.__func = func

    def __call__(self, *args, **kwds):
        def wrapper(*_arg):
            print(*_arg)
            if self.__func is not None:
                self.__func(*args, **kwds)
        return wrapper


def f1(arg):
    def wrapper(class_decorator):
        return class_decorator(arg)
    return wrapper


@f1('world')
@decorator
def foo(arg):
    print(arg)


foo('hello ')

以上代码会打印hello world，请整理出上面两个装饰器的调用过程。