類的成員可以分為三大類：字段、方法、屬性。

　　　　　　 ? ??

　　@：所有成員中，只有普通字段的內容保存在對象中，即：根據此類創建了多少對象，在內存中就有多少普通字段。而其他的成員都是保存在類中的，即：無論對象的多少，在內存中只創建一份。

?

一、字段：（普通字段和靜態字段）

　　1、普通字段：屬于對象

　　2、靜態字段：屬于類

class Yitian:#靜態字段user = "張無忌"def __init__(self,name):#普通字段self.name = name#直接訪問普通字段 obj = Yitian("明教") print(obj.name)#直接訪問靜態字段 print(Yitian.user)

@普通字段需要通過對象來訪問，靜態方法通過類訪問。(兩者的歸屬不同)

由圖可知：　

　　靜態字段在內存中只保存一份

　　普通字段在每個對象中都要保存一份

class Yitian:#靜態字段user = "張無忌"def __init__(self,name):#普通字段self.name = name#直接訪問普通字段 obj1 = Yitian("明教") obj2 = Yitian("峨眉") print(obj1.name) print(obj2.name) #增加了一個對象”峨眉“#直接訪問靜態字段 Yitian.user = "周芷若" #改變了靜態字段 結果：周芷若 print(Yitian.user) #最終結果：周芷若

?

應用的場景：通過類創建對象時，如果每個對象都具有相同字段，那么就用靜態字段。

?

二、方法：（普通方法、靜態方法、類方法-->在內存中都歸屬于類，調用方式不同）

　　1、普通方法：

　　　　由對象調用，至少一個self參數，執行普通方法時，自動將調用該方法的對象賦值給self。

　　2、類方法：

　　　　由類方法調用，至少一個cls參數，執行方法時，自動將調用該方法的類復制給cls.

　　3、靜態方法：?

?　　　　由類調用，無默認值參數。

class Foo:def __init__(self,name):self.naem = namedef ord_func(self):'''定義一個普通方法，至少有一個self參數'''print(self.naem)print("普通方法")@classmethoddef class_func(cls):'''定義一個類方法，至少一個cls參數'''print("類方法")@staticmethoddef static_func():'''定義一個靜態方法，無默認值參數'''print("靜態方法") #調用普通方法 f = Foo() f.ord_func()#調用類方法 Foo.class_func()#調用靜態方法 Foo.static_func()

@區別：

　　相同點：對于所有的方法而言，均屬于類（非對象）中，所以在內存中也只保存一份。

　　不同點：方法調用者不同、調用方法時自動傳入的參數不同。

?

三、屬性：

　　1、屬性的基本使用：　　

#==========定義================= class Doo:def func(self):pass#定義屬性@propertydef prop(self):pass #=========調用=============== doo_obj = Doo() doo_obj.func() doo_obj.prop #調用屬性

@定義屬性的注意事項：

　　定義時，在普通方法的基礎上添加@property裝飾器

　　定義時，屬性僅有一個self參數

　　調用時，無需括號

　　　　方法：obj.func()

　　　　屬性：obj.prop ? #沒有括號

　　　　　　屬性存在的意義是：訪問屬性時可以制造出和訪問字段完全相同的假象

　　　　　　屬性由方法變種而來，如果python中沒有屬性，方法完全可以代替其功能。

#例： 分頁顯示請求的頁面的數據 class Pager:def __init__(self,current_page):#用戶當前請求的頁碼self.current_page = current_page#每頁默認顯示10條數據self.per_intems = 10@propertydef start(self):val = (self.current_page - 1) * self.per_intemsreturn val@propertydef end(self):val = self.current_page * self.per_intemsreturn val #調用 p = Pager(10) print(p.start) print(p.end)

@python屬性的功能是：屬性內部進行一系列的邏輯計算，最終將計算結果返回

?

　　2、屬性的兩種定義方式

?　　　　(1)、裝飾器：在方法上應用裝飾器　　　　

　　裝飾器方式：在類的普通方法上應用@property裝飾器

　　　　經典類：具有一種@property裝飾器

#==========定義========= class Goods:@propertydef price(self):return "張無忌" # ======調用========== obj = Goods() result = obj.price #自動執行@property修飾方法，并獲取方法的返回值。 print(result)

　　　　新式類：具有三種@property裝飾器

#======定義======= class Goods:@propertydef price(self):print("張無忌")@price.setterdef price(self,value):print("周芷若")# print(value) @price.deleterdef price(self):print("趙敏") # =====調用============ obj = Goods() obj.price #自動執行@property修飾的price方法，并獲取方法的返回值 obj.price = 123 #自動執行@property.setter修飾的price方式，并將123賦值給方法的參數 del obj.price #自動執行@price.deleter修飾的price方法

@? 經典類中的屬性只有一種訪問方式，其對應被@property修飾的方法

　? 新式類中的屬性有三種訪問方式，并分別對應了三個被@property、@方法名.setter、@方法名.deleter修飾的方法。（由于新式類中具有三種訪問方式，根據他們幾個屬性訪問特點，分別將三個方法定義為對同一個屬性：獲取、修改、刪除）

class Goods:def __init__(self):#原價self.original_price = 10#折扣self.discount = 0.8@propertydef price(self):#實際價格 = 原價 * 折扣new_price = self.original_price * self.discountreturn new_price@price.setterdef price(self,value):self.original_price = value@price.deleterdef price(self):del self.original_priceobj = Goods() print(obj.price) #獲取商品價格 update = obj.price = 200 #修改商品原價 print(update) del obj.price #刪除商品原價

?

　　　　(2)、靜態字段：在類中定義值為property對象的靜態字段

?　　　　　　當使用靜態字段的方式創建屬性時，經典類和新式類無區別

class Foo:def get_bar(self):return "張無忌"BAR = property(get_bar)obj = Foo() reuslt = obj.BAR #自動調用get_bar方法，并獲取方法的返回值 print(reuslt)# 結果：張無忌

property的構造方法中有四個參數

　　第一個參數是方法名，調用對象.屬性 時自動觸發執行方法

?　　第二個參數是方法名，調用對象.屬性 =xxx 時自動觸發執行方法

　　第三個參數是方法名，調用del 對象.屬性 時自動觸發執行方法

　　第四個參數是字符串，調用對象.屬性.__doc__,此參數是該屬性的描述信息

class Foo:def get_bar(self):return "張無忌"#必須兩個參數def set_bar(self,value):return "set value" + valuedef del_bar(self):return "周芷若"BAR = property(get_bar,set_bar,del_bar,"description...")obj = Foo() obj.BAR #自動調用第一個參數中定義的方法：get_bar obj.BAR = "趙敏" #自動調用第二個參數中定義的方法：set_bar,并將“趙敏”當作參數傳入 del Foo.BAR #自動調用第三個參數中定義的方法：del_bar方法 obj.BAR.__doc__ #自動獲取第四個參數中設置的值description...

　　由于靜態字段方式創建屬性具有三種訪問方式，我們可以根據他們幾個屬性的訪問特點分別將三個方法定義位獲取、修改、刪除　　

class Googs(object):def __init__(self):self.original_price = 100 #原價self.discount = 0.8 #折扣self.WW = 22def get_price(self):#實際價格 = 原價 * 折扣new_price = self.original_price * self.discountreturn new_pricedef set_price(self,value):self.original_price = valuedef del_price(self):del self.WWPRICE = property(get_price, set_price, del_price, "價格屬性描述。。。") obj = Googs() print(obj.PRICE) #獲取商品價格 obj.PRICE = 200 #修改商品原價 del obj.PRICE #刪除商品原價

　　所以在定義屬性共有兩種方式，分別是【裝飾器】和【靜態字段】，而【裝飾器】方式針對經典類和新式類又有所不同。

?

四、類成員修飾符

　　對于每一個類的成員而言都有兩種形式：

　　　　共有成員，在任何地方都能訪問

　　　　私有成員，只有在類的內部才能訪問

　　1、私有成員的和共有成員的定義不同

　　　　私有成員命名時，前兩個字符時下劃線。（特殊成員除外，例如：__init__、__call__、__dict__等）

class Foo:def __init__(self):self.name = "張無忌" #公有字段self.__age = 20 #私有字段

　　2、私有成員和共有成員的訪問限制不同：

　　　　（1）、靜態字段

　　　　　　公有靜態字段：類可以訪問；類內部可以訪問，派生類中可以訪問

class Foo:name = "張無忌" #公有靜態字段def func(self): print(Foo.name) class Doo(Foo):def show(self):print(Foo.name)Foo.name #類訪問 obj = Doo() obj.func() #內部類可以訪問 obj_son = Doo() obj_son.show() #派生類中可以訪問

　　　　　　私有靜態字段：僅類內部可以訪問

class Foo:__name = "張無忌" #私有靜態字段def func(self):print(Foo.__name) class Doo(Foo):def show(self):print(Foo.__name)Foo.name #類訪問 ---錯誤 obj = Doo() obj.func() #內部類可以訪問 ---正確 obj_son = Doo() obj_son.show() #派生類中可以訪問 ---錯誤

?　　　　（2）、普通字段

　　　　　　共有普通字段：對象可以訪問，內部類可以訪問、派生類可以訪問

class Foo:def __init__(self):self.foo = "周芷若" #公有字段def func(self):print(self.foo) #類內部訪問class Doo(Foo):def show(self):print(self.foo) #派生類中訪問 obj = Foo()obj.foo #通過對象訪問 obj.func() #類內部訪問 obj_son = Doo() obj_son.show() #派生類中訪問

　　　　　　私有普通字段：僅類內部可以訪問

　　@如果想要強制訪問私有字段，可以通過[對象._類名__私有字段名]訪問，(例如：obj._Foo__foo),不建議強制訪問私有成員。

class Foo:def __init__(self):self.__foo = "周芷若" #私有字段def func(self):print(self.__foo) #類內部訪問class Doo(Foo):def show(self):print(self.__foo) #派生類中訪問 ---錯誤 obj = Foo()obj.foo #通過對象訪問 ---錯誤 obj.func() #類內部訪問 ---正確 obj_son = Doo() obj_son.show() #派生類中訪問 ---錯誤

@方法、屬性的訪問于上述方式相似，即：私有成員只能子啊類內部是用

@非要訪問私有屬性的話，可以通過 對象._類__屬性名

?

五、類的特殊成員

　　1、__doc__

　　2、__module__和__class__

　　3、__init__

　　4、__del__

　　5、__call__

　　6、__dict__

　　7、__str__

　　8、__getitem__、__setitem__、__delitem__

　　9、__getslice__、__setslice__、__delslice__

　　10、__iter__

　　11、__new__和__metaclass__

?

　　

?

轉載于:https://www.cnblogs.com/LW-5208/articles/9545961.html

總結

以上是生活随笔為你收集整理的进阶面向对象——类的成员的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。