class Entity: 
    def __init__(self, size, x, y):     
        self.x, self.y = x, y     
        self.size = size     
    def __call__(self, x, y):     
        self.x, self.y = x, y

会话管理

在Python 2.5中，为了代码利用定义了一个新的关键词 with 语句。会话控制在Python中不罕见(之前是作为库的一部分被实现)，直到 PEP343 被添加后。它被成为一级语言结构。你也许之前看到这样的语句:

with open('foo.txt') as bar:
# perform some action with bar

回话控制器通过包装一个 with 语句来设置和清理行为。回话控制器的行为通过两个魔术方法来定义:

•  __enter__(self) 定义当使用 with 语句的时候会话管理器应该初始块被创建的时候的行为。注意 __enter__ 的返回值被 with 语句的目标或者 as 后的名字绑定。 

• __exit__(self, exception_type, exception_value, traceback) 定义当一个代码块被执行或者终止后会话管理器应该做什么。它可以被用来处理异常，清楚工作或者做一些代码块执行完毕之后的日常工作。如果代码块执行成功， exception_type , exception_value , 和 traceback 将会是 None。否则的话你可以选择处理这个异常或者是直接交给用户处理。如果你想处理这个异常的话，确认 __exit__ 在所有结束之后会返回 True 。如果你想让异常被会话管理器处理的话，那么就这样处理。

__enter__ 和 __exit__ 对于明确有定义好的和日常行为的设置和清洁工作的类很有帮助。你也可以使用这些方法来创建一般的可以包装其他对象的会话管理器。以下是一个例子。

class Closer:     
    '''通过with语句和一个close方法来关闭一个对象的会话管理器'''      
    def __init__(self, obj):
        self.obj = obj      
    def __enter__(self):         
        return self.obj # bound to target      
    def __exit__(self, exception_type, exception_val, trace):         
        try:             
            self.obj.close()         
        except AttributeError: 
            # obj isn't closable             
            print 'Not closable.'             
            return True # exception handled successfully

以下是一个使用 Closer 的例子，使用一个FTP链接来证明(一个可关闭的套接字):

>>> from magicmethods import Closer 

>>> from ftplib import FTP 

>>> with Closer(FTP('ftp.somesite.com')) as conn: 

...  conn.dir() 

... 

>>> conn.dir() 

>>> with Closer(int(5)) as i: 

...  i += 1 

... Not closable. 

>>> i 6 

你已经看到了我们的包装器如何静默的处理适当和不适当的使用行为。这是会话管理器和魔术方法的强大功能。

class Meter(object):     
    '''Descriptor for a meter.'''     
    def __init__(self, value=0.0):         
    	self.value = float(value)     
    def __get__(self, instance, owner):         
    	return self.value     
    def __set__(self, instance, value):         
    	self.value = float(value)  

class Foot(object):     
	'''Descriptor for a foot.'''     
	def __get__(self, instance, owner):         
		return instance.meter * 3.2808     

	def __set__(self, instance, value):         
		instance.meter = float(value) / 3.2808  

class Distance(object):     
	'''Class to represent distance holding two descriptors for feet and meters.'''     
	meter = Meter()     
	foot = Foot()

储存你的对象

如果你接触过其他的 Pythoner，你可能已经听说过 Pickle 了， Pickle 是用来序列化 Python 数据结构的模块，在你需要暂时存储一个对象的时候（比如缓存），这个模块非常的有用，不过这同时也是隐患的诞生地。

序列化数据是一个非常重要的功能，所以他不仅仅拥有相关的模块（ Pickle , cPickle ），还有自己的协议以及魔术方法，不过首先，我们先讨论下关于序列化内建数据结构的方法。

Pickling: 简单例子

让我们深入研究 Pickle，比如说你现在需要临时储存一个字典，你可以把它写入到一个文件里，并且要小心翼翼的确保格式正确，之后再用 exec() 或者处理文件输入来恢复数据，实际上这是很不安全的，如果你使用文本存储了一些重要的数据，任何方式的改变都可能会影响到你的程序，轻则程序崩溃，重则被恶意程序利用，所以，让我们用 Pickle 代替这种方式：

import pickle 

data = {'foo': [1, 2, 3], 'bar': ('Hello', 'world!'), 'baz': True}  

jar = open('data.pkl', 'wb') 

pickle.dump(data, jar) # write the pickled data to the file jar  

jar.close() 

嗯，过了几个小时之后，我们需要用到它了，只需把它 unpickle 了就行了：

import pickle 

pkl_file = open('data.pkl', 'rb') # connect to the pickled data  

data = pickle.load(pkl_file) # load it into a variable 

print data pkl_file.close() 

正如你期望的，数据原封不动的回来了！

同时要给你一句忠告： pickle 并不是很完美， Pickle 文件很容易被不小心或者故意损坏， Pickle 文件比纯文本文件要稍微安全一点，但是还是可以被利用运行恶意程序。 Pickle 不是跨版本兼容的（译注：最近刚好在 《Python Cookbook》上看到相关讨论，书中描述的 Pickle 是跨版本兼容的，此点待验证），所以尽量不要去分发 Pickle 过的文本，因为别人并不一定能够打开。不过在做缓存或者其他需要序列化数据的时候， Pickle 还是很有用处的。

例子

我们以 Slate 为例，这是一段记录一个值以及这个值是何时被写入的程序，但是，这个 Slate 有一点特殊的地方，当前值不会被保存。

import time  

class Slate: 
	'''Class to store a string and a changelog, and forget its value when  pickled.'''      
	def __init__(self, value):                     
		self.value = value          
		self.last_change = time.asctime()         
		self.history = {}     

	def change(self, new_value): 
		# Change the value. Commit last value to history          
		self.history[self.last_change] = self.value         
		self.value = new_value          
		self.last_change = time.asctime()      

	def print_changes(self):         

		print 'Changelog for Slate object:'          
		for k, v in self.history.items():             
			print '%s\t %s' % (k, v)     

	def __getstate__(self): 
		# Deliberately do not return self.value or self.last_change. 
		# We want to have a "blank slate" when we unpickle.         
		return self.history     

	def __setstate__(self, state): 
		# Make self.history = state and last_change and value undefined         
		self.history = state         
		self.value, self.last_change = None, None