類的成員

• 字段
  • 普通字段

    保存在對象當中,執行只能通過對象訪問

  • 靜態字段

    保存在類當中, 執行可以通過類訪問也可以通過對象訪問

• 方法
  • 普通方法

    保存在類當中,由對象來調用

  • 靜態方法

    靜態方法,保存在類當中,由類直接調用,也可通過對象調用

  • 類方法

    保存在類當中,由類直接調用,也可通過對象調用

• 屬性
  • 不用加括號也能執行的方法

class Foo:
    name = ‘nathaniel_靜態字段‘# 靜態字段
    def __init__(self):
        self.age = ‘19_普通字段‘# 普通字段

# 靜態字段,保存在類當中,執行可以通過類訪問也可以通過對象訪問
 

print(‘直接通過類訪問靜態字段‘,Foo.name)
obj = Foo()
print(‘通過對象訪問靜態字段‘,obj.name)
# 普通字段,保存在對象當中,執行只能通過對象訪問
print(‘普通字段只能通過對象訪問‘,obj.age)


class Foo1:
    def foo(self):
        print(‘普通方法‘)

    @staticmethod # 使用裝飾器
    def foo1():
        print(‘靜態方法‘)

    @classmethod
    def foo2(cls):
        # cls 類名
 

        print(‘類方法‘)

# 類方法,保存在類當中,由類直接調用,無需實例化類
Foo1.foo2()
# 靜態方法,保存在類當中,由類直接調用,無需實例化類
Foo1.foo1()
# 普通方法,保存在類當中,由對象來調用
obj = Foo1()
obj.foo()
# 類方法和靜態也可由對象調用
obj.foo1()
obj.foo2()

# 屬性

# 屬性
# 定義時，在普通方法的基礎上添加 @property 裝飾器；
# 定義時，屬性僅有一個self參數
# 調用時，無需括號
#     方法：obj.func()
#     屬性：obj.func

class Foo2:
    @property
    
 
def foo2(self):
        print(‘屬性‘)

    @foo2.setter
    def foo2(self,values):
        print(‘偽裝賦值‘,values,)

    @foo2.deleter
    def foo2(self):
        print(‘偽裝刪除‘)

# 屬性是方法,但是調用的時候不加括號
obj = Foo2()

obj.foo2 # 自動執行 @property 修飾的foo2方法並獲取返回值

obj.foo2 = ‘123‘ # 自動執行 @foo2.setter 修飾的foo2方法並將 ‘123‘ 賦值給 values

del obj.foo2 # 自動執行 @foo2.deleter 修飾的foo2方法

# 上述代碼的執行實際上有一個對應關系
# obj.foo2 對應 @property 下的函數
# obj.foo2 = ‘123‘ 對應 @foo2.setter 下的函數 # 需要一個參數
# del obj.foo2 對應 @foo2.deleter 下的函數

註意:

• 經典類只有一種@property裝飾器,即上述實例中與 obj.foo2 相對應的
• 新式類有有三種@property裝飾器,即上述實例中,三種都可用

類的成員修飾符

一般來說,每一個類中都可以有兩種成員

• 公有成員,在任何地方都可以訪問
  • 公有字段
  • 公有方法
• 私有成員,只有在類的內部才可以訪問 # 私有成員在命名時以雙下劃線開頭 (特殊成員除外, __init__、__call__、__del__ 等
• 私有字段
• 私有方法
• 類的私有成員不會被子類繼承

class Foo4:
    __static_foo = ‘123‘ # 靜態私有字段,只能在內部訪問

    def __init__(self,name,age):
        self.name = name # 公有字段
        self.__age = age # 私有字段,只能在內部訪問
        
    def __foo41(self):
        # 私有方法,只能在類的內部訪問
        print(‘私有方法,只能在類的內部訪問,私有方法也可以訪問私有字段%s‘% self.name)

    def show(self):
        # 類的內部可以訪問私有字段和私有方法
        print(self.__static_foo)
        print(self.__age)
        self.__foo41()

obj = Foo4(‘nathaniel‘,‘20‘)
print(obj.name) # 公有字段可以訪問
print(obj.__age) # 私有字段,報錯
obj.show() # 公有方法可以訪問
obj.__foo41() # 私有方法,報錯

類的特殊成員

1、__init__ 構造方法 類() 自動執行
2、__call__ 對象() 類()() 自動執行
3、__int__ int(對象) 自動執行對象中的 __int__ 方法,並將返回值賦給它
4、__str__ str(對象) 自動執行對象中的 __int__ 方法,並將返回值賦給它
5、__add__ 兩個對象相加時,自動執行第一個對象的__add__方法,並將第二個對象當做參數傳入
6、__dict__ 對象.__dict__ 將對象中的成員以列表返回 類.__dict__ 將類裏的成員以字典返回
7、__del__ 析構方法,對象被銷毀時執行
8、__getitem__ 切片(slice類型)或者索引
9、__setitem__ 按索引賦值
10、__delitem__ 按索引刪除

class Foo5:
    """
    __doc__方法 打印類的描述信息
    """
    def __init__(self):
        print(‘構造方法  類()  自動執行‘)

    def __call__(self, *args, **kwargs):
        print(‘對象() 類()()  自動執行‘)

    def __int__(self):
        return 123

    def __str__(self):
        return ‘123‘

    def __add__(self, other):
        print(str(1 + other))

    def __del__(self):
        print(‘析構方法,對象被銷毀時執行‘)

    def __getitem__(self):
        print(‘對象進行切片操作,自動執行對象裏的__getitem__方法‘)
    def __setitem__(self, key, value):
        print(‘對象按索引賦值,自動執行對象裏的__setitem__方法‘)
    def __delitem__(self, key):
        print(‘對象按索引刪除,自動執行對象裏的__delitem__方法‘)
print(Foo5.__dic__)

class Foo5:
    pass
class F0051(Foo5):
    pass
obj = Foo5()

print(isinstance(obj, Foo5)) # 檢查對象 obj 是否是類 cls 的對象
print(issubclass(F0051, Foo5)) # 檢查 F0051 類是否是 Foo5 類的派生類

python 面向對象(進階篇)