py3———函数类与对象

缺乏、安全感 2022-05-27 05:47 154阅读 0赞

内容来自 cookbook，中文翻译网站：[python3-cookbook][]

## 函数 ##

### 可变参数 ###

> 有时候构建了一个函数，但是接收参数的数量并不是确定的，为了能让一个函数接受任意数量的位置参数，这时候就可以使用可变参数

def avg(first, *rest):
        return (first + sum(rest)) / (1 + len(rest))
    
    avg(1,2)
    avg(1,2,3,4)

可变参数是以元组的形式传入函数内部的，在函数内代码中将它当成一个序列来进行后续的计算。

为了接受任意数量的关键字参数，可以使用 \*\* 开头，可变关键字参数是以字典的形式传入到函数内部。  
*函数中接收参数形式有以下几种：*

*  *def run(a): 位置参数，参数传递受参数的位置限制*
 *  *def run(a=1): 关键字参数，以键值对方式传入，不受参数位置影响*
 *  *def run(\*a): 可变参数*
 *  *def run(\*\*a): 可变关键字参数*  
    `函数中如果设定了多个类型的参数，可变参数应放在最后一个位置参数后，可变关键字参数必须放在最后`

### 只接受关键字参数的函数 ###

> 如果希望一个函数的某些参数强制使用关键字参数传递，将强制关键字参数放到某个\*参数或者单个\*后面就能达到这种效果

def recv(maxsize, *, block):
        'Receives a message'
        pass
    
    recv(1024, True) # TypeError
    recv(1024, block=True) # Ok

### 给函数参数增加元信息 ###

> 为函数的参数增加一些额外的信息，这样可以使其他使用者清楚的知道这个函数应该怎么使用。  
> 使用函数参数注解

def add(x:int,y:int) -> int:
        return x+y

### 函数返回多值 ###

def run():
        return 1,2,3
    
    a,b,c = run()

### 定义有默认值参数的函数 ###

> 定义一个函数或方法，他的一个或多个参数是可选的并且有一个默认值

def spam(a, b=42):
        print(a,b)
    
    spam(1) # Ok. a=1, b=42
    spam(1, 2) # Ok. a=1, b=2

`默认参数的值应该是不可变的对象！`

### 定义匿名或内联函数 ###

> 当你想实现一个简单的函数功能，又不想用def去写一个单行函数时，就可以使用匿名函数来解决

add = lambda x,y:x+y
    add(2,3)  # 5

## 类与对象 ##

### 改变对象的字符串显示 ###

> 改变对象实例的打印或显示输出，让他们更具有可读性。改变一个实例的字符串表示，可以重新定义它的 **str**() 和 **repr**()方法。

class Pair:
        def __init__(self, x, y):
            self.x = x
            self.y = y
    
        def __repr__(self):
            return 'Pair({0.x!r}, {0.y!r})'.format(self)
    
        def __str__(self):
            return '({0.x!s}, {0.y!s})'.format(self)

**repr**() 方法返回一个实例的代码表示形式，通常用来重新构造这个实例。内置的 repr() 函数返回这个字符串。**str**()方法将实例转换为一个字符串，使用str（）或print（）函数会输出这个字符串。

p = Pair(3, 4)
    p
    Pair(3, 4) # __repr__() output
    print(p)
    (3, 4) # __str__() output

### 自定义字符串的格式化 ###

> 通过 format() 函数和字符串方法是的一个对象能支持自定义的格式化。

在类上面定义 **format**() 方法

_formats = {
        'ymd' : '{d.year}-{d.month}-{d.day}',
        'mdy' : '{d.month}/{d.day}/{d.year}',
        'dmy' : '{d.day}/{d.month}/{d.year}'
        }
    
    class Date:
        def __init__(self, year, month, day):
            self.year = year
            self.month = month
            self.day = day
    
        def __format__(self, code):
            if code == '':
                code = 'ymd'
            fmt = _formats[code]
            return fmt.format(d=self)

>>> d = Date(2012, 12, 21)
    >>> format(d)
    '2012-12-21'
    >>> format(d, 'mdy')
    '12/21/2012'
    >>> 'The date is {:ymd}'.format(d)
    'The date is 2012-12-21'
    >>> 'The date is {:mdy}'.format(d)
    'The date is 12/21/2012'

***format**() 方法给Python的字符串格式化功能提供了一个钩子。 这里需要着重强调的是格式化代码的解析工作完全由类自己决定。因此，格式化代码可以是任何值。*

### 让对象支持上下文管理协议 ###

> 让对象支持上下文管理协议（with 语句）

让一个对象兼容with语句，需要实现 **enter**() 和**exit**() 方法

from socket import socket, AF_INET, SOCK_STREAM
    
    class LazyConnection:
        def __init__(self, address, family=AF_INET, type=SOCK_STREAM):
            self.address = address
            self.family = family
            self.type = type
            self.sock = None
    
        def __enter__(self):
            if self.sock is not None:
                raise RuntimeError('Already connected')
            self.sock = socket(self.family, self.type)
            self.sock.connect(self.address)
            return self.sock
    
        def __exit__(self, exc_ty, exc_val, tb):
            self.sock.close()
            self.sock = None

这个类的关键特点在于它表示了一个网络连接，但是初始化的时候并不会做任何事情(比如它并没有建立一个连接)。 连接的建立和关闭是使用 with 语句自动完成的，例如：

from functools import partial
    
    conn = LazyConnection(('www.python.org', 80))
    # Connection closed
    with conn as s:
        # conn.__enter__() executes: connection open
        s.send(b'GET /index.html HTTP/1.0\r\n')
        s.send(b'Host: www.python.org\r\n')
        s.send(b'\r\n')
        resp = b''.join(iter(partial(s.recv, 8192), b''))
        # conn.__exit__() executes: connection closed

编写上下文管理器的主要原理是你的代码会放到 with 语句块中执行。 当出现 with 语句的时候，对象的 **enter**() 方法被触发， 它返回的值(如果有的话)会被赋值给 as 声明的变量。然后，with 语句块里面的代码开始执行。 最后，**exit**() 方法被触发进行清理工作。

不管 with 代码块中发生什么，上面的控制流都会执行完，就算代码块中发生了异常也是一样的。 事实上，**exit**() 方法的第三个参数包含了异常类型、异常值和追溯信息(如果有的话)。 **exit**() 方法能自己决定怎样利用这个异常信息，或者忽略它并返回一个None值。 如果 **exit**() 返回 True ，那么异常会被清空，就好像什么都没发生一样， with 语句后面的程序继续在正常执行。  
还有一个细节问题就是 LazyConnection 类是否允许多个 with 语句来嵌套使用连接。 很显然，上面的定义中一次只能允许一个socket连接，如果正在使用一个socket的时候又重复使用 with 语句， 就会产生一个异常了。不过你可以像下面这样修改下上面的实现来解决这个问题：

from socket import socket, AF_INET, SOCK_STREAM
    
    class LazyConnection:
        def __init__(self, address, family=AF_INET, type=SOCK_STREAM):
            self.address = address
            self.family = family
            self.type = type
            self.connections = []
    
        def __enter__(self):
            sock = socket(self.family, self.type)
            sock.connect(self.address)
            self.connections.append(sock)
            return sock
    
        def __exit__(self, exc_ty, exc_val, tb):
            self.connections.pop().close()
    
    # Example use
    from functools import partial
    
    conn = LazyConnection(('www.python.org', 80))
    with conn as s1:
        pass
        with conn as s2:
            pass
            # s1 and s2 are independent sockets

在第二个版本中，LazyConnection 类可以被看做是某个连接工厂。在内部，一个列表被用来构造一个栈。 每次 **enter**() 方法执行的时候，它复制创建一个新的连接并将其加入到栈里面。 **exit**() 方法简单的从栈中弹出最后一个连接并关闭它。 这里稍微有点难理解，不过它能允许嵌套使用 with 语句创建多个连接，就如上面演示的那样。

在需要管理一些资源比如文件、网络连接和锁的编程环境中，使用上下文管理器是很普遍的。 这些资源的一个主要特征是它们必须被手动的关闭或释放来确保程序的正确运行。 例如，如果你请求了一个锁，那么你必须确保之后释放了它，否则就可能产生死锁。 通过实现 **enter**() 和 **exit**() 方法并使用 with 语句可以很容易的避免这些问题， 因为 **exit**() 方法可以让你无需担心这些了。

### 创建大量对象时节省内存方法 ###

> 当程序要创建大量（上百万）的对象，导致占用很大的内存时，对于主要是用来当成简单的数据结构的类而言，可以通过给类添加 **slots**属性来极大的减少实例所占的内存。比如：

class Date:
        __slots__ = ['year', 'month', 'day']
        def __init__(self, year, month, day):
            self.year = year
            self.month = month
            self.day = day

当你定义 **slots** 后，Python就会为实例使用一种更加紧凑的内部表示。 实例通过一个很小的固定大小的数组来构建，而不是为每个实例定义一个字典，这跟元组或列表很类似。 在 **slots** 中列出的属性名在内部被映射到这个数组的指定小标上。 使用slots一个不好的地方就是我们不能再给实例添加新的属性了，只能使用在 **slots** 中定义的那些属性名。  
**AND** :  
使用slots后节省的内存会跟存储属性的数量和类型有关。 不过，一般来讲，使用到的内存总量和将数据存储在一个元组中差不多。 为了给你一个直观认识，假设你不使用slots直接存储一个Date实例， 在64位的Python上面要占用428字节，而如果使用了slots，内存占用下降到156字节。 如果程序中需要同时创建大量的日期实例，那么这个就能极大的减小内存使用量了。

尽管slots看上去是一个很有用的特性，很多时候你还是得减少对它的使用冲动。 Python的很多特性都依赖于普通的基于字典的实现。 另外，定义了slots后的类不再支持一些普通类特性了，比如多继承。 大多数情况下，你应该只在那些经常被使用到的用作数据结构的类上定义slots (比如在程序中需要创建某个类的几百万个实例对象)。

关于 **slots** 的一个常见误区是它可以作为一个封装工具来防止用户给实例增加新的属性。 尽管使用slots可以达到这样的目的，但是这个并不是它的初衷。 **slots** 更多的是用来作为一个内存优化工具。

### 在类中封装属性名 ###

> 在python语言中并没有访问控制，如果想封装类的实例上面的“私有数据”，可以通过遵循一定的属性和方法命名规约来达到这个效果，

*  任何以单下划线 \_ 开头的名字都应该是内部实现。

class A:
        def __init__(self):
            self._internal = 0 # An internal attribute
            self.public = 1 # A public attribute
    
        def public_method(self):
            ''' A public method '''
            pass
    
        def _internal_method(self):
            pass

Python并不会真的阻止别人访问内部名称。但是如果你这么做肯定是不好的，可能会导致脆弱的代码。 同时还要注意到，使用下划线开头的约定同样适用于模块名和模块级别函数。 例如，如果你看到某个模块名以单下划线开头(比如\_socket)，那它就是内部实现。 类似的，模块级别函数比如 sys.\_getframe() 在使用的时候就得加倍小心了。

*  在类定义中使用两个下划线 （\_\_）开头的命名

class B:
        def __init__(self):
            self.__private = 0
    
        def __private_method(self):
            pass
    
        def public_method(self):
            pass
            self.__private_method()

使用双下划线开始会导致访问名称变成其他形式。 比如，在前面的类B中，私有属性会被分别重命名为 \_B\_\_private 和 \_B\_\_private\_method 。 这时候你可能会问这样重命名的目的是什么，答案就是继承——这种属性通过继承是无法被覆盖的。比如：

class C(B):
        def __init__(self):
            super().__init__()
            self.__private = 1 # Does not override B.__private
    
        # Does not override B.__private_method()
        def __private_method(self):
            pass

这里，私有名称 \_\_private 和 \_\_private\_method 被重命名为 \_C\_\_private 和 \_C\_\_private\_method ，这个跟父类B中的名称是完全不同的。  
**AND**:  
上面提到有两种不同的编码约定(单下划线和双下划线)来命名私有属性，那么问题就来了：到底哪种方式好呢？ 大多数而言，你应该让你的非公共名称以单下划线开头。但是，如果你清楚你的代码会涉及到子类， 并且有些内部属性应该在子类中隐藏起来，那么才考虑使用双下划线方案。

还有一点要注意的是，有时候你定义的一个变量和某个保留关键字冲突，这时候可以使用单下划线作为后缀，例如：

lambda\_ = 2.0 \# Trailing \_ to avoid clash with lambda keyword  
这里我们并不使用单下划线前缀的原因是它避免误解它的使用初衷 (如使用单下划线前缀的目的是为了防止命名冲突而不是指明这个属性是私有的)。 通过使用单下划线后缀可以解决这个问题。

### 创建可管理的属性 ###

> 给某个实例attribute增加除访问与修改之外的其他处理逻辑，比如类型检查或合法性验证。

自定义某个属性的一种简单方法是将它定义为一个 property 。  
例如增加对一个属性简单的类型检查：

class Person:
        def __init__(self, first_name):
            self.first_name = first_name
    
        # Getter function
        @property
        def first_name(self):
            return self._first_name
    
        # Setter function
        @first_name.setter
        def first_name(self, value):
            if not isinstance(value, str):
                raise TypeError('Expected a string')
            self._first_name = value
    
        # Deleter function (optional)
        @first_name.deleter
        def first_name(self):
            raise AttributeError("Can't delete attribute")

上述代码中有三个相关联的方法，这三个方法的名字都必须一样。 第一个方法是一个 getter 函数，它使得 first\_name 成为一个属性。 其他两个方法给 first\_name 属性添加了 setter 和 deleter 函数。 需要强调的是只有在 first\_name 属性被创建后， 后面的两个装饰器 @first\_name.setter 和 @first\_name.deleter 才能被定义。

property的一个关键特征是它看上去跟普通的attribute没什么两样， 但是访问它的时候会自动触发 getter 、setter 和 deleter 方法。例如：

a = Person('Guido')
    a.first_name # Calls the getter
    'Guido'
    a.first_name = 42 # Calls the setter
    Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
        File "prop.py", line 14, in first_name
            raise TypeError('Expected a string')
    TypeError: Expected a string
    del a.first_name
    Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
    AttributeError: can`t delete attribute

在实现一个property的时候，底层数据(如果有的话)仍然需要存储在某个地方。 因此，在get和set方法中，你会看到对 \_first\_name 属性的操作，这也是实际数据保存的地方。 另外，你可能还会问为什么 **init**() 方法中设置了 self.first\_name 而不是 self.\_first\_name 。 在这个例子中，我们创建一个property的目的就是在设置attribute的时候进行检查。 因此，你可能想在初始化的时候也进行这种类型检查。通过设置 self.first\_name ，自动调用 setter 方法， 这个方法里面会进行参数的检查，否则就是直接访问 self.\_first\_name 了。

还能在已存在的get和set方法基础上定义property。例如：

class Person:
        def __init__(self, first_name):
            self.set_first_name(first_name)
    
        # Getter function
        def get_first_name(self):
            return self._first_name
    
        # Setter function
        def set_first_name(self, value):
            if not isinstance(value, str):
                raise TypeError('Expected a string')
            self._first_name = value
    
        # Deleter function (optional)
        def del_first_name(self):
            raise AttributeError("Can't delete attribute")
    
        # Make a property from existing get/set methods
        name = property(get_first_name, set_first_name, del_first_name)

**AND**:  
一个property属性其实就是一系列相关绑定方法的集合。如果你去查看拥有property的类， 就会发现property本身的fget、fset和fdel属性就是类里面的普通方法。比如：

>>> Person.first_name.fget
    <function Person.first_name at 0x1006a60e0>
    >>> Person.first_name.fset
    <function Person.first_name at 0x1006a6170>
    >>> Person.first_name.fdel
    <function Person.first_name at 0x1006a62e0>

通常来讲，你不会直接取调用fget或者fset，它们会在访问property的时候自动被触发。

只有当你确实需要对attribute执行其他额外的操作的时候才应该使用到property。 有时候一些从其他编程语言(比如Java)过来的程序员总认为所有访问都应该通过getter和setter， 所以他们认为代码应该像下面这样写：

class Person:
        def __init__(self, first_name):
            self.first_name = first_name
    
        @property
        def first_name(self):
            return self._first_name
    
        @first_name.setter
        def first_name(self, value):
            self._first_name = value

不要写这种没有做任何其他额外操作的property。 首先，它会让你的代码变得很臃肿，并且还会迷惑阅读者。 其次，它还会让你的程序运行起来变慢很多。 最后，这样的设计并没有带来任何的好处。 特别是当你以后想给普通attribute访问添加额外的处理逻辑的时候， 你可以将它变成一个property而无需改变原来的代码。 因为访问attribute的代码还是保持原样。

Properties还是一种定义动态计算attribute的方法。 这种类型的attributes并不会被实际的存储，而是在需要的时候计算出来。比如：

import math
    class Circle:
        def __init__(self, radius):
            self.radius = radius
    
        @property
        def area(self):
            return math.pi * self.radius ** 2
    
        @property
        def diameter(self):
            return self.radius * 2
    
        @property
        def perimeter(self):
            return 2 * math.pi * self.radius

在这里，我们通过使用properties，将所有的访问接口形式统一起来， 对半径、直径、周长和面积的访问都是通过属性访问，就跟访问简单的attribute是一样的。 如果不这样做的话，那么就要在代码中混合使用简单属性访问和方法调用。 下面是使用的实例：

>>> c = Circle(4.0)
    >>> c.radius
    4.0
    >>> c.area  # Notice lack of ()
    50.26548245743669
    >>> c.perimeter  # Notice lack of ()
    25.132741228718345

尽管properties可以实现优雅的编程接口，但有些时候你还是会想直接使用getter和setter函数。例如：

>>> p = Person('Guido')
    >>> p.get_first_name()
    'Guido'
    >>> p.set_first_name('Larry')

这种情况的出现通常是因为Python代码被集成到一个大型基础平台架构或程序中。 例如，有可能是一个Python类准备加入到一个基于远程过程调用的大型分布式系统中。 这种情况下，直接使用get/set方法(普通方法调用)而不是property或许会更容易兼容。

最后一点，不要像下面这样写有大量重复代码的property定义：

class Person:
        def __init__(self, first_name, last_name):
            self.first_name = first_name
            self.last_name = last_name
    
        @property
        def first_name(self):
            return self._first_name
    
        @first_name.setter
        def first_name(self, value):
            if not isinstance(value, str):
                raise TypeError('Expected a string')
            self._first_name = value
    
        # Repeated property code, but for a different name (bad!)
        @property
        def last_name(self):
            return self._last_name
    
        @last_name.setter
        def last_name(self, value):
            if not isinstance(value, str):
                raise TypeError('Expected a string')
            self._last_name = value

### 调用父类的方法 ###

> 在子类中调用父类的某个已经被覆盖的方法，可以使用 super() 函数

class A:
        def spam(self):
            print('A.spam')
    
    class B(A):
        def spam(self):
            print('B.spam')
            super().spam()  # Call parent spam()

super() 函数的一个常见用法是在 **init**() 方法中确保父类被正确的初始化了：

class A:
        def __init__(self):
            self.x = 0
    
    class B(A):
        def __init__(self):
            super().__init__()
            self.y = 1

super() 的另外一个常见用法出现在覆盖 python 特殊方法的代码中，比如：

class Proxy:
        def __init__(self, obj):
            self._obj = obj
    
        # Delegate attribute lookup to internal obj
        def __getattr__(self, name):
            return getattr(self._obj, name)
    
        # Delegate attribute assignment
        def __setattr__(self, name, value):
            if name.startswith('_'):
                super().__setattr__(name, value) # Call original __setattr__
            else:
                setattr(self._obj, name, value)

在上面代码中，**setattr**() 的实现包含一个名字检查。 如果某个属性名以下划线(\_)开头，就通过 super() 调用原始的 **setattr**() ， 否则的话就委派给内部的代理对象 self.\_obj 去处理。 这看上去有点意思，因为就算没有显式的指明某个类的父类， super() 仍然可以有效的工作。  
**AND**:  
实际上，大家对于在Python中如何正确使用 super() 函数普遍知之甚少。 你有时候会看到像下面这样直接调用父类的一个方法：

class Base:
        def __init__(self):
            print('Base.__init__')
    
    class A(Base):
        def __init__(self):
            Base.__init__(self)
            print('A.__init__')

尽管对于大部分代码而言这么做没什么问题，但是在更复杂的涉及到多继承的代码中就有可能导致很奇怪的问题发生。 比如，考虑如下的情况：

class Base:
        def __init__(self):
            print('Base.__init__')
    
    class A(Base):
        def __init__(self):
            Base.__init__(self)
            print('A.__init__')
    
    class B(Base):
        def __init__(self):
            Base.__init__(self)
            print('B.__init__')
    
    class C(A,B):
        def __init__(self):
            A.__init__(self)
            B.__init__(self)
            print('C.__init__')

如果你运行这段代码就会发现 Base.**init**() 被调用两次，如下所示:

c = C()
    Base.__init__
    A.__init__
    Base.__init__
    B.__init__
    C.__init__

可能两次调用 Base.**init**() 没什么坏处，但有时候却不是。 另一方面，假设你在代码中换成使用 super() ，结果就很完美了：

class Base:
        def __init__(self):
            print('Base.__init__')
    
    class A(Base):
        def __init__(self):
            super().__init__()
            print('A.__init__')
    
    class B(Base):
        def __init__(self):
            super().__init__()
            print('B.__init__')
    
    class C(A,B):
        def __init__(self):
            super().__init__()  # Only one call to super() here
            print('C.__init__')

运行这个新版本后，你会发现每个 **init**() 方法只会被调用一次了：

c = C()
    Base.__init__
    B.__init__
    A.__init__
    C.__init__

python关于继承的顺序是按照MRO列表从左到右来进行的

>>> C.__mro__
    (<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class '__main__.Base'>, <class 'object'>) >>>

为了实现继承，Python会在MRO列表上从左到右开始查找基类，直到找到第一个匹配这个属性的类为止。

MRO 遵循一下三条准则：

*  子类会先于父类被检查
 *  多个父类会根据它们在列表中的顺序被检查
 *  如果对下一个类存在两个合法的选择，选择第一个父类

### 在子类中扩展property ###

> 在子类中扩展定义在父类中的property的功能：

class Person:
        def __init__(self, name):
            self.name = name
    
        # Getter function
        @property
        def name(self):
            return self._name
    
        # Setter function
        @name.setter
        def name(self, value):
            if not isinstance(value, str):
                raise TypeError('Expected a string')
            self._name = value
    
        # Deleter function
        @name.deleter
        def name(self):
            raise AttributeError("Can't delete attribute")

继承自 Person 并扩展 name属性

class SubPerson(Person):
        @property
        def name(self):
            print('Getting name')
            return super().name
    
        @name.setter
        def name(self, value):
            print('Setting name to', value)
            super(SubPerson, SubPerson).name.__set__(self, value)
    
        @name.deleter
        def name(self):
            print('Deleting name')
            super(SubPerson, SubPerson).name.__delete__(self)

开始使用这个新类：

>>> s = SubPerson('Guido')
    Setting name to Guido
    >>> s.name
    Getting name
    'Guido'
    >>> s.name = 'Larry'
    Setting name to Larry
    >>> s.name = 42
    Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
        File "example.py", line 16, in name
            raise TypeError('Expected a string')
    TypeError: Expected a string

如果只想扩展 property 的某一个方法，那么可以直接这样写：

class SubPerson(Person):
        @Person.name.getter
        def name(self):
            print('Getting name')
            return super().name

或者是只想修改setter方法：

class SubPerson(Person):
        @Person.name.setter
        def name(self, value):
            print('Setting name to', value)
            super(SubPerson, SubPerson).name.__set__(self, value)

**AND**:  
在子类中扩展一个property可能会引起很多不易察觉的问题， 因为一个property其实是 getter、setter 和 deleter 方法的集合，而不是单个方法。 因此，当你扩展一个property的时候，你需要先确定你是否要重新定义所有的方法还是说只修改其中某一个。

在第一个例子中，所有的property方法都被重新定义。 在每一个方法中，使用了 super() 来调用父类的实现。 在 setter 函数中使用 super(SubPerson, SubPerson).name.**set**(self, value) 的语句是没有错的。 为了委托给之前定义的setter方法，需要将控制权传递给之前定义的name属性的 **set**() 方法。 不过，获取这个方法的唯一途径是使用类变量而不是实例变量来访问它。 这也是为什么我们要使用 super(SubPerson, SubPerson) 的原因。

### 创建新的类或实例属性 ###

> 创建新的类或实例属性，可以通过一个描述器类的形式来定义它的功能

class Integer:
        def __init__(self, name):
            self.name = name
    
        def __get__(self, instance, cls):
            if instance is None:
                return self
            else:
                return instance.__dict__[self.name]
    
        def __set__(self, instance, value):
            if not isinstance(value, int):
                raise TypeError('Expected an int')
            instance.__dict__[self.name] = value
    
        def __delete__(self, instance):
            del instance.__dict__[self.name]

一个描述器就是一个实现了三个核心的属性访问操作(get, set, delete)的类， 分别为 **get**() 、**set**() 和 **delete**() 这三个特殊的方法。 这些方法接受一个实例作为输入，之后相应的操作实例底层的字典。

为了使用一个描述器，需将这个描述器的实例作为类属性放到一个类的定义中。例如：

class Point:
        x = Integer('x')
        y = Integer('y')
    
        def __init__(self, x, y):
            self.x = x
            self.y = y

当你这样做后，所有对描述器属性(比如x或y)的访问会被 **get**() 、**set**() 和 **delete**() 方法捕获到。例如：

>>> p = Point(2, 3)
    >>> p.x # Calls Point.x.__get__(p,Point)
    2
    >>> p.y = 5 # Calls Point.y.__set__(p, 5)
    >>> p.x = 2.3 # Calls Point.x.__set__(p, 2.3)
    Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
        File "descrip.py", line 12, in __set__
            raise TypeError('Expected an int')
    TypeError: Expected an int
    >>>

作为输入，描述器的每一个方法会接受一个操作实例。 为了实现请求操作，会相应的操作实例底层的字典(**dict**属性)。 描述器的 self.name 属性存储了在实例字典中被实际使用到的key。

### 使用延迟计算属性 ###

> 将一个只读属性定义成一个property，并且只在访问的时候才会计算结果。 但是一旦被访问后，你希望结果值被缓存起来，不用每次都去计算。

定义一个延迟属性的一种高效方法是通过使用和一个描述器类，如下所示：

class lazyproperty:
        def __init__(self, func):
            self.func = func
    
        def __get__(self, instance, cls):
            if instance is None:
                return self
            else:
                value = self.func(instance)
                setattr(instance, self.func.__name__, value)
                return value

在下面的这个类中使用它：

import math
    
    class Circle:
        def __init__(self, radius):
            self.radius = radius
    
        @lazyproperty
        def area(self):
            print('Computing area')
            return math.pi * self.radius ** 2
    
        @lazyproperty
        def perimeter(self):
            print('Computing perimeter')
            return 2 * math.pi * self.radius

使用演示：

>>> c = Circle(4.0)
    >>> c.radius
    4.0
    >>> c.area
    Computing area
    50.26548245743669
    >>> c.area
    50.26548245743669
    >>> c.perimeter
    Computing perimeter
    25.132741228718345
    >>> c.perimeter
    25.132741228718345
    >>>

### 简化数据结构的初始化 ###

> 需要很多仅仅用作数据结构的类，不想写太多烦人的 **init** () 函数：

可以在一个基类中写一个公用的 **init**() 函数：

import math
    class Structure1:
        # Class variable that specifies expected fields
        _fields = []
    
        def __init__(self, *args):
            if len(args) != len(self._fields):
                raise TypeError('Expected {} arguments'.format(len(self._fields)))
            # Set the arguments
            for name, value in zip(self._fields, args):
                setattr(self, name, value)

然后使你的类继承自这个基类：

# Example class definitions
    class Stock(Structure1):
        _fields = ['name', 'shares', 'price']
    
    class Point(Structure1):
        _fields = ['x', 'y']
    
    class Circle(Structure1):
        _fields = ['radius']
    
        def area(self):
            return math.pi * self.radius ** 2

使用演示：

>>> s = Stock('ACME', 50, 91.1)
    >>> p = Point(2, 3)
    >>> c = Circle(4.5)
    >>> s2 = Stock('ACME', 50)
    Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
        File "structure.py", line 6, in __init__
            raise TypeError('Expected {} arguments'.format(len(self._fields)))
    TypeError: Expected 3 arguments

将关键字参数设置为实例属性：

class Structure2:
        _fields = []
    
        def __init__(self, *args, **kwargs):
            if len(args) > len(self._fields):
                raise TypeError('Expected {} arguments'.format(len(self._fields)))
    
            # Set all of the positional arguments
            for name, value in zip(self._fields, args):
                setattr(self, name, value)
    
            # Set the remaining keyword arguments
            for name in self._fields[len(args):]:
                setattr(self, name, kwargs.pop(name))
    
            # Check for any remaining unknown arguments
            if kwargs:
                raise TypeError('Invalid argument(s): {}'.format(','.join(kwargs)))
    # Example use
    if __name__ == '__main__':
        class Stock(Structure2):
            _fields = ['name', 'shares', 'price']
    
        s1 = Stock('ACME', 50, 91.1)
        s2 = Stock('ACME', 50, price=91.1)
        s3 = Stock('ACME', shares=50, price=91.1)
        # s3 = Stock('ACME', shares=50, price=91.1, aa=1)

将不在 \_fields 中的名称加入到属性中去：

class Structure3:
        # Class variable that specifies expected fields
        _fields = []
    
        def __init__(self, *args, **kwargs):
            if len(args) != len(self._fields):
                raise TypeError('Expected {} arguments'.format(len(self._fields)))
    
            # Set the arguments
            for name, value in zip(self._fields, args):
                setattr(self, name, value)
    
            # Set the additional arguments (if any)
            extra_args = kwargs.keys() - self._fields
            for name in extra_args:
                setattr(self, name, kwargs.pop(name))
    
            if kwargs:
                raise TypeError('Duplicate values for {}'.format(','.join(kwargs)))
    
    # Example use
    if __name__ == '__main__':
        class Stock(Structure3):
            _fields = ['name', 'shares', 'price']
    
        s1 = Stock('ACME', 50, 91.1)
        s2 = Stock('ACME', 50, 91.1, date='8/2/2012')

将不在 \_fields 中的名称加入到属性中去：

### 定义接口或者抽象基类 ###

> 定义一个接口或抽象类，并且通过执行类型检查来确保子类实现了某些特定的方法

使用abc模块定义抽象基类

from abc import ABCMeta, abstractmethod
    
    class IStream(metaclass=ABCMeta):
        @abstractmethod
        def read(self, maxbytes=-1):
            pass
    
        @abstractmethod
        def write(self, data):
            pass

抽象类的一个特点是它不能直接被实例化，比如你想像下面这样做是不行的：  
a = IStream()  
抽象类的目的就是让别的类继承它并实现特定的抽象方法：

class SocketStream(IStream):
        def read(self, maxbytes=-1):
            pass
    
        def write(self, data):
            pass

抽象基类的一个主要用途是在代码中检查某些类是否为特定类型，实现了特定接口：

def serialize(obj, stream):
        if not isinstance(stream, IStream):
            raise TypeError('Expected an IStream')
        pass

除了继承这种方式外，还可以通过注册方式来让某个类实现抽象基类：

import io
    
    # Register the built-in I/O classes as supporting our interface
    IStream.register(io.IOBase)
    
    # Open a normal file and type check
    f = open('foo.txt')
    isinstance(f, IStream) # Returns True

@abstractmethod 还能注解静态方法、类方法和 properties 。 你只需保证这个注解紧靠在函数定义前即可：

class A(metaclass=ABCMeta):
        @property
        @abstractmethod
        def name(self):
            pass
    
        @name.setter
        @abstractmethod
        def name(self, value):
            pass
    
        @classmethod
        @abstractmethod
        def method1(cls):
            pass
    
        @staticmethod
        @abstractmethod
        def method2():
            pass

### 实现数据模型的类型约束 ###

> 定义某些在属性赋值上面有限制的数据结构

下面的代码使用描述器实现了一个系统类型和赋值验证框架

# Base class. Uses a descriptor to set a value
    class Descriptor:
        def __init__(self, name=None, **opts):
            self.name = name
            for key, value in opts.items():
                setattr(self, key, value)
    
        def __set__(self, instance, value):
            instance.__dict__[self.name] = value
    
    
    # Descriptor for enforcing types
    class Typed(Descriptor):
        expected_type = type(None)
    
        def __set__(self, instance, value):
            if not isinstance(value, self.expected_type):
                raise TypeError('expected ' + str(self.expected_type))
            super().__set__(instance, value)
    
    
    # Descriptor for enforcing values
    class Unsigned(Descriptor):
        def __set__(self, instance, value):
            if value < 0:
                raise ValueError('Expected >= 0')
            super().__set__(instance, value)
    
    
    class MaxSized(Descriptor):
        def __init__(self, name=None, **opts):
            if 'size' not in opts:
                raise TypeError('missing size option')
            super().__init__(name, **opts)
    
        def __set__(self, instance, value):
            if len(value) >= self.size:
                raise ValueError('size must be < ' + str(self.size))
            super().__set__(instance, value)

这些类就是你要创建的数据模型或类型系统的基础构建模块。 下面就是我们实际定义的各种不同的数据类型：

class Integer(Typed):
        expected_type = int
    
    class UnsignedInteger(Integer, Unsigned):
        pass
    
    class Float(Typed):
        expected_type = float
    
    class UnsignedFloat(Float, Unsigned):
        pass
    
    class String(Typed):
        expected_type = str
    
    class SizedString(String, MaxSized):
        pass

然后使用这些自定义数据类型，我们定义一个类：

class Stock:
        # Specify constraints
        name = SizedString('name', size=8)
        shares = UnsignedInteger('shares')
        price = UnsignedFloat('price')
    
        def __init__(self, name, shares, price):
            self.name = name
            self.shares = shares
            self.price = price

然后测试这个类的属性赋值约束，可发现对某些属性的赋值违法了约束是不合法的：

>>> s.name
    'ACME'
    >>> s.shares = 75
    >>> s.shares = -10
    Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
        File "example.py", line 17, in __set__
            super().__set__(instance, value)
        File "example.py", line 23, in __set__
            raise ValueError('Expected >= 0')
    ValueError: Expected >= 0
    >>> s.price = 'a lot'
    Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
        File "example.py", line 16, in __set__
            raise TypeError('expected ' + str(self.expected_type))
    TypeError: expected <class 'float'> >>> s.name = 'ABRACADABRA' Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
        File "example.py", line 17, in __set__
            super().__set__(instance, value)
        File "example.py", line 35, in __set__
            raise ValueError('size must be < ' + str(self.size))
    ValueError: size must be < 8
    >>>

下面还可以使用装饰器来简化上面的代码：

# Class decorator to apply constraints
    def check_attributes(**kwargs):
        def decorate(cls):
            for key, value in kwargs.items():
                if isinstance(value, Descriptor):
                    value.name = key
                    setattr(cls, key, value)
                else:
                    setattr(cls, key, value(key))
            return cls
    
        return decorate
    
    # Example
    @check_attributes(name=SizedString(size=8),
                      shares=UnsignedInteger,
                      price=UnsignedFloat)
    class Stock:
        def __init__(self, name, shares, price):
            self.name = name
            self.shares = shares
            self.price = price

另一种方式是使用元类：

# A metaclass that applies checking
    class checkedmeta(type):
        def __new__(cls, clsname, bases, methods):
            # Attach attribute names to the descriptors
            for key, value in methods.items():
                if isinstance(value, Descriptor):
                    value.name = key
            return type.__new__(cls, clsname, bases, methods)
    
    # Example
    class Stock2(metaclass=checkedmeta):
        name = SizedString(size=8)
        shares = UnsignedInteger()
        price = UnsignedFloat()
    
        def __init__(self, name, shares, price):
            self.name = name
            self.shares = shares
            self.price = price

**AND**:  
在 Descriptor 基类中你会看到有个\_\_set\_\_() 方法，却没有相应的 \_\_get\_\_() 方法。 如果一个描述仅仅是从底层实例字典中获取某个属性值的话，那么没必要去定义 \_\_get\_\_() 方法。

### 实现自定义容器 ###

> 想实现一个自定义的类来模拟内置的容器类功能，比如列表和字典。但是你不确定到底要实现哪些方法。

collections 定义了很多抽象基类，当你想自定义容器类的时候它们会非常有用。 比如你想让你的类支持迭代，那就让你的类继承 collections.Iterable 即可：

import collections
    class A(collections.Iterable):
        pass

不过你需要实现 collections.Iterable 所有的抽象方法，否则会报错:

> > > a = A()  
> > > Traceback (most recent call last):  
> > > File “”, line 1, in  
> > > TypeError: Can’t instantiate abstract class A with abstract methods **iter**
> > > 
> > > 你只要实现 **iter**() 方法就不会报错了(参考4.2和4.7小节)。

你可以先试着去实例化一个对象，在错误提示中可以找到需要实现哪些方法：

>>> import collections
    >>> collections.Sequence()
    Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
    TypeError: Can't instantiate abstract class Sequence with abstract methods \ __getitem__, __len__

下面是一个简单的示例，继承自上面Sequence抽象类，并且实现元素按照顺序存储：

class SortedItems(collections.Sequence):
        def __init__(self, initial=None):
            self._items = sorted(initial) if initial is not None else []
    
        # Required sequence methods
        def __getitem__(self, index):
            return self._items[index]
    
        def __len__(self):
            return len(self._items)
    
        # Method for adding an item in the right location
        def add(self, item):
            bisect.insort(self._items, item)
    
    items = SortedItems([5, 1, 3])
    print(list(items))
    print(items[0], items[-1])
    items.add(2)
    print(list(items))

可以看到，SortedItems跟普通的序列没什么两样，支持所有常用操作，包括索引、迭代、包含判断，甚至是切片操作。

这里面使用到了 bisect 模块，它是一个在排序列表中插入元素的高效方式。可以保证元素插入后还保持顺序。

**AND**:  
使用 collections 中的抽象基类可以确保你自定义的容器实现了所有必要的方法。并且还能简化类型检查。 你的自定义容器会满足大部分类型检查需要，如下所示：

>>> items = SortedItems()
    >>> import collections
    >>> isinstance(items, collections.Iterable)
    True
    >>> isinstance(items, collections.Sequence)
    True
    >>> isinstance(items, collections.Container)
    True
    >>> isinstance(items, collections.Sized)
    True
    >>> isinstance(items, collections.Mapping)
    False

collections 中很多抽象类会为一些常见容器操作提供默认的实现， 这样一来你只需要实现那些你最感兴趣的方法即可。假设你的类继承自 collections.MutableSequence ，如下：

class Items(collections.MutableSequence):
        def __init__(self, initial=None):
            self._items = list(initial) if initial is not None else []
    
        # Required sequence methods
        def __getitem__(self, index):
            print('Getting:', index)
            return self._items[index]
    
        def __setitem__(self, index, value):
            print('Setting:', index, value)
            self._items[index] = value
    
        def __delitem__(self, index):
            print('Deleting:', index)
            del self._items[index]
    
        def insert(self, index, value):
            print('Inserting:', index, value)
            self._items.insert(index, value)
    
        def __len__(self):
            print('Len')
            return len(self._items)

如果你创建 Items 的实例，你会发现它支持几乎所有的核心列表方法(如append()、remove()、count()等)。 下面是使用演示：

>>> a = Items([1, 2, 3])
    >>> len(a)
    Len
    3
    >>> a.append(4)
    Len
    Inserting: 3 4
    >>> a.append(2)
    Len
    Inserting: 4 2
    >>> a.count(2)
    Getting: 0
    Getting: 1
    Getting: 2
    Getting: 3
    Getting: 4
    Getting: 5
    2
    >>> a.remove(3)
    Getting: 0
    Getting: 1
    Getting: 2
    Deleting: 2

### 属性的代理访问 ###

> 想将某个实例的属性访问代理到内部另一个实例中去，目的可能是作为继承的一个替代方法或者实现代理模式。

简单来说，代理是一种编程模式，它将某个操作转移给另外一个对象来实现。 最简单的形式可能是像下面这样：

class A:
        def spam(self, x):
            pass
    
        def foo(self):
            pass
    
    
    class B1:
        """简单的代理"""
    
        def __init__(self):
            self._a = A()
    
        def spam(self, x):
            # Delegate to the internal self._a instance
            return self._a.spam(x)
    
        def foo(self):
            # Delegate to the internal self._a instance
            return self._a.foo()
    
        def bar(self):
            pass

如果仅仅就两个方法需要代理，那么像这样写就足够了。但是，如果有大量的方法需要代理， 那么使用 **getattr**() 方法或许或更好些：

class B2:
        """使用__getattr__的代理，代理方法比较多时候"""
    
        def __init__(self):
            self._a = A()
    
        def bar(self):
            pass
    
        # Expose all of the methods defined on class A
        def __getattr__(self, name):
            """这个方法在访问的attribute不存在的时候被调用 the __getattr__() method is actually a fallback method that only gets called when an attribute is not found"""
            return getattr(self._a, name)

**getattr** 方法是在访问attribute不存在的时候被调用，使用演示：

b = B()
    b.bar() # Calls B.bar() (exists on B)
    b.spam(42) # Calls B.__getattr__('spam') and delegates to A.spam

另外一个代理例子是实现代理模式，例如：

# A proxy class that wraps around another object, but
    # exposes its public attributes
    class Proxy:
        def __init__(self, obj):
            self._obj = obj
    
        # Delegate attribute lookup to internal obj
        def __getattr__(self, name):
            print('getattr:', name)
            return getattr(self._obj, name)
    
        # Delegate attribute assignment
        def __setattr__(self, name, value):
            if name.startswith('_'):
                super().__setattr__(name, value)
            else:
                print('setattr:', name, value)
                setattr(self._obj, name, value)
    
        # Delegate attribute deletion
        def __delattr__(self, name):
            if name.startswith('_'):
                super().__delattr__(name)
            else:
                print('delattr:', name)
                delattr(self._obj, name)

使用这个代理类时，你只需要用它来包装下其他类即可：

class Spam:
        def __init__(self, x):
            self.x = x
    
        def bar(self, y):
            print('Spam.bar:', self.x, y)
    
    # Create an instance
    s = Spam(2)
    # Create a proxy around it
    p = Proxy(s)
    # Access the proxy
    print(p.x)  # Outputs 2
    p.bar(3)  # Outputs "Spam.bar: 2 3"
    p.x = 37  # Changes s.x to 37

通过自定义属性访问方法，你可以用不同方式自定义代理类行为(比如加入日志功能、只读访问等)。  
**AND**:  
代理类有时候可以作为继承的替代方案。例如，一个简单的继承如下：

class A:
        def spam(self, x):
            print('A.spam', x)
        def foo(self):
            print('A.foo')
    
    class B(A):
        def spam(self, x):
            print('B.spam')
            super().spam(x)
        def bar(self):
            print('B.bar')

使用代理的话，就是下面这样：

class A:
        def spam(self, x):
            print('A.spam', x)
        def foo(self):
            print('A.foo')
    
    class B:
        def __init__(self):
            self._a = A()
        def spam(self, x):
            print('B.spam', x)
            self._a.spam(x)
        def bar(self):
            print('B.bar')
        def __getattr__(self, name):
            return getattr(self._a, name)

当实现代理模式时，还有些细节需要注意。 首先，**getattr**() 实际是一个后备方法，只有在属性不存在时才会调用。 因此，如果代理类实例本身有这个属性的话，那么不会触发这个方法的。 另外，**setattr**() 和 **delattr**() 需要额外的魔法来区分代理实例和被代理实例 *obj 的属性。 一个通常的约定是只代理那些不以下划线*  开头的属性(代理类只暴露被代理类的公共属性)。  
还有一点需要注意的是，**getattr**() 对于大部分以双下划线(\_\_)开始和结尾的属性并不适用。 比如，考虑如下的类：

class ListLike:
        """__getattr__对于双下划线开始和结尾的方法是不能用的，需要一个个去重定义"""
    
        def __init__(self):
            self._items = []
    
        def __getattr__(self, name):
            return getattr(self._items, name)

如果是创建一个ListLike对象，会发现它支持普通的列表方法，如append()和insert()， 但是却不支持len()、元素查找等。例如：

>>> a = ListLike()
    >>> a.append(2)
    >>> a.insert(0, 1)
    >>> a.sort()
    >>> len(a)
    Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
    TypeError: object of type 'ListLike' has no len()
    >>> a[0]
    Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
    TypeError: 'ListLike' object does not support indexing
    >>>

为了让它支持这些方法，你必须手动的实现这些方法代理：

class ListLike:
        """__getattr__对于双下划线开始和结尾的方法是不能用的，需要一个个去重定义"""
    
        def __init__(self):
            self._items = []
    
        def __getattr__(self, name):
            return getattr(self._items, name)
    
        # Added special methods to support certain list operations
        def __len__(self):
            return len(self._items)
    
        def __getitem__(self, index):
            return self._items[index]
    
        def __setitem__(self, index, value):
            self._items[index] = value
    
        def __delitem__(self, index):
            del self._items[index]

### 在类中定义多个构造器 ###

> 实现一个类，除了使用 **init**() 方法外，还有其他方式可以初始化它。

为了实现多个构造器，需要用到类方法。

import time
    
    class Date:
        """方法一：使用类方法"""
        # Primary constructor
        def __init__(self, year, month, day):
            self.year = year
            self.month = month
            self.day = day
    
        # Alternate constructor
        @classmethod
        def today(cls):
            t = time.localtime()
            return cls(t.tm_year, t.tm_mon, t.tm_mday)

直接调用类方法即可，下面是使用示例：  
a = Date(2012, 12, 21) \# Primary  
b = Date.today() \# Alternate  
**AND**:  
类方法的一个主要用途就是定义多个构造器。它接受一个 class 作为第一个参数(cls)。 你应该注意到了这个类被用来创建并返回最终的实例。在继承时也能工作的很好。

### 创建不调用init方法的实例 ###

> 绕过 **init**() 方法。创建一个实例

可以通过 **new**() 方法创建一个未初始化的实例

class Date:
        def __init__(self,year,moth,day):
            self.year = year
            self.month = month
            self.day = day

下面演示如何不调用 **init**() 方法来创建这个Date实例：

>>> d = Date.__new__(Date)
    >>> d
    <__main__.Date object at 0x1006716d0>
    >>> d.year
    Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
    AttributeError: 'Date' object has no attribute 'year'

结果可以看到，这个Date实例的属性year还不存在，所以你需要手动初始化：

>>> data = {
       'year':2012, 'month':8, 'day':29}
    >>> for key, value in data.items():
    ...     setattr(d, key, value)
    ...
    >>> d.year
    2012
    >>> d.month
    8

**AND**:  
当我们在反序列对象或者实现某个类方法构造函数时需要绕过 **init**() 方法来创建对象。 例如，对于上面的Date来讲，有时候你可能会像下面这样定义一个新的构造函数 today() ：

from time import localtime
    
    class Date:
        def __init__(self, year, month, day):
            self.year = year
            self.month = month
            self.day = day
    
        @classmethod
        def today(cls):
            d = cls.__new__(cls)
            t = localtime()
            d.year = t.tm_year
            d.month = t.tm_mon
            d.day = t.tm_mday
            return d

同样，在你反序列化JSON数据时产生一个如下的字典对象：

data = { 'year': 2012, 'month': 8, 'day': 29 }

如果你想将它转换成一个Date类型实例，可以使用上面的技术。

当你通过这种非常规方式来创建实例的时候，最好不要直接去访问底层实例字典，除非你真的清楚所有细节。 否则的话，如果这个类使用了 **slots** 、properties 、descriptors 或其他高级技术的时候代码就会失效。 而这时候使用 setattr() 方法会让你的代码变得更加通用。

### 利用 mixinx 扩展类功能 ###

> 你有很多有用的方法，想使用它们来扩展其他类的功能。但是这些类并没有任何继承的关系。 因此你不能简单的将这些方法放入一个基类，然后被其他类继承。

假设你想扩展映射对象，给它们添加日志、唯一性设置、类型检查等等功能。下面是一些混入类：

class LoggedMappingMixin:
        """ Add logging to get/set/delete operations for debugging. """
        __slots__ = ()  # 混入类都没有实例变量，因为直接实例化混入类没有任何意义
    
        def __getitem__(self, key):
            print('Getting ' + str(key))
            return super().__getitem__(key)
    
        def __setitem__(self, key, value):
            print('Setting {} = {!r}'.format(key, value))
            return super().__setitem__(key, value)
    
        def __delitem__(self, key):
            print('Deleting ' + str(key))
            return super().__delitem__(key)
    
    
    class SetOnceMappingMixin:
        ''' Only allow a key to be set once. '''
        __slots__ = ()
    
        def __setitem__(self, key, value):
            if key in self:
                raise KeyError(str(key) + ' already set')
            return super().__setitem__(key, value)
    
    
    class StringKeysMappingMixin:
        ''' Restrict keys to strings only '''
        __slots__ = ()
    
        def __setitem__(self, key, value):
            if not isinstance(key, str):
                raise TypeError('keys must be strings')
            return super().__setitem__(key, value)

这些类单独使用起来没有任何意义，事实上如果你去实例化任何一个类，除了产生异常外没任何作用。 它们是用来通过多继承来和其他映射对象混入使用的。例如：

class LoggedDict(LoggedMappingMixin, dict):
        pass
    
    d = LoggedDict()
    d['x'] = 23
    print(d['x'])
    del d['x']
    
    from collections import defaultdict
    
    class SetOnceDefaultDict(SetOnceMappingMixin, defaultdict):
        pass
    
    
    d = SetOnceDefaultDict(list)
    d['x'].append(2)
    d['x'].append(3)
    # d['x'] = 23 # KeyError: 'x already set'

这个例子中，可以看到混入类跟其他已存在的类(比如dict、defaultdict和OrderedDict)结合起来使用，一个接一个。 结合后就能发挥正常功效了。  
**AND**:  
混入类在标准库中很多地方都出现过，通常都是用来像上面那样扩展某些类的功能。 它们也是多继承的一个主要用途。比如，当你编写网络代码时候， 你会经常使用 socketserver 模块中的 ThreadingMixIn 来给其他网络相关类增加多线程支持。 例如，下面是一个多线程的XML-RPC服务：

from xmlrpc.server import SimpleXMLRPCServer  
from socketserver import ThreadingMixIn  
class ThreadedXMLRPCServer(ThreadingMixIn, SimpleXMLRPCServer):  
pass  
同时在一些大型库和框架中也会发现混入类的使用，用途同样是增强已存在的类的功能和一些可选特征。

对于混入类，有几点需要记住。首先是，混入类不能直接被实例化使用。 其次，混入类没有自己的状态信息，也就是说它们并没有定义 **init**() 方法，并且没有实例属性。 这也是为什么我们在上面明确定义了 **slots** = () 。

还有一种实现混入类的方式就是使用类装饰器，如下所示：

def LoggedMapping(cls):
        """第二种方式：使用类装饰器"""
        cls_getitem = cls.__getitem__
        cls_setitem = cls.__setitem__
        cls_delitem = cls.__delitem__
    
        def __getitem__(self, key):
            print('Getting ' + str(key))
            return cls_getitem(self, key)
    
        def __setitem__(self, key, value):
            print('Setting {} = {!r}'.format(key, value))
            return cls_setitem(self, key, value)
    
        def __delitem__(self, key):
            print('Deleting ' + str(key))
            return cls_delitem(self, key)
    
        cls.__getitem__ = __getitem__
        cls.__setitem__ = __setitem__
        cls.__delitem__ = __delitem__
        return cls

@LoggedMapping
    class LoggedDict(dict):
        pass

这个效果跟之前的是一样的，而且不再需要使用多继承了。

### 实现状态对象或者状态机 ###

你想实现一个状态机或者是在不同状态下执行操作的对象，但是又不想在代码中出现太多的条件判断语句。  
在很多程序中，有些对象会根据状态的不同来执行不同的操作。比如考虑如下的一个连接对象：

class Connection:
        """普通方案，好多个判断语句，效率低下~~"""
    
        def __init__(self):
            self.state = 'CLOSED'
    
        def read(self):
            if self.state != 'OPEN':
                raise RuntimeError('Not open')
            print('reading')
    
        def write(self, data):
            if self.state != 'OPEN':
                raise RuntimeError('Not open')
            print('writing')
    
        def open(self):
            if self.state == 'OPEN':
                raise RuntimeError('Already open')
            self.state = 'OPEN'
    
        def close(self):
            if self.state == 'CLOSED':
                raise RuntimeError('Already closed')
            self.state = 'CLOSED'

这样写有很多缺点，首先是代码太复杂了，好多的条件判断。其次是执行效率变低， 因为一些常见的操作比如read()、write()每次执行前都需要执行检查。

一个更好的办法是为每个状态定义一个对象：

class Connection1:
        """新方案——对每个状态定义一个类"""
    
        def __init__(self):
            self.new_state(ClosedConnectionState)
    
        def new_state(self, newstate):
            self._state = newstate
            # Delegate to the state class
    
        def read(self):
            return self._state.read(self)
    
        def write(self, data):
            return self._state.write(self, data)
    
        def open(self):
            return self._state.open(self)
    
        def close(self):
            return self._state.close(self)

# Connection state base class
    class ConnectionState:
        @staticmethod
        def read(conn):
            raise NotImplementedError()
    
        @staticmethod
        def write(conn, data):
            raise NotImplementedError()
    
        @staticmethod
        def open(conn):
            raise NotImplementedError()
    
        @staticmethod
        def close(conn):
            raise NotImplementedError()

# Implementation of different states
    class ClosedConnectionState(ConnectionState):
        @staticmethod
        def read(conn):
            raise RuntimeError('Not open')
    
        @staticmethod
        def write(conn, data):
            raise RuntimeError('Not open')
    
        @staticmethod
        def open(conn):
            conn.new_state(OpenConnectionState)
    
        @staticmethod
        def close(conn):
            raise RuntimeError('Already closed')
    
    
    class OpenConnectionState(ConnectionState):
        @staticmethod
        def read(conn):
            print('reading')
    
        @staticmethod
        def write(conn, data):
            print('writing')
    
        @staticmethod
        def open(conn):
            raise RuntimeError('Already open')
    
        @staticmethod
        def close(conn):
            conn.new_state(ClosedConnectionState)

下面是使用演示：

>>> c = Connection()
    >>> c._state
    <class '__main__.ClosedConnectionState'> >>> c.read() Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
        File "example.py", line 10, in read
            return self._state.read(self)
        File "example.py", line 43, in read
            raise RuntimeError('Not open')
    RuntimeError: Not open
    >>> c.open()
    >>> c._state
    <class '__main__.OpenConnectionState'> >>> c.read() reading >>> c.write('hello') writing >>> c.close() >>> c._state <class '__main__.ClosedConnectionState'>

**AND**:  
如果代码中出现太多的条件判断语句的话，代码就会变得难以维护和阅读。 这里的解决方案是将每个状态抽取出来定义成一个类。

这里看上去有点奇怪，每个状态对象都只有静态方法，并没有存储任何的实例属性数据。 实际上，所有状态信息都只存储在 Connection 实例中。 在基类中定义的 NotImplementedError 是为了确保子类实现了相应的方法。

### 通过字符串调用对象方法 ###

> 通过一个字符串形式的方法名称调用某个对象的对应方法

最简单的情况，可以使用 getattr() :

import math
    class Point:
        def __init__(self,x,y):
            self.x = x
            self.y = y
        def __repr__(self):
            return 'Point({!r:},{!r:})'.format(self.x, self.y)
        def distance(self,x,y):
            return math.hypot(self.x - x, self.y -y)
    
    p = Point(2,3)
    d = getattr(p,'distance')(0,0)
    # 等价于 p.distance(0,0)

另一种方法是使用 operator.methodcaller() ，例如：

import operator
    operator.methodcaller('distance',0,0)(p)

当你需要通过相同的参数多次调用某个方法时，使用 operator.methodcaller 就很方便了。 比如你需要排序一系列的点，就可以这样做：

points = [
        Point(1, 2),
        Point(3, 0),
        Point(10, -3),
        Point(-5, -7),
        Point(-1, 8),
        Point(3, 2)
    ]
    # Sort by distance from origin (0, 0)
    points.sort(key=operator.methodcaller('distance', 0, 0))

**AND**:  
调用一个方法实际上是两部独立操作，第一步是查找属性，第二步是函数调用。 因此，为了调用某个方法，你可以首先通过 getattr() 来查找到这个属性，然后再去以函数方式调用它即可。

operator.methodcaller() 创建一个可调用对象，并同时提供所有必要参数， 然后调用的时候只需要将实例对象传递给它即可，比如：

>>> p = Point(3, 4)
    >>> d = operator.methodcaller('distance', 0, 0)
    >>> d(p)
    5.0

通过方法名称字符串来调用方法通常出现在需要模拟 case 语句或实现访问者模式的时候。

### 实现访问者模式 ###

> 要处理由大量不同类型的对象组成的复杂数据结构，每一个对象都需要需要进行不同的处理。 比如，遍历一个树形结构，然后根据每个节点的相应状态执行不同的操作。

这里遇到的问题在编程领域中是很普遍的，有时候会构建一个由大量不同对象组成的数据结构。 假设你要写一个表示数学表达式的程序，那么你可能需要定义如下的类：

class Node:
        pass
    
    class UnaryOperator(Node):
        def __init__(self, operand):
            self.operand = operand
    
    class BinaryOperator(Node):
        def __init__(self, left, right):
            self.left = left
            self.right = right
    
    class Add(BinaryOperator):
        pass
    
    class Sub(BinaryOperator):
        pass
    
    class Mul(BinaryOperator):
        pass
    
    class Div(BinaryOperator):
        pass
    
    class Negate(UnaryOperator):
        pass
    
    class Number(Node):
        def __init__(self, value):
            self.value = value

然后利用这些类构建嵌套数据结构，如下所示：

# Representation of 1 + 2 * (3 - 4) / 5
    t1 = Sub(Number(3), Number(4))
    t2 = Mul(Number(2), t1)
    t3 = Div(t2, Number(5))
    t4 = Add(Number(1), t3)

这样做的问题是对于每个表达式，每次都要重新定义一遍，有没有一种更通用的方式让它支持所有的数字和操作符呢。 这里我们使用访问者模式可以达到这样的目的：

class NodeVisitor:
        def visit(self, node):
            methname = 'visit_' + type(node).__name__
            meth = getattr(self, methname, None)
            if meth is None:
                meth = self.generic_visit
            return meth(node)
    
        def generic_visit(self, node):
            raise RuntimeError('No {} method'.format('visit_' + type(node).__name__))

为了使用这个类，可以定义一个类继承它并且实现各种 visit\_Name() 方法，其中Name是node类型。 例如，如果你想求表达式的值，可以这样写：

class Evaluator(NodeVisitor):
        def visit_Number(self, node):
            return node.value
    
        def visit_Add(self, node):
            return self.visit(node.left) + self.visit(node.right)
    
        def visit_Sub(self, node):
            return self.visit(node.left) - self.visit(node.right)
    
        def visit_Mul(self, node):
            return self.visit(node.left) * self.visit(node.right)
    
        def visit_Div(self, node):
            return self.visit(node.left) / self.visit(node.right)
    
        def visit_Negate(self, node):
            return -node.operand

使用示例：

>>> e = Evaluator()
    >>> e.visit(t4)
    0.6

作为一个不同的例子，下面定义一个类在一个栈上面将一个表达式转换成多个操作序列：

class StackCode(NodeVisitor):
        def generate_code(self, node):
            self.instructions = []
            self.visit(node)
            return self.instructions
    
        def visit_Number(self, node):
            self.instructions.append(('PUSH', node.value))
    
        def binop(self, node, instruction):
            self.visit(node.left)
            self.visit(node.right)
            self.instructions.append((instruction,))
    
        def visit_Add(self, node):
            self.binop(node, 'ADD')
    
        def visit_Sub(self, node):
            self.binop(node, 'SUB')
    
        def visit_Mul(self, node):
            self.binop(node, 'MUL')
    
        def visit_Div(self, node):
            self.binop(node, 'DIV')
    
        def unaryop(self, node, instruction):
            self.visit(node.operand)
            self.instructions.append((instruction,))
    
        def visit_Negate(self, node):
            self.unaryop(node, 'NEG')

使用示例：

>>> s = StackCode()
    >>> s.generate_code(t4)
    [('PUSH', 1), ('PUSH', 2), ('PUSH', 3), ('PUSH', 4), ('SUB',),
    ('MUL',), ('PUSH', 5), ('DIV',), ('ADD',)]

**AND**:

刚开始的时候你可能会写大量的if/else语句来实现， 这里访问者模式的好处就是通过 getattr() 来获取相应的方法，并利用递归来遍历所有的节点：

def binop(self, node, instruction):
        self.visit(node.left)
        self.visit(node.right)
        self.instructions.append((instruction,))

还有一点需要指出的是，这种技术也是实现其他语言中switch或case语句的方式。 比如，如果你正在写一个HTTP框架，你可能会写这样一个请求分发的控制器：

class HTTPHandler:
        def handle(self, request):
            methname = 'do_' + request.request_method
            getattr(self, methname)(request)
        def do_GET(self, request):
            pass
        def do_POST(self, request):
            pass
        def do_HEAD(self, request):
            pass

访问者模式一个缺点就是它严重依赖递归，如果数据结构嵌套层次太深可能会有问题， 有时候会超过Python的递归深度限制(参考 sys.getrecursionlimit() )。

### 让类支持比较操作 ###

> 让某个类的实例支持标准的比较运算(比如>=,!=,<=,<等)，但是又不想去实现那一大丢的特殊方法。

Python类对每个比较操作都需要实现一个特殊方法来支持。 例如为了支持>=操作符，你需要定义一个 **ge**() 方法。 尽管定义一个方法没什么问题，但如果要你实现所有可能的比较方法那就有点烦人了。

装饰器 functools.total\_ordering 就是用来简化这个处理的。 使用它来装饰一个来，你只需定义一个 **eq**() 方法， 外加其他方法(**lt**, **le**, **gt**, or **ge**)中的一个即可。 然后装饰器会自动为你填充其它比较方法。

作为例子，我们构建一些房子，然后给它们增加一些房间，最后通过房子大小来比较它们：

from functools import total_ordering
    
    class Room:
        def __init__(self, name, length, width):
            self.name = name
            self.length = length
            self.width = width
            self.square_feet = self.length * self.width
    
    @total_ordering
    class House:
        def __init__(self, name, style):
            self.name = name
            self.style = style
            self.rooms = list()
    
        @property
        def living_space_footage(self):
            return sum(r.square_feet for r in self.rooms)
    
        def add_room(self, room):
            self.rooms.append(room)
    
        def __str__(self):
            return '{}: {} square foot {}'.format(self.name,
                    self.living_space_footage,
                    self.style)
    
        def __eq__(self, other):
            return self.living_space_footage == other.living_space_footage
    
        def __lt__(self, other):
            return self.living_space_footage < other.living_space_footage

这里我们只是给House类定义了两个方法：**eq**() 和 **lt**() ，它就能支持所有的比较操作：

# Build a few houses, and add rooms to them
    h1 = House('h1', 'Cape')
    h1.add_room(Room('Master Bedroom', 14, 21))
    h1.add_room(Room('Living Room', 18, 20))
    h1.add_room(Room('Kitchen', 12, 16))
    h1.add_room(Room('Office', 12, 12))
    h2 = House('h2', 'Ranch')
    h2.add_room(Room('Master Bedroom', 14, 21))
    h2.add_room(Room('Living Room', 18, 20))
    h2.add_room(Room('Kitchen', 12, 16))
    h3 = House('h3', 'Split')
    h3.add_room(Room('Master Bedroom', 14, 21))
    h3.add_room(Room('Living Room', 18, 20))
    h3.add_room(Room('Office', 12, 16))
    h3.add_room(Room('Kitchen', 15, 17))
    houses = [h1, h2, h3]
    print('Is h1 bigger than h2?', h1 > h2) # prints True
    print('Is h2 smaller than h3?', h2 < h3) # prints True
    print('Is h2 greater than or equal to h1?', h2 >= h1) # Prints False
    print('Which one is biggest?', max(houses)) # Prints 'h3: 1101-square-foot Split'
    print('Which is smallest?', min(houses)) # Prints 'h2: 846-square-foot Ranch'

**AND**:  
其实 total\_ordering 装饰器也没那么神秘。 它就是定义了一个从每个比较支持方法到所有需要定义的其他方法的一个映射而已。 比如你定义了 **le**() 方法，那么它就被用来构建所有其他的需要定义的那些特殊方法。 实际上就是在类里面像下面这样定义了一些特殊方法：

class House:
        def __eq__(self, other):
            pass
        def __lt__(self, other):
            pass
        # Methods created by @total_ordering
        __le__ = lambda self, other: self < other or self == other
        __gt__ = lambda self, other: not (self < other or self == other)
        __ge__ = lambda self, other: not (self < other)
        __ne__ = lambda self, other: not self == other

### 创建缓存实例 ###

> 在创建一个类的对象时，如果之前使用同样参数创建过这个对象， 你想返回它的缓存引用。

这种通常是因为你希望相同参数创建的对象时单例的。 在很多库中都有实际的例子，比如 logging 模块，使用相同的名称创建的 logger 实例永远只有一个。例如：

>>> import logging
    >>> a = logging.getLogger('foo')
    >>> b = logging.getLogger('bar')
    >>> a is b
    False
    >>> c = logging.getLogger('foo')
    >>> a is c
    True

为了达到这样的效果，你需要使用一个和类本身分开的工厂函数，例如：

# The class in question
    class Spam:
        def __init__(self, name):
            self.name = name
    
    # Caching support
    import weakref
    _spam_cache = weakref.WeakValueDictionary()
    def get_spam(name):
        if name not in _spam_cache:
            s = Spam(name)
            _spam_cache[name] = s
        else:
            s = _spam_cache[name]
        return s

然后做一个测试，你会发现跟之前那个日志对象的创建行为是一致的：

>>> a = get_spam('foo')
    >>> b = get_spam('bar')
    >>> a is b
    False
    >>> c = get_spam('foo')
    >>> a is c
    True

**AND**:  
更优雅的解决方案

import weakref
    
    class Spam:
        _spam_cache = weakref.WeakValueDictionary()
        def __new__(cls, name):
            if name in cls._spam_cache:
                return cls._spam_cache[name]
            else:
                self = super().__new__(cls)
                cls._spam_cache[name] = self
                return self
        def __init__(self, name):
            print('Initializing Spam')
            self.name = name

初看起来好像可以达到预期效果，但是问题是 **init**() 每次都会被调用，不管这个实例是否被缓存了。例如：

>>> s = Spam('Dave')
    Initializing Spam
    >>> t = Spam('Dave')
    Initializing Spam
    >>> s is t
    True

这个或许不是你想要的效果，因此这种方法并不可取。

上面我们使用到了弱引用计数，对于垃圾回收来讲是很有帮助的，关于这个我们在8.23小节已经讲过了。 当我们保持实例缓存时，你可能只想在程序中使用到它们时才保存。 一个 WeakValueDictionary 实例只会保存那些在其它地方还在被使用的实例。 否则的话，只要实例不再被使用了，它就从字典中被移除了。观察下下面的测试结果：

> > > a = get\_spam(‘foo’)  
> > > b = get\_spam(‘bar’)  
> > > c = get\_spam(‘foo’)  
> > > list(\_spam\_cache)  
> > > \[‘foo’, ‘bar’\]  
> > > del a  
> > > del c  
> > > list(\_spam\_cache)  
> > > \[‘bar’\]  
> > > del b  
> > > list(\_spam\_cache)  
> > > \[\]
> > > 
> > > 对于大部分程序而已，这里代码已经够用了。不过还是有一些更高级的实现值得了解下。

首先是这里使用到了一个全局变量，并且工厂函数跟类放在一块。我们可以通过将缓存代码放到一个单独的缓存管理器中：

import weakref

class CachedSpamManager:  
def **init**(self):  
self.\_cache = weakref.WeakValueDictionary()

def get_spam(self, name):
        if name not in self._cache:
            s = Spam(name)
            self._cache[name] = s
        else:
            s = self._cache[name]
        return s
    
    def clear(self):
            self._cache.clear()

class Spam:  
manager = CachedSpamManager()  
def **init**(self, name):  
self.name = name

def get_spam(name):
        return Spam.manager.get_spam(name)

这样的话代码更清晰，并且也更灵活，我们可以增加更多的缓存管理机制，只需要替代manager即可。

还有一点就是，我们暴露了类的实例化给用户，用户很容易去直接实例化这个类，而不是使用工厂方法，如：

>>> a = Spam('foo')
    >>> b = Spam('foo')
    >>> a is b
    False

有几种方式可以防止用户这样做，第一个是将类的名字修改为以下划线(\_)开头，提示用户别直接调用它。 第二种就是让这个类的 **init**() 方法抛出一个异常，让它不能被初始化：

class Spam:
        def __init__(self, *args, **kwargs):
            raise RuntimeError("Can't instantiate directly")
    
        # Alternate constructor
        @classmethod
        def _new(cls, name):
            self = cls.__new__(cls)
            self.name = name

然后修改缓存管理器代码，使用 Spam.\_new() 来创建实例，而不是直接调用 Spam() 构造函数：

# ------------------------最后的修正方案------------------------
    class CachedSpamManager2:
        def __init__(self):
            self._cache = weakref.WeakValueDictionary()
    
        def get_spam(self, name):
            if name not in self._cache:
                temp = Spam3._new(name)  # Modified creation
                self._cache[name] = temp
            else:
                temp = self._cache[name]
            return temp
    
        def clear(self):
                self._cache.clear()
    
    class Spam3:
        def __init__(self, *args, **kwargs):
            raise RuntimeError("Can't instantiate directly")
    
        # Alternate constructor
        @classmethod
        def _new(cls, name):
            self = cls.__new__(cls)
            self.name = name
            return self

最后这样的方案就已经足够好了。

`类与对象这一节看的还是挺蒙的，还是基础不足经验太少，先保留下来，以后再回顾吧`

[python3-cookbook]: http://python3-cookbook.readthedocs.io/zh_CN/latest/chapters/p08_classes_and_objects.html