1、引言
(1)類和執行個體:類是對象的定義,執行個體是“真正的實物”。
定義類:類名通常大寫字母打頭。
class MyNewObjectType(bases): 'define MyNewObjectType class' class_suite
bases可以是一個(單繼承)或多個(多重繼承)用於繼承的父類。
object是“所有類之母”。
Python調用類進行執行個體化,執行個體化類不使用new關鍵字。
>>>c=MyNewObjectType()
類有時可以僅作為名稱空間。
class MyData(object): passmathobj=MyData()mathobj.x=4mathobj.y=5
這些屬性是動態,不需要在構造器中或其他任何地方為它們預先聲明或賦值。
(2)方法
定義方法:屬性和方法使用駝峰記法。
class MyDataWithMethod(object): def printFoo(self): print ....
所有方法都存在self,表示執行個體對象本身。
靜態方法或類方法不需要self。
__init__()方法類似於建構函式,但不同於建構函式,因Python不new。該方法在執行個體被建立後,執行個體化調用返回這個執行個體之前被調用。
2、物件導向編程常用術語 抽象/實現:建模 現實化 封裝/介面 合成:聯合、彙總 繼承/派生 泛化/特化 多態 自省/反射
3、類
Python中,一切皆為對象。
下面是類的定義文法。
class ClassName(object): 'class documentation string' class_suite
Python不支援純虛函數(像C++)或者抽象方法等。
替代方案:在基類方法中引發NotImplementedError異常。
4、類屬性
(1)屬性
屬性(資料或函數),使用句點屬性標識符來訪問。
屬性本身也是一個對象,也有自己的屬性,所以訪問屬性時會形成一個屬性鏈。
(2)類屬性/執行個體資料屬性
執行個體屬性在OOP中用得最多,類屬性僅當需要有更加“靜態”資料類型時才變得有用,它和任何執行個體無關,方法是類屬性。
Python要求,沒有執行個體,方法不能被調用。方法必須“綁定”到一個執行個體才能直接被調用。非綁定的方法可能可以被調用,但執行個體對象一定要明確給出,才能保證調用成功。然而,不管是否綁定,方法都是它所在的類的固有屬性,即使它們幾乎總是通過執行個體來調用的。
(3)確定一個類有哪些屬性的方法 使用內建函數dir() 訪問類的字典屬性__dict__ 內建函數vars()接受類對象作為參數,返回類的__dict__屬性的內容。
(4)特殊的類屬性 C.__name__ 類C的名字(字串) C.__doc__ 類C的文檔字串 C.__bases__ 類C的所有父類構成的元組 C.__dict__ 類C的屬性 C.__module__ 類C所在的模組(1.5) C.__class__ 執行個體C對應的類(新式類)
5、執行個體
Python 2.2中統一了類和類型。
Python通過調用類對象來建立執行個體。
①__init__()方法
當類被調用,建立執行個體對象,對象建立後,調用__init__()方法完成特別的操作,執行完返回類對象,執行個體化結束。
Python沒有使用new建立執行個體,沒有定義構造器,由Python建立對象。
②__new__()方法
“構造器”方法,與__init__()方法相比,__new__()更像一個真正的構造器,因為__new__()必須返回一個合法的執行個體,該執行個體作為self傳給__init__()方法。
__new__()方法會調用父類的__new__()方法來建立對象。
在對內建類型進行派生時,__new__()方法可以執行個體化不可變對象。
③__del__()方法
“解構器”方法,當執行個體對象所有的引用都被清除掉後才執行該方法,用於執行個體釋放前進行特殊處理。 __del__()方法只能被調用一次。 使用__del__()方法,不要忘記首先調用父類的__del__()方法。 del x不表示調用x.__del__()方法,僅引用計數減少。 若存在循環參考,則對象的__del__()方法可能永遠不會被執行。 __del__()方法未捕獲的異常會被忽略掉,除非有必要,否則不去實現__del__()方法。 如果定義了__del__()方法,且執行個體是某個迴圈的一部分,記憶體回收行程將不會終止這個迴圈,你需要自己顯式調用del。
6、執行個體屬性
方法嚴格來說是類屬性。執行個體僅擁有資料屬性。
(1)”執行個體化”執行個體屬性
①在__init__()方法中設定執行個體屬性。
設定執行個體的屬性可以在執行個體建立後任意時間進行。__init__()方法是設定這些屬性的關鍵點之一。Python能夠在“運行時”建立執行個體屬性(Python優秀特性之一)
②預設參數提供預設的執行個體安裝。
class HotelRoomClac(object): def __init__(self,rt,sales=0.085,rm=0.1): self.salesTax=sales self.roomTax=rm self.roomRate=rt
③__init__()方法應該返回None
__init__()方法不應該返回任何對象,因為執行個體對象是自動在執行個體化調用後返回的。
(2)查看執行個體屬性 查看執行個體屬性:dir()、__dict__屬性、vars() 特殊的執行個體屬性:I.__class__、I.__dict__ 內建類型屬性:內建類型可以使用dir()方法,不可以訪問__dict__特殊屬性,因為在內建類型中,不存在這個屬性。
(3)類屬性和執行個體屬性(類似於自動變數和靜態變數)
可以採用類來訪問類屬性,若執行個體沒有同名的屬性的話,也可以用執行個體來訪問。
類屬性可以通過類或執行個體來訪問,不過只能使用類訪問類屬性時,才能更新類屬性的值。若在執行個體中更新類屬性,將會建立同名的執行個體屬性,“遮蔽”了類屬性。當刪除同名的執行個體屬性,類屬性才起作用。所以,從執行個體中訪問類屬性須謹慎。
class C(object): #定義類 version = 1.2#靜態成員>>>c=C()>>>C.version #通過類來訪問>>>c.version #通過執行個體來訪問>>>C.version+=0.1 #通過類(只能這樣)來更新類屬性>>>c.version =1.3 #任何對執行個體屬性的賦值都會建立一個執行個體屬性,而不是更新類屬性
當類屬性是可變類型時,並不會建立執行個體屬性,直接操作的是類屬性。
class Foo(object): x={2003:'poe2'}>>>foo=Foo()>>>foo.x[2004]='valid path'>>>foo.x{2003:'poe2',2004:'valid path'}>>>Foo.x{2003:'poe2',2004:'valid path'} #生效了>>>del foo.x #刪除會報錯,因為沒有遮蔽所以不能刪除掉
(4)類屬性持久性
類屬性,任憑整個執行個體(及其屬性)的如何進展,他都不理不睬(因此獨立於執行個體),類屬性的修改會影響到所有的執行個體。類屬性是靜態成員。
7、綁定和方法調用
(1)綁定
方法僅僅是類內部定義的函數,意味著方法是類屬性而不是執行個體屬性。
方法只有在類擁有執行個體時,才能被調用。方法被認為是綁定到執行個體。方法中的變數self表示調用此方法的執行個體對象。
(2)方法調用
①調用非綁定的方法(不常見):類還未執行個體化。
class EmplAddrBookEntry(AddrBookEntry): 'Employee Address Book Entry class' def __init__(self,nm,ph,em): AddrBookEntry.__init__(self,nm,ph) #覆蓋父類方法 self.empid=em
②調用Binder 方法:類已經執行個體化。
>>>mc=MyClass()>>>mc.foo()
總結:方法定義於類內部,是類方法;方法綁定到執行個體,由執行個體調用;未綁定,由類調用。
8、靜態方法和類方法(2.2)
(1)經典類中建立靜態方法和類方法的例子
class TestStaticMethod: def foo(): print 'calling static method foo()' foo=staticmethod(foo) #內建函數,將方法轉換成靜態方法class TestClassMethod: def foo(cls): #cls為類對象,類似於self print 'calling class method foo()' foo=classmethod(foo) #內建函數,將方法轉換成類方法
可以通過類或者執行個體調用這些函數。
>>>tsm=TestStaticMethod()>>>TestStaticMethod.foo()>>>tsm.foo()>>>tcm=TestClassMethod()>>>TestClassMethod.foo()>>>tcm.foo()
(2)使用函數修飾符建立靜態方法和類方法的例子(2.4)
class TestStaticMethod: @staticmethod def foo(): print 'calling static method foo()'class TestClassMethod: @classmethod def foo(cls): print 'calling class method foo()'
9、繼承
(1)通過繼承覆蓋方法
子類定義與基類相同的方法時,會覆蓋(override)基類方法。
子類可以使用調用非綁定的基類方法的方法調用基類方法。
也可以使用super()內建方法調用基類方法。
當從一個帶構造器__init__()的類派生,如果你不去覆蓋__init__(),它將會被繼承並自動調用,但如果你在子類中覆蓋了__init__(),子類被執行個體化時,基類的__init__()就不會被自動調用。若要調用父類的__init__()方法,需要使用super()。
(2)從標準類型派生
經典類中,不能對標準類型進行子類化。
2.2後,可以對標準類型進行子類化。
子類化Python類型:其中一個是可變類型;另一個是不可變類型。
①子類化不可變類型
class RoundFloat(float): def __new__(cls,val): return float.__new__(cls,round(val,2))
所有的__new__()方法都是類方法,所以顯式地傳入類作為第一個參數。
class RoundFloat(float): def __new__(cls,val): return super(RoundFloat,cls).__new__(cls,round(val,2))
通常使用super()內建函數去捕獲對應的父類以調用它的__new__()方法。
②子類化可變類型
class SortedKeyDict(dict): def keys(self): return sorted(super(SortedKeyDict,self).keys())
(3)多重繼承中方法解釋順序(MRO)
2.2之前,演算法簡單:深度優先,從左至右進行搜尋,取得在子類中使用的屬性。多重繼承取找到的第一個名字。
2.2提出新的MRO,演算法思想是根據每個祖先類的繼承結構編譯出一張列表,包括搜尋到的類,按策略重複資料刪除的。
2.3使用新的C3演算法替換,採用廣度優先。
新式類有__mro__屬性,告訴你尋找順序。
新式類使用經典類的MRO會失敗。
菱形效應
使用經典類的MRO,當執行個體化D時,不再得到C.__init__()之結果,而得到object.__init__()之結果。使用新式類,需要出現基類,這樣在繼承結構中,就形成了一個菱形。
補充:文檔字串不會從基類中繼承過來。因為文檔字串對類,函數/方法,還有模組來說都是唯一的。
10、類、執行個體、其他對象的內建函數
(1)issubclass()
布爾函數,判斷一個類是另一個類的子類或子孫類(一個類可視為其自身的子類)。
issubclass(sub,sup)
從2.3開始,第二個參數可以是可能的父類組成的元組。只要sub是其中任何一個的子類都返回True。
(2)isinstance()
布爾函數,判定一個對象是否是另一個給定類的執行個體。
isinstance(obj1,obj2)
obj1是obj2的一個執行個體,或是obj2的子類的一個執行個體時,返回True。
從2.2開始,obj2可以是一個元組,obj1是obj2元組中任何一個候選類型或類的執行個體時,就返回True。
(3)hasattr(),getattr(),setattr(),delattr()
*attr()系列函數可工作於各種對象,不限於類和執行個體。
*attr(obj,’attr’….)相當於操作obj.attr。
hasattr()布爾函數,決定一個對象是否有一個特定的屬性。
getattr(),setattr()相應地取得和賦值給對象的屬性。getattr()會在你試圖讀取一個不存在的屬性時,引發AttributeError異常。
delattr()刪除屬性。
(4)dir()
可用於執行個體或者類或者模組。 用於執行個體,顯示執行個體變數,還有在執行個體所在的類及所有它的基類中定義的方法和類屬性。 用於類,顯示類及它所有基類的__dict__中的內容,但不會顯示定義在元類中的類屬性。 用於模組,顯示模組的__dict__的內容。 dir()不帶參數時,顯示調用者的局部變數。
(5)super()(2.2)
協助程式員找出相應的父類,然後調用相關屬性。
super(type[,obj])返回type的父類,傳入obj參數進行父類綁定。 obj是一個執行個體,isinstance(obj,type)必須返回True; obj是一個類或類型,issubclass(obj,type)必須返回True。
super(MyClass,self).__init__()
(6)vars()
與dir()相似,只是給定的對象參數都必須有一個__dict__屬性。如果提供的對象沒有一個這樣的屬性,則會引發一個TypeError異常。
vars()返回一個字典,包含儲存於對象__dict__中的屬性(鍵)和值。如果沒有為vars()提供參數,將顯示一個包含本地名稱空間的屬性(鍵)及其值的字典,也就是locals()。
11、用特殊方法定製類
Python特殊方法可以用來擴充類的功能,可以實現: 類比標準類型; 重載操作符。
(1)Python中用來定製類的特殊方法
①基本定製型 C.__init__(self[,arg1,…]) 構造器(帶一些可選的參數) C.__new__(self[,arg1,…])構造器(帶一些可選的參數);通常用在設定不變資料類型的子類 C.__del__(self) 解析器 C.__str__(self) 可列印的字元輸出;內建str()及print語句 C.__repr__(self) 運行時的字串輸出;內建repr()和“操作符 C.__unicode__(self) Unicode字串輸出:內建unicode() C.__call__(self,*args) 表示可調用的執行個體 C.__nonzero__(self) 為object定義False值;內建bool() C.__len__(self) “長度”(可用於類);內建len()
②對象(值)比較 C.__cmp__(self,obj) 對象比較:內建cmp() C.__lt__(self,obj) and C.__le__(self,obj) 小於/小於或等於:對應<及<=操作符 C.__gt__(self,obj) and C.__ge__(self,obj) 大於/大於或等於:對應>及>=操作符 C.__eq__(self,obj) and C.__ne__(self,obj) 等於/不等於:對應==,!=及<>操作符
③屬性 C.__getattr__(self,attr) 擷取屬性:內建getattr(),僅當屬性沒有找到時調用 C.__setattr__(self,attr,val) 設定屬性 C.__delattr__(self,attr) 刪除屬性 C.__getattribute__(self,attr) 擷取屬性:內建getattr(),總是被調用 C.__get__(self,attr) (描述符)擷取屬性 C.__set__(self,attr,val) (描述符)設定屬性 C.__delete__(self,attr) (描述符)刪除屬性
④數實值型別:二元操作符 C.__*add__(self,obj) 加:+操作符 C.__*sub__(self,obj) 減:-操作符 C.__*mul__(self,obj) 乘:*操作符 C.__*div__(self,obj) 除:/操作符 C.__*truediv__(self,obj) True除:/操作符 C.__*floordiv__(self,obj) Flooor除://操作符 C.__*mod__(self,obj) 模數/取餘:%操作符 C.__*divmod__(self,obj) 除和模數:內建divmod() C.__*pow__(self,obj[,mod]) 乘冪:內建pow(),**操作符
⑤數實值型別:二進位操作符 C.__*lshift__(self,obj) 左移位:<<操作符 C.__*rshift__(self,obj) 右移位:>>操作符 C.__*and__(self,obj) 按位與:&操作符 C.__*or__(self,obj) 按位或:|操作符 C.__*xor__(self,obj) 按位與或:^操作符
⑥數實值型別:一元操作符 C.__neg__(self) 一元負 C.__pos__(self) 一元正 C.__abs__(self) 絕對值,內建abs() C.__invert__(self) 按位求反,~操作符
⑦數實值型別:數值轉換 C.__complex__(self,com) 轉為complex(複數),內建complex() C.__int__(self) 轉為int,內建int() C.__long__(self) 轉為long,內建long() C.__float__(self) 轉為float,內建float()
⑧數實值型別:基本標記法(String) C.__oct__(self) 八進位表示,內建oct() C.__hex__(self) 十六進位表示,內建hex()
⑨數實值型別:數值壓縮 C.__coerce__(self,num) 壓縮成同樣的數實值型別,內建coerce() C.__index__(self) 在有必要時,壓縮可選的數實值型別為整型(比如用於切片索引等)
⑩序列類型 C.__len__(self) 序列中項的數目 C.__getitem__(self,ind) 得到單個序列 C.__setitem__(self,ind,val) 設定單個序列元素 C.__delitem__(self,ind) 刪除單個序列元素 C.__getslice__(self,ind1,ind2) 得到序列片段 C.__setslice__(self,ind1,ind2,val) 設定序列片段 C.__delslice__(self,ind1,ind2) 刪除序列片段 C.__contains__(self,val) 測試序列成員:內建in關鍵字 C.__*add__(self,obj) 串聯:+操作符 C.__*mul__(self,obj) 重複:*操作符 C.__iter__(self) 建立迭代器:內建iter()
⑪映射類型 C.__len__(self) mapping中項的數目 C.__hash__(self) 散列(hash)函數值 C.__getitem__(self,key) 得到給定鍵(key)的值 C.__setitem__(self,key,val) 設定給定鍵(key)的值 C.__delitem__(self,key) 刪除給定鍵(key)的值 C.__missing__(self,key) 給定鍵如果不存在字典中,則提供一個預設值
(2)簡單定製
自己實現init(),str(),repr()等。
print使用str()方法,真正的字串對象表示使用repr()方法。
#! /usr/bin/env pythonclass RoundFloatManual(object): def __init__(self,val): assert isinstance(val,float),\ "Value must be a float!" self.value=round(val,2) def __str__(self): return '%.2f' % self.value __repr__=__str__
(3)數值定製
重載__add__()方法,就重載了(+)操作符。
還可以使用__radd__()方法和__iadd__()方法。
def __add__(self,other): return self.__class__(self.hr+other.hr,self.min+other.min)
覆蓋“原位”操作,實現增量賦值(2.0),比如iadd()支援mon+=tue。
(4)定製迭代器
實作類別中的__iter__()和next()方法來建立一個迭代器。
#! /usr/bin/env pythonclass AnyIter(object): def __init__(self,data,safe=False): self.safe=safe self.iter=iter(data) def __iter__(self): return self def next(self,howmany=1): retval=[] for eachItem in range(howmany): try: retval.append(self.iter.next()) catch StopIteration: if self.safe: break else: raise return retval
12、私人化
類中屬性預設情況下是“公開的”,類所在模組以及匯入類所在模組中的代碼都可以訪問到。
(1)雙底線
Python使用雙底線(__)來“混淆”屬性,不允許直接存取。
混淆後的屬性,會在名字前面加上底線和類名,比如NumStr類中的__num屬性,被混淆後,用於訪問這個資料值的標識符就變成了self._NumStr__num。混淆操作可以防止在父類或子類中的同名衝突。
(2)單底線
使用單底線(_)實現簡單的模組層級私人化。
13、授權
(1)封裝
封裝任何類型作為一個類的核心成員,使新對象的行為模仿你想要的資料類型中已經存在的行為,且去掉不希望存在的行為。擴充Python是封裝的另一種形式。
(2)實現授權
授權是封裝的一個特性。
授權的過程即是所有更新的功能都是由新類的某部分來處理,但已存在的功能就授權給對象的預設屬性。實現授權的關鍵點是覆蓋__getattr__()方法,在代碼中包含一個對getattr()內建函數的調用。
class WrapMe(object): def __init__(self,obj): self.__data=obj def get(self): return self.__data def __repr__(self): return 'self.__data' def __str__(self): return str(self.__data) def __getattr__(self,attr): return getattr(self.__data,attr)>>>wrappedComplex=WrapMe(3.5+4j)>>>wrappedComplex.real
訪問real屬性時,Python解譯器將試著在局部名稱空間中尋找那個名字;若沒有找到,會搜尋類名稱空間,以一個類屬性訪問;若還沒有找到,搜素則對原對象開始授權請求,此時調用__getattr__()方法,__getattr__()方法中調用getattr()方法得到一個對象的預設行為。
總結:通過覆蓋__getattr__()方法實現授權。
授權只能訪問屬性,特殊行為不可以。例如對列表的切片操作,它內建於類型中,不是屬性,不能授權訪問。
屬性可以是資料屬性,還可以是函數或者方法。Python所有數實值型別,只有複數擁有屬性:資料屬性和conjugate()內建方法。
>>>wrappedList=WrapMe([123,'foo',45.67])>>>wrrapedList[3] #會拋出AttributeError
此時可以採用“作弊”的方法來訪問實際對象和它的切片能力。
>>>realList=wrappedList.get() #get()方法取得對原對象的訪問>>>realList[3]
14、新式類的進階特性(2.2+)
(1)新式類的通用特性
類型和類的統一,使得可以子類化Python資料類型。同時,所有的Python內建的“casting”或轉換函式現在都是工廠函數。例如:int(),long(),float(),complex;str(),unicode();list(),tuple();type()。
另外,還加入了一些新的函數:basestring();dict();bool();set(),frozenset();object();classmethod();staticmethod();super();property();file()。這些類名和工廠函數,不僅能建立這些類名的新對象,還可以用來作為基類,去子類化類型。現在還可以用於isinstance()內建函數,isinstance()函數在obj是一個給定類型的執行個體或其子類的執行個體時返回True。
OLD(not as good):if type(obj)==type(0)...if type(obj)==types.IntType...BETTER:if type(obj) is type(0)...EVEN BETTER:if isinstance(obj,int)...if isinstance(obj,(int,long))...if type(obj) is int...
(2)__slots__類屬性
__dict__屬性跟蹤所有執行個體屬性。
執行個體inst,屬性foo,那麼inst.foo與inst.__dict__[‘foo’]等價。
字典會佔用大量記憶體,為記憶體上的考慮,可用__slots__屬性替代__dict__。
__slots__是一個類變數,由一序列型對象組成。由所有合法標識構成的執行個體屬性的集合來表示。任何試圖建立一個其名不在__slots__中的名字的執行個體屬性都將導致AttributeError異常。帶__slots__屬性的類定義不會存在__dict__屬性了。使用__slots__屬性的目的是節約記憶體。使用__slots__屬性可以防止使用者隨心所欲的動態增加執行個體屬性。
class SlottedClass(object): __slots__=('foo','bar')>>>c=SlottedClass()>>>c.foo=42>>>c.xxx='nihao' #引發AttributeError異常
(3)__getattribute__()特殊方法
Python類有一個__getattr__()的特殊方法,僅當屬性不能在執行個體或類或祖先類的__dict__屬性中找到時,才被調用。__getattribute__()與__getattr__()類似,不同在於,當屬性被訪問時,它就一直可以被調用,而不局限於不能找到的情況。在同時定義了__getattribute__()及__getattr__()方法的類中,除非明確從__getattribute__()方法調用,或者__getattribute__()方法引發了AttributeError異常,否則後者不會被調用。如果將要在__getattribute__()方法中訪問這個類或其祖先類的屬性,應該總是調用祖先類的同名方法,避免引起無窮遞迴。
(4)描述符(描述符就是可重用的屬性)
可認為描述符是表示對象屬性的一個代理,它為屬性提供了強大的API。當需要屬性時,可以通過描述符來訪問它(當然還可以使用常規的句點屬性標誌法來訪問屬性)。
__get__(),__set__(),__delete__()特殊方法分別用於得到一個屬性的值,對一個屬性進行賦值,刪除掉某個屬性。同時覆蓋__get__()和__set__()的類被稱作資料描述符。實現了__set__()方法的類被稱作非資料描述符,或方法描述符。
__get__(),__set__(),__delete__()的原型如下: __get__(self,obj,typ=None)=>None __set__(self,obj,val)=>None __delete__(self,obj)=>None
整個描述符系統的心臟是__getattribute__()特殊方法,因為對每個屬性的訪問都會調用這個特殊的方法。
舉例來說,給定類X和執行個體x:
訪問執行個體屬性,x.foo由__getattribute__()轉化成:
type(x).__dict__['foo'].__get__(x,type(x))
訪問類屬性,那麼None將作為對象被傳入:
X.__dict__['foo'].__get__(None,X)
訪問父類屬性,super(Y,obj).foo(假設Y為X的子類):
X.__dict__['foo'].__get__(obj,X)
靜態方法、類方法、屬性,甚至所有的函數都是描述符。Python中函數之間的唯一區別在於調用方式的不同,分為綁定和非綁定狼類,函數描述符可以處理這些問題,描述符會根據函數的類型確定如何“封裝”這個函數和函數被綁定的對象,然後返回調用對象。使用描述符的順序很重要,有一些描述符的層級要高於其他的。描述符是一個類屬性,因此所有的類屬性皆具有最高的優先順序。優先順序排序:類屬性>資料描述符>執行個體屬性>非資料描述符>預設為__getattr__()。
#! /usr/bin/env pythonimport osimport pickleclass FileDescr(object): saved=[] def __init__(self,name=None): self.name=name def __get__(self,obj,typ=None): if self.name not in FileDescr.saved: raise AtrributeError,"%r used before assignment" % self.name try: f=open(self.name,'r') val=pickle.load(f) f.close() return val except(pickle.UnpicklingError,IOError,EOFError,AttributeError,ImportError,IndexError),e: raise AttributeError, "could not read %r" % self.name def __set__(self,obj,val): f=open(self.name,'w') try: pickle.dump(val,f) FileDescr.saved.append(self.name) except(TypeError,pickle.PickingError),e: raise AttributeError, "could not pickle %r" % self.name finally: f.close() def __delete__(self,obj): try: os.unlink(self.name) FileDescr.saved.remove(self.name) except