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.

callable试例1

　　　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

callable示例2

二：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 )