面向對象的進階（item系列，__new__,__hash__,__eq__）

 

 

 

面向對象的進階（item系列，__new__,__hash__,__eq__）

 

1、item系列

 

getitem、setitem、delitem（操做過程達到的結果其實就是增刪改查）

 

class Foo:
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

    def __getitem__(self, item):  # 與f['xx']形式對應
        if hasattr(self, item):
            return self.__dict__[item]

    def __setitem__(self, key, value):  # 與f['xx']='ss'形式對應
        self.__dict__[key] = value

    def __delitem__(self, key):  # 與del f['xx']形式對應
        del self.__dict__[key]

f = Foo('egon',30,'男')
print(f['name'])
#  f['name']---對象['xx']這種形式就會觸發前面的__getitem__方法，將name就傳給了item
#  支持以這樣的方式取得了對象的屬性name，正常的是f.name取到屬性

f['hobby'] = '男'
# 新增長的key和value，觸發__setitem__方法，將對應的屬性和值放入本來的字典中
print(f['hobby'], f.hobby)
# 以f['hobby']這樣的方式取到新增的屬性,本來正常取值f.hobby

# del f.hobby  # 正常的刪除方式
# print(f.hobby)  # 此時會報錯，顯示：AttributeError: 'Foo' object has no attribute 'hobby'

del f['hobby']
# 若是執行到這步，就會顯示:AttributeError: __delitem__,顯示沒有這個方法
# 這個刪除方式就觸發__delitem__方法，前面類裏面就必須得有定義該方法
print(f.__dict__)  # 字典裏面就沒有hobby的屬性了

運行結果：

C:\Users\3-2\PycharmProjects\untitled\venv\Scripts\python.exe C:/Users/3-2/PycharmProjects/untitled/面向對象進階.py
egon
男 男
{'sex': '男', 'age': 30, 'name': 'egon'}

Process finished with exit code 0

 

這種用中括號就能夠直接調的方式，好比用字典，列表的實現過程，就是內部存在了item系列這個機制的緣由

這種用中括號就能夠直接調的方式，好比用字典，列表的實現過程，就是內部存在了item系列這個機制的緣由
object原生支持__delattr__因此才能夠直接del f.hobby而不報錯，可是del f['hobby']得經過本身實現，
因此當類方法裏面沒有__delitem__的時候就會報錯

 

2、__new__

__init__:初始化方法
__new__:構造方法，建立一個對象。self就是__new__構造出來的，即__new__方法是self產生的機制
平時是不須要用到執行__new__方法的，如下例子只是簡單說明它是怎麼用的：

class A:
    def __init__(self):
        self.x = 1
        print('in init function')
    def __new__(cls, *args, **kwargs):
        # 傳入一個默認參數cls，執行__new__方法前尚未self,因此只能傳一個類進來
        print('in new function')
        return object.__new__(A,*args,**kwargs)
        # object.__new__創造了一個新的對象，而後將這個對象傳給self的位置，因此當執行self的時候就可使用對象了

a = A()  # 實例化，會先執行__new__方法，再執行 __init__方法

運行結果：

in new function
in init function

Process finished with exit code 0

一個典型的設計模式（23種）：單例模式
單例模式:一個類始終只有一個實例；當第一次實例化這個類的時候就建立一個實例化的對象；當以後再來實例化的時候， 就會用以前建立的對象

 

# 實現單例模式的例子：


class A:
    __instance = False  # 私有的靜態變量 不但願別人可使用，必須得通過本身的設置
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __new__(cls, *args, **kwargs):
        if cls.__instance:  # 若是爲真就執行下面代碼,不然執行後面的代碼
            # 第二次進來的時候就符合這個了
            return cls.__instance  # 第二次進來就直接將以前建立的對象返回給self了
        cls.__instance = object.__new__(A)
        # 由於第一次進來的時候就是__instance = False，因此執行這行代碼代碼
        # 用object.__new__建立一個類A的新的對象，而且賦值給 cls.__instance
        return cls.__instance  # 這裏就是將新建的對象return回去

egon = A('egg',38)
# 真正能實例化對象而且佔用內存的是object裏面的self,可是這裏使用的對象始終是object.__new__建立的，
# 由於本身就有對象了，就不會去使用object裏面的了
# 反正可以實現單例化的緣由是__new__方法的使用
egon.cloth = '小花襖'
nezha = A('nazha',25)
nezha.shoes = '小白鞋'
print(nezha)
print(egon)
# 執行到這裏根據運行結果顯示內存地址是同一個，也就是說第二次實例化的時候是在對第一個實例化後的
# 對象進行操做的，而並無再次建立另外一個佔內存的對象，若是第二次實例化傳的參數和原對象一致，
# 參數值就會進行覆蓋，若是第二次實例化傳的參數只是原屬性的一部分，則相同的覆蓋，原來的繼續會
# 在表如今現有對象中
print(nezha.name)
print(egon.name)
# 執行到這裏原來egon的名字已經被nezha覆蓋了
print(nezha.cloth)
# 執行到這裏原來egon的cloth會繼續穿在nezha上

運行結果：

<__main__.A object at 0x0000025C0C2293C8>
<__main__.A object at 0x0000025C0C2293C8>
nazha
nazha
小花襖

 

 

3、__hash__

# 在沒有定義__hash__方法的時候，hash都是針對內存地址的，而不是針對對象屬性，內存地址不同，hash的結果也不同 

class A: 
　　def __init__(self,name,sex): 
　　　　self.name = name 
a = A('egn','男') 
b = A('egon','nv')
print(hash(a)) 
print(hash(b))

運行結果：

154259419512
154259419617

 

# 定義了—__hash__方法後，屬性不一樣hash值也會不一樣，屬性相同hash值也會相同：
class A:
    def __init__(self,name,sex):
        self.name = name
        self.sex = sex
    def __hash__(self):
        return hash(self.name+self.sex)

a = A('egon','男')
b = A('egon','男')
c = A('egon','nv')
print(hash(a))
print(hash(b))
print(hash(c))

運行結果：

8385798543724353936
8385798543724353936
-7270162062837990016

 

4、__eq__

 

沒有__eq__方法的時候，二者比較是比較內存地址：
class A:
    def __init__(self,name):
        self.name = name

obj1 = A('egg')
obj2 = A('egg')
print(obj1 == obj2)
# 沒有定義__eq__方法的時候，比較時候默認比較內存地址，上面兩個內存地址是不同的

運行結果：

False

 

# 定義__eq__方法時能夠本身設定執行內容,‘==’觸發的_eq_方法
class A:
    def __init__(self,name):
        self.name = name

    def __eq__(self, other):
        if self.name == other.name:
            return True
        else:
            return False

obj1 = A('egg')
obj2 = A('egg')
obj3 = A('EGG')
print(obj1 == obj2)  # 等號觸發的__eq__
print(obj2 == obj3)  # 等號觸發的__eq__

 

運行結果：

True
False

Process finished with exit code 0