Python Revisited Day 06 (面向对象程序设计）

目录

• 6.1 面向对象方法
  • duck typing
  • 访问限制 __
• 6.2 自定义类
  • 6.2.1 属性与方法
  • 预定义的特殊方法 _..._
    • 比较的特殊方法
  • 6.2.2 继承与多态
  • 6.2.3 使用特性进行属性存取控制 @property
  • 6.2.4 创建完全整合的数据类型
    • 基本的特殊方法
    • 数值型与位逻辑运算的特殊方法
    • 6.2.4.1 从头开始创建数据类型
    • 6.2.4.2 从其他数据类型创建数据类型
      • Tips 如何快速无效化不要的方法 exec()
• 6.3 自定义组合类
  • 6.3.1 创建聚集组合数据的类
    • 组合类型的特殊方法 [ ], in
  • 6.3.2 使用聚集创建组合类 SortedList
  • 6.3.3 使用继承创建组合类
    • 静态方法与类方法
• 6.5 练习

《Python 3 程序开发指南》 学习笔记

6.1 面向对象方法

duck typing

“如果走起来像只鸭子，叫起来也像只鸭子，那它就是一只鸭子。”

访问限制 __

class Circle:
    def __init__(self, x=0, y=0, radius=0):
        self.x = x
        self.y = y
        self.radius = radius
        self.__PI = 3.1415926  #私有属性 __

    def get_PI(self):

        return self.__PI  #我们可以通过方法来获得此属性，当然相应的改变也可以

    def get_area(self):

        return self.PI * self.radius ** 2

c = Circle(2, 2, 2)
c.x, c.y,c.radius  #(2, 2, 2)
c.__PI   # AttributeError
c.get_PI()   #3.1415926

6.2 自定义类

class className:
	suite
class className(base_classes):
	suite

6.2.1 属性与方法

class Circle:
    def __init__(self, x=0, y=0, radius=0):
        self.x = x
        self.y = y
        self.radius = radius
        self.__PI = 3.1415926

    def get_PI(self):
        return self.__PI

    def get_area(self):
        return self.PI * self.radius ** 2

    def __eq__(self, other):
        return (self.x, self.y, self.radius) == (other.x, other.y, other.radius)

    def __repr__(self):
        return "Circle({0.x!r}, {0.y!r}, {0.radius!r})".format(self)  # !r  强制使用表现形式

    def __str__(self):
        return "({0.x!r}, {0.y!r}, {0.radius!r})".format(self)

c = Circle(2, 2, 2)
repr(c) # 'Point(2, 2, 2)'   == c.__repr__()
str(c) # '(2, 2, 2)'   == c.__str__()
c2 = Circle(2, 2, 2)
c == c2 # True   == c.__eq__(c2)
c != c2  # False

预定义的特殊方法 _..._

一般的方法名起始和结尾不应该使用俩个下划线，除非是预定义的特殊方法（大概就是操作符所对应的方法，还有一些固定的方法？）。

比较的特殊方法

特殊方法	使用	描述
__it__(self, other)	x < y	如果x比y小，则返回True
__le__(self, other)	x <= y	...
__eq__(self, other)	x == y	...
__ne__(self, other)	x != y	...
__ge__(self, other)	x >= y	...
__gt__(self, other)	x > y	...

默认情况下，自定义类的实例都是可哈希运算的。如果重新实现了__eq__()，实例便不可哈希运算。

class Circle:
    def __init__(self, x=0, y=0, radius=0):
        self.x = x
        self.y = y
        self.radius = radius
        self.__PI = 3.1415926

c = Circle(2, 2, 2)
c2 = Circle(2, 2, 2)
c == c2 # False

    def __eq__(self, other):
        if not isinstance(other, Circle):  #assert isinstance(other, Circle)
            raise TypeError() # NotImplem-entled
        return (self.x, self.y, self.radius) == (other.x, other.y, other.radius)

上述对__eq__()的改写，可以避免类似 "c == 1"。

c = Circle(2, 2, 2)
c2 = eval(repr(c)) #如果Circle是引用来的，要加入模块 c.__module__+'.'+repr(c)
c == c2

6.2.2 继承与多态

import math

class Point:

    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

    def distance_from_origin(self):
        return math.hypot(self.x, self.y)

    def __eq__(self, other):

        if not isinstance(other, Point):
            raise TypeError()
        return (self.x ,self.y) == (other.x, other.y)

    def __repr__(self):
        return "Point({0.x!r}, {0.y!r})".format(self)

    def __str__(self):
        return "({0.x!r}, {0.y!r})".format(self)

class Circle(Point):
    def __init__(self, x=0, y=0, radius=0):
        super().__init__(x, y)
        self.radius = radius
        self.__PI = 3.1415926

    def get_PI(self):
        return self.__PI

    def edge_distance_from_origin(self):
        return abs(self.distance_from_origin() - self.radius)

    def area(self):
        return self.PI * self.radius ** 2

    def circumference(self):
        return 2 * self.__PI * self.radius

    def __eq__(self, other):
        if not isinstance(other, Circle):  #assert isinstance(other, Circle)
            raise TypeError() # NotImplem-entled
        return self.radius == other.radius and super().__eq__(other) #!!!

    def __repr__(self):
        return "Circle({0.x!r}, {0.y!r}, {0.radius!r})".format(self)

    def __str__(self):
        return "({0.x!r}, {0.y!r}, {0.radius!r})".format(self)

如果__eq_() 里用Circle.__eq_(self, other)

    def __eq__(self, other):
        if not isinstance(other, Circle):  #assert isinstance(other, Circle)
            raise TypeError() # NotImplem-entled
        return self.radius == other.radius and Circle.__eq__(self, other) #!!!
c = Circle(2, 2, 2)
c2 = Circle(2, 2, 2)
c == c2  #会进入无限迭代，因为实际上调用的Circle类里的__eq__而不是Point类里的
#另外，使用 super().__eq__(other), python 会自动传入self

6.2.3 使用特性进行属性存取控制 @property

class Circle(Point):
    def __init__(self, radius, x=0, y=0):  #注意radius的位置 且无默认值
        super().__init__(x, y)
        self.radius = radius #！！！！！！！！！！！！！！！！！！
        self.__PI = 3.1415926

    def get_PI(self):
        return self.__PI

    @property
    def radius(self):
        """The Circle's radius

        >>> circle = Circle(-2)
        Traceback (most recent call last):
        ...
        AssertionError: radius must be nonzero and non-negative
        >>> circle = Circle(4)
        >>> circle.radius = -1
        Traceback (most recent call last):
        ...
        AssertionError: radius must be nonzero and non-negative
        >>> circle.radius = 6

        """
        return self.__radius

    @radius.setter
    def radius(self, radius):
        assert radius > 0, "radius must be nonzero and non-negative"
        self.__radius = radius

    @property
    def edge_distance_from_origin(self):
        return abs(self.distance_from_origin() - self.radius)

    @property
    def area(self):
        return self.PI * self.radius ** 2

    def circumference(self):
        return 2 * self.__PI * self.radius

    def __eq__(self, other):
        if not isinstance(other, Circle):  #assert isinstance(other, Circle)
            raise TypeError() # NotImplem-entled
        return self.radius == other.radius and super().__eq__(other)

    def __repr__(self):
        return "Circle({0.x!r}, {0.y!r}, {0.radius!r})".format(self)

    def __str__(self):
        return "({0.x!r}, {0.y!r}, {0.radius!r})".format(self)

如果

    def __init__(self, radius, x=0, y=0):  #注意radius的位置 且无默认值
        super().__init__(x, y)
        self.radius = radius #！！！！！！！！！！！！！！！！！！
        self.__PI = 3.1415926

改为

    def __init__(self, radius, x=0, y=0):  #注意radius的位置 且无默认值
        super().__init__(x, y)
        self.__radius = radius #！！！！！！！！！！！！！！！！！！
        self.__PI = 3.1415926

那么

c = Circle(-1)

不会报错。

每个创建的特性（即用@property）修饰之后，都包含getter,setter,deleter等属性。

6.2.4 创建完全整合的数据类型

基本的特殊方法

特殊方法	使用	描述
__bool__(self)	bool(x)	如果提供,就返回x的真值，对 if x:... 是有用的
__format__(self, format_spec)	"{0}".format(x)	为自定义类提供str.format()支持
__hash__(self)	hash(x)	如果提供，那么x可用作字典的键或存放在集合中
__init__(self, args)	x = X(args)	对象初始化调用
__new__(cls, args）	x = X(args)	创建对象时调用
__repr__(self)	repr(x)	返回x的字符串表示，在可能的地方eval(repr(x)) == x
__repr_(self)	ascii(x)	仅使用ASCII返回x的字符串表示
str(self)	str(x)	返回x的适合阅读的字符串表示

数值型与位逻辑运算的特殊方法

特殊方法	使用	特殊方法	使用
__abs__(self)	abs(x)	__complex__(self)	complex(x)
__float__(self)	float(x)	__init__(self)	int(x)
__index__(self)	bin(x) oct(x) hex(x)	__round__(self, digits)	round(x, digits)
__pos__(self)	+x	__neg__(self)	-x
__add__(self, other)	x + y	__sub__(self, other)	x - y
__iadd__(self, other)	x += y	__isub__(self, other)	x -= y
__radd__(self, other)	y + x	__rsub__(self, other)	y - x
__mul__(self, other)	x * y	__mod__(self, other)	x % y
__imul__(self, other)	x *= y	__imod__(self, other)	x %= y
__rmul__(self, other)	y * x	__rmod__( self, other)	y % x
__floordiv__(self, other)	x // y	__truediv__(self, other)	x / y
__ifloordiv__(self, other)	x //= y	__itruediv__(self, other)	x /= y
__rfloordiv__(self, other)	y // x	__rtruediv__(self,other)	y / x
__divmod__(self, other)	divmod(x, y)	__rdivmod__(self, other)	divmod(y, x)
__pow__(self, other)	x ** y	__and__(self, other)	x & y
__ipow__(self, other)	x **= y	__iand__(self, other)	x &= y
__rpow__(self, other)	y ** x	__rand__(self, other)	y & x
__xor__(self, other)	x ^ y	__or__(self, other)	x | y
__ixor__(self, other)	x ^= y	__ior__(self, other)	x |= y
__rxor__(self, other)	y ^ x	__ror__(self, other)	y | x
__lshift__(self, other)	x << y	__rshift__(self, other)	x >> y
__ilshift__(self, other)	x <<= y	__irshift__(self, other)	x >>= y
__rlshift__(self, other)	y << x	__rrshift__(self, other)	y >> x
		__invert__(self)	~x

6.2.4.1 从头开始创建数据类型

class FuzzyBool:

    """从头开始创建数据类型FuzzyBool:模糊型布尔值
    FuzzyBool扩展了二元值true 和 false. 1.0 表示 true,
    0.0 表示false， 0.5 表示 50% true.

    >>> a = FuzzyBool(0.875)
    >>> b = FuzzyBool(0.25)

    实例提供比较"> >= < <= = !="
    >>> a >= b
    True
    >>> a == 1
    Traceback (most recent call last):
    ...
    TypeError

    实例支持bool()操作
    >>> bool(a), bool(b)
    (True, False)

    实例支持位操作符
    >>> ~a
    FuzzyBool(0.125)
    >>> a & b
    FuzzyBool(0.25)
    >>> b |= FuzzyBool(.5)

    支持format
    >>> "a={0:.1%} b={1:.0%}".format(a, b)
    'a=87.5% b=50%'

    """
    def __init__(self, value=0.0):
        """初始化函数 value 默认值为0.0
        且传入的值要求在0,1之间，否则取0.0
        """
        self.__value = value if 0.0 <= value <= 1.0 else 0.0

    def __invert__(self):
        """
        倒置操作符 ~
        :return: FuzzyBool(1.0 - self.__value)
        """
        return FuzzyBool(1.0 - self.__value)

    def __and__(self, other):
        """
        & 的特殊方法
        :param other: 相同的鸭子。。。
        :return: self.__value 与 other.__value的小的
        """
        if not isinstance(other, FuzzyBool):
            raise  TypeError()
        return FuzzyBool(min(self.__value, other.__value))

    def __iand__(self, other):
        """
        &= 的特殊方法
        :param other: 相同的鸭子。。。
        :return: self.__value更新为self.__value和other.__value中较小的那个, 返回self.
        """
        if not isinstance(other, FuzzyBool):
            raise TypeError()
        self.__value = min(self.__value, other.__value)
        return self

    def __or__(self, other):
        """
        |
        :param other:
        :return:
        """
        if not isinstance(other, FuzzyBool):
            raise TypeError()
        return FuzzyBool(max(self.__value, other.__value))

    def __ior__(self, other):
        """
        |=
        :param other:
        :return:
        """
        if not isinstance(other, FuzzyBool):
            raise TypeError()
        return FuzzyBool(max(self.__value, other.__value))

    def __repr__(self):
        """
        表象形式
        :return:
        """
        return "{0}({1})".format(self.__class__.__name__,
                                 self.__value)

    def __str__(self):
        """
        字符串形式
        :return:
        """
        return str(self.__value)

    def __bool__(self):
        """
        if self.__value > 0.5
        :return: True
        """
        return self.__value > 0.5

    def __int__(self):
        """
        整数形式
        :return:
        """
        return round(self.__value)

    def __float__(self):
        """
        浮点数形式
        :return:
        """
        return self.__value

    # 要想完整的比较操作符集< > <= >= == != 只需要提供其中3个即可(< <= ==)
    # 余下的Python自己会推导出来
    def __lt__(self, other):
        """
        <
        :param other:
        :return:
        """
        if not isinstance(other, FuzzyBool):
            raise TypeError()
        return self.__value < other.__value

    def __eq__(self, other):
        """
        ==
        :param other:
        :return:
        """
        if not isinstance(other, FuzzyBool):
            raise  TypeError()
        return self.__value == other.__value

    def __le__(self, other):
        """
        <=
        :param other:
        :return:
        """
        if not isinstance(other, FuzzyBool):
            raise  TypeError()
        return self.__value <= other.__value

    def __hash__(self):
        """
        因为重写了__eq__(),所以需要提供__hash__()来使其可哈希
        !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        不能把self.__value作为哈希值，因为它是可变的
        !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        :return:
        """
        return hash(id(self))

    def  __format__(self, format_spec):
        return format(self.__value, format_spec)

    @staticmethod
    def conjunction(*fuzzies):
        """
        结链处理
        :param fuzzies:
        :return: fuzzies[0] & fuzzies[1] ... & fuzzies[n]
        """
        return FuzzyBool(min(float(x) for x in fuzzies))

if __name__ == "__main__":

    import doctest
    doctest.testmod()

6.2.4.2 从其他数据类型创建数据类型

class FuzzyBool(float):

    """从头开始创建数据类型FuzzyBool:模糊型布尔值
    FuzzyBool扩展了二元值true 和 false. 1.0 表示 true,
    0.0 表示false， 0.5 表示 50% true.

    >>> a = FuzzyBool(0.875)
    >>> b = FuzzyBool(0.25)

    实例提供比较"> >= < <= = !="
    >>> a >= b
    True

    实例支持bool()操作
    >>> bool(a), bool(b)
    (True, False)

    实例支持位操作符
    >>> ~a
    FuzzyBool(0.125)
    >>> a & b
    FuzzyBool(0.25)
    >>> b |= FuzzyBool(.5)

    支持format
    >>> "a={0:.1%} b={1:.0%}".format(a, b)
    'a=87.5% b=50%'

    不支持+,-，*，/等运算符
    >>> -a
    Traceback (most recent call last):
    ...
    NotImplementedError
    >>> a + b
    Traceback (most recent call last):
    ...
    TypeError: unsupported operand type(s) for '+':'FuzzyBool' and 'FuzzyBool'

    """
    def __new__(cls, value=0.0):
        """
        创建一个新类时，通常是可变的。对于固定类，
        我们需要在一个步骤中同时完成创建和初始化，
        因为对于固定对象而言，一旦创建，就不能更改。
        :param value:
        :return:
        """
        return super().__new__(cls,
                               value if 0.0 <= value <= 1.0 else 0)

    def __invert__(self):
        return FuzzyBool(1.0 - float(self)) #注意是self!!!

    def __and__(self, other):
        return FuzzyBool(min(self, other))

    def __iand__(self, other):
        """
        因为是固定类型，所以，实际上依旧是创建了一个新实例
        :param other:
        :return:
        """
        return FuzzyBool(min(self, other))

    def __or__(self, other):
        return FuzzyBool(max(self, other))

    def __ior__(self, other):
        return FuzzyBool(max(self, other))

    def __repr__(self):
        return "{0}({1})".format(self.__class__.__name__,
                                 super().__repr__())

    def __bool__(self):
        return self > 0.5

    def __int__(self):
        return round(self)

    def __add__(self, other):
        """
        FuzzyBool类型加法是没有意义的
        :param other:
        :return:
        """
        raise  TypeError("unsupported operand type(s) for '+':"
                         "'{0}' and '{1}'".format(
            self.__class__.__name__, other.__class__.__name__
        ))

    def __iadd__(self, other):
        raise NotImplementedError()

    def __radd__(self, other):
        """
        通过TypeError异常
        :param other:
        :return:
        """

        raise  TypeError("unsupported operand type(s) for '+':"
                         "'{0}' and '{1}'".format(
            self.__class__.__name__, other.__class__.__name__
        ))

    def __neg__(self):
        raise NotImplementedError()

    def __eq__(self, other):
        raise NotImplemented

if __name__ == "__main__":

    import doctest
    doctest.testmod()

Tips 如何快速无效化不要的方法 exec()

将下段代码放在FuzzyBool控制范围内即可无效化"-"和"index()"。

该代码主要是用到了exec()函数。

当然，下面无效化的是单值操作，二元操作符等要更加复杂。

for name, operator in (("__neg__", "-"),
                       ("__index__", "index()")):
    message = "bad operand type for unary {0}: '{{self}}'".format(
        operator
    )
    exec("def {0}(self): raise TypeError(\"{1}\".format("
         "self=self.__class__.__name__))".format(name, message))

6.3 自定义组合类

本节将展式3种自定义类：

• Image 用于存放图像数据
• SortedList
• SortedDict

6.3.1 创建聚集组合数据的类

用于表示2D颜色图像的一个简单方法是使用一个2维数组存储，每个数组元素代表一种颜色。

Image将采用一种更加高效的做法：记入一种单一的背景色，以及图像种不同于背景色的颜色。

"""
This module provides the Image class which holds (x, y, color) triples
and a background color to provide a kind of sparse-array representation of
an image. A method to export the image in XPM format is also provided.

>>> import os
>>> import tempfile
>>> red = "#FF0000"
>>> blue = "#0000FF"
>>> img = os.path.join(tempfile.gettempdir(), "test.img")
>>> xpm = os.path.join(tempfile.gettempdir(), "test.xpm")
>>> image = Image(10, 8, img)
>>> for x, y in ((0, 0), (0, 7), (1, 0), (1, 1), (1, 6), (1, 7), (2, 1),
...             (2, 2), (2, 5), (2, 6), (2, 7), (3, 2), (3, 3), (3, 4),
...             (3, 5), (3, 6), (4, 3), (4, 4), (4, 5), (5, 3), (5, 4),
...             (5, 5), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (7, 1),
...             (7, 2), (7, 5), (7, 6), (7, 7), (8, 0), (8, 1), (8, 6),
...             (8, 7), (9, 0), (9, 7)):
...    image[x, y] = blue
>>> for x, y in ((3, 1), (4, 0), (4, 1), (4, 2), (5, 0), (5, 1), (5, 2),
...             (6, 1)):
...    image[(x, y)] = red
>>> print(image.width, image.height, len(image.colors), image.background)
10 8 3 #FFFFFF
>>> border_color = "#FF0000" # red
>>> square_color = "#0000FF" # blue
>>> width, height = 240, 60
>>> midx, midy = width // 2, height // 2
>>> image = Image(width, height, img, "#F0F0F0")
>>> for x in range(width):
...     for y in range(height):
...         if x < 5 or x >= width - 5 or y < 5 or y >= height -5:
...             image[x, y] = border_color
...         elif midx - 20 < x < midx + 20 and midy - 20 < y < midy + 20:
...             image[x, y] = square_color
>>> print(image.width, image.height, len(image.colors), image.background)
240 60 3 #F0F0F0
>>> image.save()
>>> newimage = Image(1, 1, img)
>>> newimage.load()
>>> print(newimage.width, newimage.height, len(newimage.colors), newimage.background)
240 60 3 #F0F0F0
>>> image.export(xpm)
>>> image.thing
Traceback (most recent call last):
...
AttributeError: 'Image' object has no attribute 'thing'
>>> for name in (img, xpm):
...     try:
...         os.remove(name)
...     except EnvironmentError:
...         pass
"""

import os, pickle
"""
在Python中，pickling是将Python对象进行序列化的一种方法。Pickling之所以
强大，是因为进行pickling处理的对象可以是组合数据类型。并且，即便要进行
pickling处理的对象内部包含其他对象，仍然可以统一进行pickling处理————并且
不会使得对象重复出现。
说实话，并没有很深的理解，有空找官方文档看看吧。
"""

"""
定义异常
"""
class ImageError(Exception): pass
class CoordinateError(ImageError): pass
class LoadError(ImageError): pass
class SaveError(ImageError): pass
class ExportError(ImageError): pass
class NoFilenameError(ImageError): pass

"""
Image 类
"""

class Image:
    """Class Image provides some methods about image, such as building and saving.

    """
    def __init__(self, width, height, filename="",
                 background="#FFFFFF"):
        """
        the keys of self.__data are (x, y)
        :param width:
        :param height:
        :param filename: default: ""
        :param background:  default: "#FFFFFF"  white
        """
        self.filename = filename
        self.__background = background
        self.__data = {}
        self.__width = width
        self.__height = height
        self.__colors = {self.__background}

    @property
    def background(self):
        return self.__background

    @property
    def width(self):
        return self.__width

    @property
    def height(self):
        return self.__height

    @property
    def colors(self):
        """
        why we set() the set. In, fact, we return
        a copy of self.__colors to avoid the changing in accident.
        :return:
        """
        return set(self.__colors) #返回一个复制而避免外界不小心的改变 | {self.__background}

    def __getitem__(self, coordinate):
        """
        y[k] 方法的实现 同时要求输入的2元组
        :param coordinate:
        :return:
        """
        assert len(coordinate) == 2, "coordinate should be a 2-tuple"
        if (not (0 <= coordinate < self.width) or
            not (0 <= coordinate[1] < self.height)):
            raise  CoordinateError(str(coordinate))
        return self.__data.get(tuple(coordinate), self.__background)

    def __setitem__(self, coordinate, color):
        """
        y[k] = v 方法的实现 同时要求输入2元组
        :param coordinate: 坐标
        :param color: 该坐标上的颜色
        :return: None
        """
        assert len(coordinate) == 2, "coordinate should be a 2-tuple"
        if (not (0 <= coordinate[0] < self.width) or
            not (0 <= coordinate[1] < self.height)):
            raise CoordinateError(str(coordinate))
        if color == self.__background:
            self.__data.pop(tuple(coordinate), None) # 不用del的原因是 避免产生异常
        else:
            self.__data[tuple(coordinate)] = color
            self.__colors.add(color)

    def __delitem__(self, coordinate):
        assert len(coordinate) == 2, "coordinate should be a 2-tuple"
        if (not (0 <= coordinate[0] < self.width) or
                not (0 <= coordinate[1] < self.height)):
            raise CoordinateError(str(coordinate))
        self.__data.pop(tuple(coordinate), None)

    def save(self, filename=None):
        """
        save the image...

        first block addresses the filename, if no filename is provided,
        raise Error.

        second block is the process to save

        :param filename:
        :return:
        """
        if filename is not None:
            self.filename = filename
        elif not self.filename:
            raise NoFilenameError()

        fh = None
        try:
            data = [self.width, self.height, self.__background,
                    self.__data]
            fh = open(self.filename, "wb") #二进制打开文件
            pickle.dump(data, fh, pickle.HIGHEST_PROTOCOL) #pickle.HIGHEST_PROTOCOL 是一种紧凑的二进制格式
        except (EnvironmentError, pickle.PicklingError) as err:
            raise SaveError(str(err))
        finally:
            if fh is not None:
                fh.close()

    def load(self, filename=None):
        """
        for load image...
        the first block is the same as save...
        the second block is the process to loading...
        :param filename:
        :return: None
        """
        if filename is not None:
            self.filename = filename
        elif not self.filename:
            raise NoFilenameError()

        fh = None
        try:
            fh = open(self.filename, "rb")
            data = pickle.load(fh)
            (self.__width, self.__height,
             self.__background, self.__data) = data
            self.__colors = (set(self.__data.values()) |
                             {self.__background}) # s.union(t) == s|t
        except (EnvironmentError, pickle.UnpicklingError) as err:
            raise LoadError(str(err))
        finally:
            if fh is not None:
                fh.close()

    def export(self, filename):
        if filename.lower().endswith(".xpm"):
            self.__export_xpm(filename) #
        else:
            raise ExportError("unsupported export format:" +
                              os.path.splitext(filename)[1])

    def __export_xpm(self, filename):  #直接从源代码中复制过来的
        """Exports the image as an XPM file if less than 8930 colors are
        used
        """
        name = os.path.splitext(os.path.basename(filename))[0]
        count = len(self.__colors)
        chars = [chr(x) for x in range(32, 127) if chr(x) != '"']
        if count > len(chars):
            chars = []
            for x in range(32, 127):
                if chr(x) == '"':
                    continue
                for y in range(32, 127):
                    if chr(y) == '"':
                        continue
                    chars.append(chr(x) + chr(y))
        chars.reverse()
        if count > len(chars):
            raise ExportError("cannot export XPM: too many colors")
        fh = None
        try:
            fh = open(filename, "w", encoding="ascii")
            fh.write("/* XPM */\n")
            fh.write("static char *{0}[] = {{\n".format(name))
            fh.write("/* columns rows colors chars-per-pixel */\n")
            fh.write('"{0.width} {0.height} {1} {2}",\n'.format(
                     self, count, len(chars[0])))
            char_for_colour = {}
            for color in self.__colors:
                char = chars.pop()
                fh.write('"{char} c {color}",\n'.format(**locals()))
                char_for_colour[color] = char
            fh.write("/* pixels */\n")
            for y in range(self.height):
                row = []
                for x in range(self.width):
                    color = self.__data.get((x, y), self.__background)
                    row.append(char_for_colour[color])
                fh.write('"{0}",\n'.format("".join(row)))
            fh.write("};\n")
        except EnvironmentError as err:
            raise ExportError(str(err))
        finally:
            if fh is not None:
                fh.close()

if __name__ == "__main__":

    import doctest
    doctest.testmod()

组合类型的特殊方法 [ ], in

特殊方法	使用	描述
__contains__(self, x)	x in y	如果x在序列y中，或x是映射y种的键,就返回True
__delitem__(self, k)	del y[k]	删除序列y中的第k项或映射y中键为k的项
__getitem__(self, k)	y[k]	返回序列y中第k项或映射y中键为k的项的值
__iter__(self)	for x in y: pass	返回序列y中的项或映射y中键的迭代子
__len__(self)	len(y)	返回y中项的个数
__reversed__(self)	reversed(y)	返回序列y中的项或映射y中的键的反向迭代子
__setitem__(self, k, v)	y[k] = v	将序列y中的第k项(或映射y中键为k的项）设置为v

6.3.2 使用聚集创建组合类 SortedList

"""
>>> L = SortedList((5, 8, -1, 3, 4, 22))
>>> L[2] = 18 #doctest: +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
TypeError: use add() to insert a value and rely on the...
>>> list(L)
[-1, 3, 4, 5, 8, 22]
>>> L.add(5)
>>> L.add(5)
>>> L.add(6)
>>> list(L)
[-1, 3, 4, 5, 5, 5, 6, 8, 22]
>>> L.index(4)
2
>>> L.count(5), L.count(2)
(3, 0)
>>> L.insert(2, 9)
Traceback (most recent call last):
...
AttributeError: 'SortedList' object has no attribute 'insert'
>>> L.reverse()
Traceback (most recent call last):
...
AttributeError: 'SortedList' object has no attribute 'reverse'
>>> L.sort()
Traceback (most recent call last):
...
AttributeError: 'SortedList' object has no attribute 'sort'

>>> import collections
>>> isinstance(L, collections.Sequence)
False
"""

_identity = lambda x: x

class SortedList:
    def __init__(self, sequence=None, key=None):
        """Creates a SortedList that orders using < on the items,
        or on the results of using the given key function

        >>> L = SortedList()
        >>> print(L)
        []
        >>> L = SortedList((5, 8, -1, 3, 4, 22))
        >>> print(L)
        [-1, 3, 4, 5, 8, 22]
        >>> L = SortedList({9, 8, 7, 6, -1, -2})
        >>> print(L)
        [-2, -1, 6, 7, 8, 9]
        >>> L = SortedList([-5, 4, -3, 8, -2, 16, -1, 0, -3, 8])
        >>> print(L)
        [-5, -3, -3, -2, -1, 0, 4, 8, 8, 16]
        >>> L2 = SortedList(L)
        >>> print(L2)
        [-5, -3, -3, -2, -1, 0, 4, 8, 8, 16]
        >>> L = SortedList(("the", "quick", "brown", "fox", "jumped"))
        >>> print(L)
        ['brown', 'fox', 'jumped', 'quick', 'the']
        >>> L.index('1')
        Traceback (most recent call last):
        ...
        ValueError: SortedList.index(x): x not in list
        """
        self.__key = key or _identity  #_identity = lambda x: x
        assert hasattr(self.__key, "__call__") # 对象是否能调用
        if sequence is None:
            self.__list = []
        elif (isinstance(sequence, SortedList) and
              sequence.key == self.__key):
            """因为Python采用的是短路检测，所以不用担心后面部分会报错
            如果key使用lambdaIf创建的，那么这部分就不会执行，所以，这部分
            代码可能不会带来多大效率的提升。
            """
            self.__list = sequence.__list[:]
        else:
            self.__list = sorted(list(sequence), key=self.__key)

    @property
    def key(self):
        return self.__key

    def add(self, value):
        """
        书上说为了避免index超出限制，才分开来
        事实上，没问题啊，即便超出了也是加末尾
        所以不需要分类讨论
        是Python版本的问题？
        :param value:
        :return:
        """

        index = self.__bisect_left(value)
        if index == len(self.__list):
            self.__list.append(value)
        else:
            self.__list.insert(index, value)

    def __bisect_left(self, value):
        """
        二叉树算法找插入的index
        :param value:
        :return:
        """
        key = self.__key(value)
        left, right = 0, len(self.__list)
        while left < right:
            middle = (left + right) // 2
            if self.__key(self.__list[middle]) < key:
                left = middle + 1
            else:
                right = middle

        return left

    def remove(self, value):
        index = self.__bisect_left(value)
        if index < len(self.__list) and self.__list[index] == value:
            del self.__list[index]
        else:
            raise ValueError("{0}.remove(x): x not in list.".format(
                self.__class__.__name__
            ))

    def remove_every(self, value):
        """
        删除每一个值为value的项
        :param value:
        :return:
        """
        count = 0
        index = self.__bisect_left(value)
        while (index < len(self.__list) and
               sekf.__list[index] == value):
            del self.__list[index]
            count += 1
        return count

    def count(self, value):
        """
        :param value:
        :return: 值为value的项的数目
        """
        count = 0
        index = self.__bisect_left(value)
        while(index < len(self.__list) and
              self.__list[index] == value):
            index += 1
            count += 1

        return count

    def index(self, value):
        """返回值为value的index，如果不存在报错"""
        index = self.__bisect_left(value)
        if (index < len(self.__list) and
            self.__list[index] == value):
            return index
        raise ValueError("{0}.index(x): x not in list".format(
            self.__class__.__name__
        ))

    def __delitem__(self, index):
        del self.__list[index]

    def __getitem__(self, index):
        return self.__list[index]

    def __setitem__(self, index, value):
        """
        禁止 L[n] = k
        但是我觉得可以
        __delitem__()
        add()
        :param index:
        :param value:
        :return:
        """
        raise TypeError("use add() to insert a value and rely on"
                        "the list to pu it in the right place")

    def __iter__(self):
        """
        list(L), 此时Python将调用SortedList.__iter__(L)
        来提供list()函数所需要的序列。
        :return:
        """
        return iter(self.__list)

    def __reversed__(self):
        return reversed(self.__list)

    def __contains__(self, value):
        """是否包含value"""
        index = self.__bisect_left(value)
        return (index < len(self.__list) and
                self.__list[index] == value)
    def clear(self):
        self.__list = []

    def pop(self, index=-1):
        return self.__list.pop(index)

    def __len__(self):
        return len(self.__list)

    def __str__(self):
        return str(self.__list)

    def copy(self):
        return SortedList(self, self.__key)

    __copy__ = copy #其意义在于，使得copy.copy()也将调用copy()方法

if __name__ == "__main__":
    import doctest
    doctest.testmod()

6.3.3 使用继承创建组合类

"""A dictionary that is sorted by < over its keys or by < over
the result of the key function applied to the keys

These are tests for inherited methods that aren't reimplemented
>>> d = SortedDict(dict(s=1, a=2, n=3, i=4, t=5, y=6))
>>> d["i"]
4
>>> d["y"]
6
>>> d["z"]
Traceback (most recent call last):
...
KeyError: 'z'
>>> d = SortedDict(dict(s=1, a=2, n=3, i=4, t=5, y=6))
>>> d.get("X", 21)
21
>>> d.get("i")
4
>>> d = SortedDict(dict(s=1, a=2, n=3, i=4, t=5, y=6))
>>> "a" in d
True
>>> "x" in d
False
>>> d = SortedDict(dict(s=1, a=2, n=3, i=4, t=5, y=6))
>>> len(d)
6
>>> del d["n"]
>>> del d["y"]
>>> len(d)
4
>>> d.clear()
>>> len(d)
0
>>> d = SortedDict(dict(V=1, E=2, I=3, N=4, S=5))
>>> str(d)
"{'E': 2, 'I': 3, 'N': 4, 'S': 5, 'V': 1}"
"""

from practice import SortedList

class SortedDict(dict):

    def __init__(self, dictionary=None, key=None, **kwargs):
        """Initializes with a shallow copy of the given dictionary
               and/or with keyword key=value pairs and preserving order using
               the key function. All keys must be unique.

               key is a key function which defaults to the identity
               function if it is not specified

               >>> d = SortedDict(dict(s=1, a=2, n=3, i=4, t=5, y=6))
               >>> list(d.items())
               [('a', 2), ('i', 4), ('n', 3), ('s', 1), ('t', 5), ('y', 6)]
               >>> dict(SortedDict())
               {}
               >>> e = SortedDict(d)
               >>> list(e.items())
               [('a', 2), ('i', 4), ('n', 3), ('s', 1), ('t', 5), ('y', 6)]
               >>> dict(e)
               {'a': 2, 'i': 4, 'n': 3, 's': 1, 't': 5, 'y': 6}
               >>> f = SortedDict(key=str.lower, S=1, a=2, n=3, I=4, T=5, y=6)
               >>> dict(f)
               {'a': 2, 'I': 4, 'n': 3, 'S': 1, 'T': 5, 'y': 6}
               """
        dictionary = dictionary or {}
        super().__init__(dictionary)
        if kwargs:
            super().update(kwargs)
        self.__keys = SortedList.SortedList(super().keys(), key)

    def update(self, dictionary=None, **kwargs):
        if dictionary is None:
            pass
        elif isinstance(dictionary, dict):
            super().update(dictionary)
        else:
            for key, value in dictionary.items():#如果没有提供items方法，AttributeError
                super().__setitem__(key, value)
        if kwargs:
            super().update(kwargs)
        self.__keys = SortedList.SortedList(super().keys(), self.__keys.key)

    @classmethod #类方法 可以调用类属性ClassCase.classmethod() 会自动传入cls
    def fromkeys(cls, iterable, value=None, key=None):
        return cls({k: value for k in iterable}, key)

    def __setitem__(self, key, value):
        if key not in self:
            self.__keys.add(key)
        return super().__setitem__(key, value)

    def __delitem__(self, key):
        try:
            self.__keys.remove(key)
        except ValueError:
            raise KeyError(key)
        return super().__delitem__(key)

    def setdefault(self, key, value=None):
        if key not in self:
            self.__keys.add(key)
        return super().setdefault(key, value)

    def pop(self, key, *args):
        """
        d.pop(k)
        d.pop(k, value)
        :param key:
        :param args:
        :return:
        """
        if key not in self:
            if len(args) == 0:
                raise KeyError(key)
            return args[0]
        self.__keys.remove(key)
        return super().pop(key, args)

    def popitem(self):
        """
        移除并返回字典中一个随机的键-值对
        :return:
        """
        item = super().popitem()
        self.__keys.remove(item[0])
        return item

    def clear(self):
        super().clear()
        self.__keys.clear()

    def values(self):
        """
        返回的是一个迭代子
        :return:
        """
        for key in self.__keys:
            yield self[key]

    def items(self):
        """
        迭代子
        :return:
        """
        for key in self.__keys:
            yield key, self[key]

    def __iter__(self):
        return iter(self.__keys)

    keys = __iter__ #相同功效

    def __repr__(self):
        """不能eval()的表象形式"""
        return object.__repr__(self)

    def __str__(self):
        return "{" + ", ".join(["{0!r}: {1!r}".format(k, v)
                                for k, v in self.items()]) + "}"

    def copy(self):
        """
        不带参数的时候,super()将针对基类与对象进行工作。
        这里我们显示地传递类与对象
        :return:
        """
        d = SortedDict()
        super(SortedDict, d).update(self) # == dict.update(d, self) | d.update(self)
        d.__keys = self.__keys.copy()
        return d

    __copy__ = copy

    def value_at(self, index):
        """因为这是有序地dict所以可以根据位置来获取"""
        return self[self.__keys[index]]

    def set_value_at(self, index, value):
        self[self.__keys[index]] = value

if __name__ == "__main__":
    import doctest
    doctest.testmod()

静态方法与类方法

静态方法：

class foo:
    @staticmethod
    def f():
        print("Q!!!!")

f = foo()
foo.f(), f.f()

类方法：

class foo:
    @classmethod
    def f(cls):
        print("Q!!!!")

f = foo()
foo.f(), f.f()

上面的输出都是：

Q!!!!
Q!!!!
(None, None)

@staticmethod是修饰器，具体如何实现我不知道，但是，如果像下面一样定义foo:

class foo:
    def f():
        print("Q!!!!")

执行foo.f() 没有问题

但是执行f.f()的时候就有问题了，

TypeError                                 Traceback (most recent call last)
<ipython-input-54-4591815b19b5> in <module>
	4
 	5 f = foo()
----> 6 foo.f(), f.f()
TypeError: f() takes 0 positional arguments but 1 was given

大概是Python在执行的时候，默认当期为实例方法，会把实例作为第一个参数传入而报错。@staticmethod的作用大概就是修正这一点。

而@classmethod的作用则是，无论是通过类还是实例调用方法，都只会把类作为第一个参数传入。这大概就是修饰器的作用所在。修饰器的强大可见一斑。

6.5 练习

import pickle

class AccountError(Exception): pass
class SaveError(AccountError): pass
class LoadError(AccountError): pass

class Transaction:
    """
    实现一个Transaction类

    >>> t = Transaction(100, "2019-2-18", "RMB", 0.1476, "Go forward...")
    >>> t.amount
    100
    >>> t.date
    '2019-2-18'
    >>> t.currency
    'RMB'
    >>> t.usd_conversion_rate
    0.1476
    >>> t.description
    'Go forward...'
    """
    def __init__(self, amount, date, currency="USD",
                 usd_conversion_rate=1, description=None):
        """
        属性均为私有
        :param amount:
        :param date:
        :param currency: 默认为"USD"，U.S. dollars
        :param usd_conversion_rate: 默认为1
        :param description: 默认为None
        """
        self.__amount = amount
        self.__date = date
        self.__currency = currency
        self.__usd_conversion_rate = usd_conversion_rate
        self.__description = description

    @property
    def amount(self):
        return self.__amount

    @property
    def date(self):
        return self.__date

    @property
    def currency(self):
        return self.__currency

    @property
    def usd_conversion_rate(self):
        return self.__usd_conversion_rate

    @property
    def description(self):
        return self.__description

    @property
    def usd(self):
        return self.__amount * self.__usd_conversion_rate

class Account:
    """
    >>> import os
    >>> import tempfile
    >>> name = os.path.join(tempfile.gettempdir(), "account01")
    >>> account = Account(name, "Qtrac Ltd.")
    >>> os.path.basename(account.number), account.name,
    ('account01', 'Qtrac Ltd.')
    >>> account.balance, account.all_usd, len(account)
    (0.0, True, 0)
    >>> account.apply(Transaction(100, "2008-11-14"))
    >>> account.apply(Transaction(150, "2008-12-09"))
    >>> account.apply(Transaction(-95, "2009-01-22"))
    >>> account.balance, account.all_usd, len(account)
    (155.0, True, 3)
    >>> account.apply(Transaction(50, "2008-12-09", "EUR", 1.53))
    >>> account.balance, account.all_usd, len(account)
    (231.5, False, 4)
    >>> account.save()
    >>> newaccount = Account(name, "Qtrac Ltd.")
    >>> newaccount.balance, newaccount.all_usd, len(newaccount)
    (0.0, True, 0)
    >>> newaccount.load()
    >>> newaccount.balance, newaccount.all_usd, len(newaccount)
    (231.5, False, 4)
    >>> try:
    ...     os.remove(name + ".acc")
    ... except EnvironmentError:
    ...     pass
    """
    def __init__(self, number, name):
        self.__number = number
        self.__name = name
        self.__transactions = []

    @property
    def number(self):
        return self.__number

    @property
    def name(self):
        return self.__name

    @name.setter
    def name(self, name):
        assert isinstance(name, str) and len(name) > 3, \
            "name must be string whose length >= 4"
        self.__name = name

    def __len__(self):
        return len(self.__transactions)

    @property
    def balance(self):
        """
        交易额  单位USD
        :return:
        """
        total = 0.0
        for transaction in self.__transactions:
            total += transaction.usd
        return total

    @property
    def all_usd(self):
        """是否均为USD"""
        for transaction in self.__transactions:
            if transaction.currency is not "USD":
                return False
        return True

    def apply(self, transaction):
        if not isinstance(transaction, Transaction):
            raise TypeError("{0} is not Transaction".format(transaction))
        self.__transactions.append(transaction)

    def save(self):
        """数据保存为number.acc"""
        fh = None
        try:
            data = [self.__number, self.__name, self.__transactions]
            fh = open(self.__number + ".acc", "wb")
            pickle.dump(data, fh, pickle.HIGHEST_PROTOCOL)
        except (EnvironmentError, pickle.PicklingError) as err:
            raise SaveError(str(err))

        finally:
            if fh is not None:
                fh.close()

    def load(self):
        """加载数据，原有数据会被覆盖"""
        fh = None
        try:
            fh = open(self.__number + ".acc", "rb")
            data = pickle.load(fh)
            assert self.__number == data[0], "not match"
            self.__name, self.__transactions = data[1:]
        except (EnvironmentError, pickle.UnpicklingError) as err:
            raise LoadError(str(err))
        finally:
            if fh is not None:
                fh.close()

if __name__ == "__main__":
    import doctest
    doctest.testmod()