Python學習筆記13:Python物件導向編程

來源:互聯網
上載者:User

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

聯繫我們

該頁面正文內容均來源於網絡整理,並不代表阿里雲官方的觀點,該頁面所提到的產品和服務也與阿里云無關,如果該頁面內容對您造成了困擾,歡迎寫郵件給我們,收到郵件我們將在5個工作日內處理。

如果您發現本社區中有涉嫌抄襲的內容,歡迎發送郵件至: info-contact@alibabacloud.com 進行舉報並提供相關證據,工作人員會在 5 個工作天內聯絡您,一經查實,本站將立刻刪除涉嫌侵權內容。

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.