【Python】面向对象整理

因为我有C++/Java面向对象的基础，所以这里的类和对象就不再多做解释。
面向对象都会有封装、继承、多态特性、下面一一介绍

数据封装

因为python是动态语言，所以对变量类型的控制不同于C++/Java等静态语言，以下面代码为例，其中定义了一个Student类，所有对象都继承与object，当然(object)这句可有可无。然后是定义__init__方法，python中类似__xxx__这中形式命名的是特殊变量/方法，所以我们在给变量和方法命名的时候尽量避免这种命名。__init__方法是我们所知道的构造方法，是在实例对象时所调用的方法，注意到__init__方法的第一个参数永远是self，表示创建的实例本身。而这里的name和score就是这个类的成员变量了。python就是这样来实现将数据和逻辑封装起来了。

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

访问限制

没有发现python中有public、private、protected，那么python是如何控制访问成员的访问权限呢？

>>> s = Student('rose', 59)
>>> s.score
59
>>> s.score = 99
>>> s.score
99

看上面的打印结果，外部代码还是可以自由地修改一个实例的name、score属性。
如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线__，在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了。
但是如果外部代码要获取name和score怎么办？可以给Student类增加get_name和get_score这样的方法：

class Student(object):
    ...
    def get_name(self):
        return self.__name

    def get_score(self):
        return self.__score

原先那种直接通过bart.score = 99也可以修改啊，为什么要定义一个方法大费周折？因为在方法中，可以对参数做检查，避免传入无效的参数
有些时候，你会看到以一个下划线开头的实例变量名，比如_name，这样的实例变量外部是可以访问的，但是，按照约定俗成的规定，当你看到这样的变量时，意思就是，“虽然我可以被访问，但是，请把我视为私有变量，不要随意访问”。
双下划线开头的实例变量是不是一定不能从外部访问呢？其实也不是。不能直接访问__name是因为Python解释器对外把__name变量改成了_Student__name ，所以，仍然可以通过_Student__name来访问__name变量，但是强烈建议你不要这么干，因为不同版本的Python解释器可能会把__name改成不同的变量名。

访问权限的注意点来了

>>> s = Student('Rose', 100)
>>> s.get_name()
'Rose'
>>> s.__name = 'new name'
>>> s.__name
'new name'
>>> s.get_name()
'Rose'

观察上面的打印，因为之前将__name属性为private，显示通过get_name()方法获取，然后又将s.__name修改了__name属性，也打印出来了新设置的属性，但是，为什么通过get_name()方法获取的__name属性没有改变呢？
因为python是动态语言，和之前学过的C++/Java有着明显的差异，python是可以给对象动态的绑定任何属性和方法，而这个__name属性和原来的__name不是一个属性！！上面说过“解释器对__的变量名字已经做了修改，所以不能直接访问”，但是现在动态的添加了新属性，所以，再访问这个新属性还是OK的。

使用__slots__

python不但可以给单独一个对象绑定实例和方法，还可以动态给class绑定方法：

>>> def set_score(self, score):
...     self.score = score
...
>>> Student.set_score = set_score

但是，如果我们想要限制实例的属性怎么办？比如，只允许对Student实例添加name和age属性。
为了达到限制的目的，Python允许在定义class的时候，定义一个特殊的__slots__变量，来限制该class实例能添加的属性：

class Student(object):
    __slots__ = ('name', 'score') # 用tuple定义允许绑定的属性名称

使用__slots__要注意，__slots__定义的属性仅对当前类实例起作用，对继承的子类是不起作用。

使用@property

对set和get方法那么获取和修改属性，看起来可能略显复杂，所以Python内置的@property装饰器就是负责把一个方法变成属性调用的。
把一个getter方法变成属性，只需要加上@property就可以了，此时，@property本身又创建了另一个装饰器@score.setter，负责把一个setter方法变成属性赋值，于是，我们就拥有一个可控的属性操作：

>>> s = Student()
>>> s.score = 60 	# OK，实际转化为s.set_score(60)
>>> s.score 		# OK，实际转化为s.get_score()
60
>>> s.score = 9999

综上，我封装了如下的Student：

#!/usr/bin/env python3
# -*- coding:utf-8 -*-


class Student:
    __slots__ = ('_Student__name', '_Student__score')

    def __init__(self, name = 'rose', score = 100):
        self.__name = name
        self.__score = score

    def print_name(self):
        print(self.__name)
        print(self.__score)

    @property
    def score(self):
        return self.__score

    @score.setter
    def score(self, value):
        self.__score = value
        

if __name__ == '__main__':
    s = Student()
    s.print_name()
    print(s.score)
    s.score = 200
    print(s.score)
    s.print_name()

实例属性和类属性

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

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

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

但是，如果Student类本身需要绑定一个属性呢？可以直接在class中定义属性，这种属性是类属性，归Student类所有：

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

从上面的例子可以看出，s有两个name属性，一个是Student的类属性，一个是实例s的实例属性。在编写程序的时候，千万不要对实例属性和类属性使用相同的名字，因为相同名称的实例属性将屏蔽掉类属性，但是当你删除实例属性后，再使用相同的名称，访问到的将是类属性。

继承&&多态

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

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

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


class Cat(Animal):
    pass

对于Dog来说，Animal就是它的父类，对于Animal来说，Dog就是它的子类。Cat和Dog类似

>>> c = Dog() 	# c是Dog类型
>>> isinstance(c, Animal)
True

要理解多态的好处，我们还需要再编写一个函数，这个函数接受一个Animal类型的变量：

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

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

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

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

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

鸭子类型

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

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

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

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

Python的“file-like object“就是一种鸭子类型。对真正的文件对象，它有一个read()方法，返回其内容。但是，许多对象，只要有read()方法，都被视为“file-like object“。许多函数接收的参数就是“file-like object“，你不一定要传入真正的文件对象，完全可以传入任何实现了read()方法的对象。

定制类

看到类似__slots__这种形如__xxx__的变量或者函数名就要注意，这些在Python中是有特殊用途的。
__slots__我们已经知道怎么用了，__len__()方法我们也知道是为了能让class作用于len()函数。
除此之外，Python的class中还有许多这样有特殊用途的函数，可以帮助我们定制类。

str && repr

>>> class Student(object):
...     def __init__(self, name):
...         self.name = name
...
>>> print(Student('Michael'))
<__main__.Student object at 0x109afb190>

这种打印并不好看，怎么才能打印得好看呢？只需要定义好__str__()方法，返回一个好看的字符串就可以了。

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

     def __str__(self):
         return 'Student object (name: %s)' % self.name

但是在交互模式下直接敲对象打印出来的还是那样不好看的：

>>> s = Student('Michael')
>>> s
<__main__.Student object at 0x109afb310>

这是因为直接显示变量调用的不是__str__()，而是__repr__()，两者的区别是__str__()返回用户看到的字符串，而__repr__()返回程序开发者看到的字符串，也就是说，__repr__()是为调试服务的。

iter && next

如果一个类想被用于for … in循环，类似list或tuple那样，就必须实现一个__iter__()方法，该方法返回一个迭代对象，然后，Python的for循环就会不断调用该迭代对象的__next__()方法拿到循环的下一个值，直到遇到StopIteration错误时退出循环。

我们以斐波那契数列为例，写一个Fib类，可以作用于for循环：

class Fib(object):
    def __init__(self):
        self.a, self.b = 0, 1 # 初始化两个计数器a，b

    def __iter__(self):
        return self # 实例本身就是迭代对象，故返回自己

    def __next__(self):
        self.a, self.b = self.b, self.a + self.b # 计算下一个值
        if self.a > 100000: # 退出循环的条件
            raise StopIteration()
        return self.a # 返回下一个值

还有一些特殊方法，就不一一说明了，在简单说明几个：
__getitem__是实现像list一样可以支持下标访问的
__getattr__正常情况下，当我们调用类的方法或属性时，如果不存在，就会报错。当调用不存在的属性时，比如score，Python解释器会试图调用__getattr__(self, 'score')来尝试获得属性，这样，我们就有机会返回score的值：

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

    def __getattr__(self, attr):
        if attr=='score':
            return 99

__call__无论何类，只需要定义一个__call__()方法，就可以直接对实例进行调用：

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

    def __call__(self):
        print('My name is %s.' % self.name)

>>> s = Student('Michael')
>>> s() # self参数不要传入
My name is Michael.