類的組合

1.1

class Foo(object):

    def __init__(self,age):
        self.age = age      # 封存了 8 和 9 

    def display(self):
        print(self.age)      # 沒有參數傳入 所以是None

data_list = [Foo(8),Foo(9)]
for item in data_list:
    print(item.age,item.display())

‘‘‘輸出結果:
8
8 None
9
9 None
 
‘‘‘

1.2

類的特殊成員

1. __doc__

表示類的描述信息

class Foo:
    """描述一個類的信息,這是一個用於聽音樂的"""
    
    def func(self):
        pass



print(Foo.__doc__)

# 輸出結果: 描述一個類的信息,這是一個用於聽音樂的

2. __module__ 和 __class__

__module__ 表示當前操作的對象在哪個模塊

__class__ 表示當前操作的對象的類是什麽

# E:\re_1.py   建立了個py文件
 


class C:
    def __init__(self):
        self.name = ‘jay‘

# E:\xx.py

from re_1 import C # 引入自定義模塊

obj = C()
print(obj.__module__)
print(obj.__class__)


#輸出結果:
re_1   
<class ‘re_1.C‘>

3. __init__

對象中數據的初始化,通過類創建對象時,自動觸發執行

class Foo:

    
 
def __init__(self, name):
        self.name = name
        self.age = 18


obj = Foo(‘jay‘) # 自動執行類中的 __init__ 方法

4. __del__

析構方法,當對象在內存中被釋放時,自動觸發執行

註：此方法一般無須定義，因為Python是一門高級語言，程序員在使用時無需關心內存的分配和釋放，因為此工作都是交給Python解釋器來執行，所以，析構函數的調用是由解釋器在進行垃圾回收時自動觸發執行的。

class Foo:

    def __del__(self):
        pass

5. __call__

對象後面加上括號,觸發執行

註:初始化對象的執行是由創建對象觸發的,即:對象 = 類名();而對於__call__方法的執行是由對象後加括號觸發的,即:對象()或類()()

class Foo:

    def __init__(self):
        print(5)
        pass

    def __call__(self, *args, **kwargs):
        print(‘__call__‘)


obj = Foo()  # 執行 __init__
obj()  # 執行 __call__
"""
輸出結果:

5
__call__

"""

6. __dict__

類或對象中的所有成員

類的普通字段屬於對象;類中的靜態字段和方法等屬於類,即:

class Province:

    country = ‘China‘

    def __init__(self, name, count):
        self.name = name
        self.count = count

    def func(self, *args, **kwargs):
        print(‘func‘)

# 獲取類的成員，即：靜態字段、方法、
print(Province.__dict__)
# 輸出：{‘country‘: ‘China‘, ‘__module__‘: ‘__main__‘, ‘func‘: <function func at 0x10be30f50>, ‘__init__‘: <function __init__ at 0x10be30ed8>, ‘__doc__‘: None}

obj1 = Province(‘HeBei‘,10000)
print(obj1.__dict__)
# 獲取 對象obj1 的成員
# 輸出：{‘count‘: 10000, ‘name‘: ‘HeBei‘}

obj2 = Province(‘HeNan‘, 3888)
print(obj2.__dict__)
# 獲取 對象obj1 的成員
# 輸出：{‘count‘: 3888, ‘name‘: ‘HeNan‘}

7. __str__

如果一個類中定義了__str__方法,那麽在打印對象時,默認輸出該方法的返回值

class Foo:

    def __str__(self):
        return ‘666‘
        pass
obj = Foo()
print(obj)

# 輸出: ‘‘666‘‘

8. __getitem__,__setitem__,__delitem__

用於索引操作,如字典,以上分別為獲取,設置,刪除數據

class Foo(object):
    def __getitem__(self, item):
        print(‘__getitem__‘,item)

    def __setitem__(self, key, value):
        print(‘__setitem__‘,key,value)
        
    def __delitem__(self, key):
        print(‘__delitem__‘,key)

obj = Foo()
result = obj[‘k1‘]   # 自動觸發執行 __getitem__
obj[‘k2‘] = ‘jay‘    # 自動觸發執行 __setitem__
del obj[‘k1‘]        # 自動觸發執行 __delitem__


"""
輸出:

__getitem__ k1
__setitem__ k2 jay
__delitem__ k1



"""

9. __add__

對象 + 對象

class Foo(object):
    def __init__(self,a,a1):
        self.a = a
        self.a1 = a1
    def __add__(self, other):
        return self.a + other.a1
obj1 = Foo(88,99)
obj2 = Foo(12,10)
ret = obj1 + obj2  # 自動執行 __add__
print(ret)
# 結果: 98

10. with 對象

自動執行__enter__/__exit__

__enter __ 相當於入口,__exit__相當於出口

class Foo(object):
    def __enter__(self):
        print(‘1111‘)
        return 999
        
    def __exit__(self, exc_type, exc_val, exc_tb):
        print(‘22222‘)
obj = Foo()
with obj as f:
    print(f)

# 輸出結果:
 1111
 999
 22222

11. __new__

構造方法,__init__之前python內部會自動執行__new__,在內部創建一個當前類的對象

class Foo(object):
    def __init__(self, a1, a2):     # 初始化方法
        """
        為空對象進行數據初始化
        :param a1:
        :param a2:
        """
        self.a1 = a1
        self.a2 = a2

    def __new__(cls, *args, **kwargs): # 構造方法
        """
        創建一個空對象
        :param args:
        :param kwargs:
        :return:
        """
        return object.__new__(cls) # Python內部創建一個當前類的對象(初創時內部是空的.).

obj1 = Foo(1,2)
print(obj1)

obj2 = Foo(11,12)
print(obj2)

類的組合和其他特殊成員