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