Python in Practice

Reference: Summerfield, Mark. Python in practice: create better programs using concurrency, libraries, and patterns. Addison-Wesley, 2013.

1. Python的创建型设计模式

抽象工厂模式

PASS

建造者模式

PASS

工厂方法模式

Class = type(name, *args, dict(__slots__ = (), __new__ = new))
setattr(sys.modules[__name__], name, Class)
Class = type(name, *args, dict(__slots__ = (), __new__ = new))
globals()[name] = Class

原型模式

class Point:
    __slots__ = {"x", "y"}

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

def make_object(Class, *args, **kwargs):
    return Class(*args, **kwargs)

point1 = Point(1, 2)
point2 = eval("{}({}, {})".format("Point", 2, 4)) # Risky
point3 = getattr(sys.modules[__name__], "Point")(3, 6)
point4 = globals()["Point"](4, 8)
point5 = make_object(Point, 5, 10)
point6 = copy.deepcopy(point5)
point6.x = 6
point6.y = 12
point7 = point1.__class__(7, 14)

单例模式

PASS

2. Python的结构型设计模式

适配器模式

  • Python内置的isinstance()函数要通过__subclasshook()__来决定函数的首个参数是不是第二个参数的子类。如果这个方法返回True或者False,那么isinstance()的判定流程就会终止并返回bool值;若返回NotImplemented,则会沿着继承体系按照通常的规则继续判定下去(判断SubClass是不是本类的子类、是不是”显式注册类”(explicitly registered class)的子类、是不是子类的子类)
@classmethod
def __subclasshook__(Class, SubClass)

桥接模式

PASS

组合模式

  • __iter__返回一个迭代器,对应for循环

修饰器模式

  • 装饰器工厂
def statically_typed(*types, return_type = None):
    def decorator(function):
        @functools.wraps(function)
        def wrapper(*args, **kwargs):
            if len(args) > len(types):
                raise ValueError("too many arguments")
            elif len(args) < len(types):
                raise ValueError("too few arguments")
            for i, (arg, type_) in enumerate(zip(args, types)):
                if not isinstance(arg, type_):
                    raise ValueError("argument {} must be of type {}"
                            .format(i, type_.__name__))
            result = function(*args, **kwargs)
            if (return_type is not None and
                not isinstance(result, return_type)):
                raise ValueError("return value must be of type {}".format(
                        return_type.__name__))
            return result
        return wrapper
    return decorator
  • 类装饰器
def ensure(name, validate, doc = None):
    def decorator(Class):
        privateName = "_" + name
        def getter(self):
            return getattr(self, privateName)
        def setter(self, value):
            validate(name, value)
            setattr(self, privateName, value)
        setattr(Class, name, property(getter, setter, doc = doc))
        return Class
    return decorator

**外观模式**

- Facade Pattern
- context manager: `__enter__``__exit__`
- 外观模式看起来很像适配器模式,其区别在于,外观模式是在复杂的接口上提炼出一套简单的借口,而适配器则是把其他接口(未必很复杂)转换成标准接口

**享元模式**

- Flyweight Pattern: 只给每种对象创建一个实例,并在有需要时共享此实例

**代理模式**

PASS


## 3. Python的行为型设计模式

**责任链模式**

- 协程(coroutine)

```python
def coroutine(function):
    @functools.wrap(function)
    def wrapper(*args, **kwargs):
        generator = function(*args, **kwargs)
        next(generator)
        return generator
    return wrapper

命令模式

  • Command Pattern: 把命令封装成对象,从而构建命令序列,以便稍后执行,或是创建”可撤销的”(undoable)命令
  • callable
  • __call__

解释器模式

  • eval不同,exec并不局限于一条表达式,并且此函数总是返回None

迭代器模式

  • __getitem__(self, index)返回这个位置的元素,否则跑出IndexError异常
  • iter(callable, stop_element)每次迭代调用callable对象,只有当callable抛出StopIteration异常或返回标记值的时候,才停止迭代

中介者模式

  • Mediator Pattern: 创建中介者,并把对象之间的交互逻辑封装到里面

备忘录模式

  • Memento Pattern: 不破坏封装的前提下保存并恢复对象状态

观察者模式

  • Observer Pattern: 处理对象间”多对多”(many-to-many)的依赖关系,当某对象改变状态时,所有相关对象都会得到通知

状态模式

PASS

策略模式

PASS

模板方法模式

PASS

访问者模式

  • Visitor Pattern: 对集合或聚合中的每个对象运用函数

4. Python的高级并发技术

计算密集型并发

  • multiprocessing.Process
  • concurrent.futures.ProcessPoolExecutor
def wait_for(futures):
    canceled = False
    results = []
    try:
        for future in concurrent.futures.as_completed(futures):
            err = future.exception()
            if err is None:
                result = future.result()
                results.append(result)
            else:
                raise err
    except KeyboardInterrupt:
        canceled = True
        for future in futures:
            future.cancel()
    return canceled, results

I/O密集型并发

  • threading.Thread
  • concurrent.futures.ThreadPoolExecutor

案例研究:并发式GUI应用程序

  • 它会执行两个线程,一个是主GUI线程,一个是工作线程,而工作线程又会把工作交由进程池来完成
  • future.add_done_callback(callback)
  • threading.Lock()

5. 扩充Python

  • 通过ctypes访问C程序库
  • Cython的用法
  • 用Cython优化图像处理程序包

如何实现 C/C++ 与 Python 的通信?

6. Python高级网络编程

  • XML-RPC
  • RPyC

7. 用Tkinter开发图形用户界面

PASS

8. 用OpenGL绘制3D图形

PASS

Written on June 25, 2017