python面对对象编程----------7:callable（类调用）与context（上下文）

一：callables

　　callables使类实例能够像函数一样被调用

　　如果类需要一个函数型接口这时用callable，最好继承自abc.Callable，这样有些检查机制并且一看就知道此类的目的是callable对象
如果类需要有‘记忆’功能，使用callable是非常方便的相对于函数而言，callable语法什么的就要复杂多了，这也是其主要的缺点：

    def x(args):
        body
    转化为callable对象：
    class X(collections.abc.callable):
        def __call__(self, args):
            body
    x= X()


　　1：计算x^y

import collections.abc                          #注，完全可以不引入cleection.abc，引入是为了能够做一些错误检查
    class Power1( collections.abc.Callable ):
    def __call__( self, x, n ):
        p= 1
        for i in range(n):
            p *= x
        return p

power= Power1()
>>> power( 2, 0 )           #像函数一样调用实例
1
>>> power( 2, 1 )
2
>>> power( 2, 2 )
4
>>> power( 2, 10 )
1024

# 提升性能：上面是O(n),用递归改进为O(logn)
class Power4( abc.Callable ):
    def __call__( self, x, n ):
        if n == 0:
            return 1
        elif n % 2 == 1:
            return self.__call__(x, n-1)*x
        else:
            t= self.__call__(x, n//2)
            return t*t

pow4= Power4()

# 再次提升性能，使用记忆功能【注：可以{（2，4）：16，... }
class Power5( collections.abc.Callable ):
    def __init__( self ):
        self.memo = {}
    def __call__( self, x, n ):
        if (x,n) not in self.memo:
            if n == 0:
                self.memo[x,n]= 1
            elif n % 2 == 1:
                self.memo[x,n]= self.__call__(x, n-1) * x
            elif n % 2 == 0:
                t= self.__call__(x, n//2)
                self.memo[x,n]= t*t
            else:
                raise Exception("Logic Error")
        return self.memo[x,n]

pow5= Power5()

# 再次改进，python库自带了一个记忆装饰器，可以使用这个从而不不用自定义callable对象
from functools import lru_cache
@lru_cache(None)
def pow6( x, n ):
    if n == 0:
        return 1
    elif n % 2 == 1:
        return pow6(x, n-1)*x
    else:
        t= pow6(x, n//2)
        return t*t
# Previous requests are stored in a memoization cache. The requests are
# tracked in the cache, and the size is limited. The idea behind an LRU cache is that
# the most recently made requests are kept and the least recently made requests are quietly purged.

　　　2：赌注翻倍：综合运用callables，输家翻倍赌注政策：每输一次后赌注就加倍直到赢了后回归原本赌注

class BettingMartingale( BettingStrategy ):
    def __init__( self ):
        self._win= 0
        self._loss= 0
        self.stage= 1
    @property
    def win(self):
        return self._win
    @win.setter
    def win(self, value):
        self._win = value
        self.stage= 1
    @property
    def loss(self):
        return self._loss
    @loss.setter
    def loss(self, value):
        self._loss = value
        self.stage *= 2

    def __call__( self ):
        return self.stage

>>> bet= BettingMartingale()
>>> bet()
1
>>> bet.win += 1
>>> bet()
1
>>> bet.loss += 1
>>> bet()
2

# property的使用使类的定义显得冗杂，实际上我们只关心setters，所以我们用__setattr__来改进上述版本
class BettingMartingale2( BettingStrategy ):
    def __init__( self ):
        self.win= 0
        self.loss= 0
        self.stage= 1
    def __setattr__( self, name, value ):
        if name == 'win':
            self.stage = 1
        elif name == 'loss':
            self.stage *= 2
        super().__setattr__( name, value )
    def __call__( self ):
        return self.stage

二：context

　　A context is generally used to acquire/release, open/close, and lock/unlock types of operation pairs.
　　Most of the examples are file I/O related, and most of the file-like objects in Python are already proper context managers.

　　1：一些context
   　　 1:最常见的是用在文件的，with语句创建
　　    2：decimal context：decimal是一个模块，常用于一些对于精度要求比较严格的计算，其本身运行在一个context中，通过改context可以对全局的计算产生影响
　　    3：还有一些context，主要都是用于类文件的操作
　　2：构造context（第八章会详细讲解构造context）
   　　 context最主要的是有__enter__()与__exit__()方法，分别在with语句开始和结束时调用
　　    抛出的问题都会以traceback参数传递到__exit__()函数中，应该做相应处理。

　　例子：错误处理context：在打开文件时做备份，若处理完文件没出问题就删除备份，若出了问题就使用备份来恢复原文件

import os
class Updating:
    def __init__( self, filename ):
        self.filename= filename
    def __enter__( self ):                  #做文件备份
        try:
            self.previous= self.filename+" copy"
            os.rename( self.filename, self.previous )
        except FileNotFoundError:
            # Never existed, no previous copy
            self.previous= None

    def __exit__( self, exc_type, exc_value, traceback ):       #
        if exc_type is not None:
            try:
                os.rename( self.filename, self.filename+ " error" )
            except FileNotFoundError:
                pass # Never even got created?
            if self.previous:
                os.rename( self.previous, self.filename )       #用备份文件恢复原文件

with Updating( "some_file" ):
    with open( "some_file", "w" ) as target:
         process( target )