詳解Python常用的魔法方法

一、python魔法方法

Python的魔法方法會在特定的情況下自動調用,且他們的方法名通常被雙下劃線包裹,之前我們學習的構造函數和析構函數就屬於魔法方法

二、運算符重載

Python中同樣有運算符重載,其實所有的運算符都是使用瞭對應的魔法方法來處理的對象的,魔法方法對應的操作符如下

在這裡插入圖片描述

我們來舉一個簡單的例子

class A:
    def __init__(self,x):
        self.x = x
    def __add__(self,other):
        return int(self.x)+int(other.x)
a = A(3.3)
b = A(5.2)
print(a+b)

類似的還有反運算重載和增量復制運算,用處較少,不再解釋

在這裡插入圖片描述
在這裡插入圖片描述

三、打印操作的魔法方法

__str__(self):返回值是str類型的,當我們需要以字符串的形式輸出對象時(調用print時),就會自動調用該方法,舉個例子

class A:
    def __str__(self):
        return '我真帥'

a = A()
print(a)# 我真帥

__repr__(self):返回值是str類型的,當我們直接在shell中輸入對象名並按下回車,就會自動調用該方法,他也有和__str__一樣的功能,但如果兩者你都重寫瞭,在使用print時,__str__的優先級高,__repr__是給機器看的,__str__是給人看的,舉個例子

>>> class A:
    def __str__(self):
        return '我真帥'
    def __repr__(self):
        return '我是世界第一帥'

>>> a = A()
>>> a
我是世界第一帥
>>> print(a)
我真帥

四、屬性操作的魔法方法

  • __getattr__(self, name):定義當用戶試圖獲取一個不存在的屬性時的行為,其中name是屬性名,是一個字符串,下同
  • __getattribute__(self, name):定義當該類的屬性被訪問時的行為,該方法默認返回該屬性的值
  • __setattr__(self, name, value):定義當一個屬性被設置時的行為,value是給該屬性的值
  • __delattr__(self, name):定義當一個屬性被刪除時的行為

例如:

class A:
    def __init__(self):
        self.id = "Pyhon"
    def __getattr__(self,name):
        print(name+"這個屬性不存在")
    def __getattribute__(self,name):
        print("我訪問瞭"+name+"這個屬性")
        return super().__getattribute__(name)
    def __setattr__(self,name,value):
        print("將屬性"+name+"置為"+value)
        super().__setattr__(name,value)
    def __delattr__(self,name):
        print("將屬性"+name+"刪除瞭");
        super().__delattr__(name)
    def fun(self):
        pass
a = A()
a.name
a.name = "老師"
del a.name
a.fun()
# output:
# 將屬性id置為Pyhon
# 我訪問瞭name這個屬性
# name這個屬性不存在
# 將屬性name置為老師
# 將屬性name刪除瞭
# 我訪問瞭fun這個屬性

結果可以看出,當我們訪問一個屬性的時候,先是調用瞭__getattribute__,如果該屬性不存在,則再調用__getattr__

使用這幾個的方法的時候,要註意不要陷入無限遞歸,運算符重載的時候也容易犯這種錯誤,例如下面的錯誤

class A:
    def __init__(self):
        self.id = "Pyhon"
    def __setattr__(self,name,value):
        print("將屬性"+name+"置為"+value)
        if(name == "id"):
            self.id = value

a = A()

執行這段程序的時候將陷入無限遞歸,原因是在__setattr__中,直接給self對象的屬性賦值,而這又會調用__setattr__方法。

所以在__setattr__中,我們通常會使用父類的__setattr__方法來給self對象的屬性賦值,這不會陷入無限遞歸,其他幾個方法和運算符重載也是同理,上面程序訂正後如下

class A:
    def __init__(self):
        self.id = "Pyhon"
    def __setattr__(self,name,value):
        print("將屬性"+name+"置為"+value)
        if(name == "id"):
            super().__setattr__(name,value)

a = A()
# output
# 將屬性id置為Pyhon

五、描述符

  • __get__(self, instance, owner):通過其他實例對象來訪問該類的實例對象時會調用該方法,返回該實例對象的引用。其中instance是訪問該對象的實例對象的引用,下同,owner是訪問該對象的類對象
  • __set__(self, instance, value):通過其他實例對象來給該類的實例對象賦值時會調用該方法。其中value是給該對象賦的值
  • __delete__(self, instance):通過其他實例對象來刪除該類的實例對象時會調用該方法
class Fit:
    def __init__(self):
        self.height = 180
        self.weight = 80
    def __get__(self,instance,owner):
        print("get:",instance,owner)
        return [self.height,self.weight]
    def __set__(self,instance,value):
        print("set:",instance,value)
        self.height = value
        self.weight = value/2
    def __delete__(self,instance):
        del self.height
        del self.weight
        print("delete:",instance)

class Test:
    fit = Fit()
        
t = Test()
print (t.fit)
t.fit = 190
del t.fit
# output:
# get: <__main__.Test object at 0x0000023EFFA738C8> <class '__main__.Test'>
# [180, 80]
# set: <__main__.Test object at 0x0000023EFFA738C8> 190
# delete: <__main__.Test object at 0x0000023EFFA738C8>

通常情況下,上面幾個魔法方法,當我們需要定義一個屬性,且希望可以直接對該屬性進行相應的操作,而不是通過調用方法的方式來進行操作時,我們可以定義一個該屬性的類,實現上面幾個魔法方法,將需要用到的屬性作為其實例對象,這樣就完成瞭,例如上面的Fit,其實就是體型類,而Test中有一個體型屬性叫fit,我們在Fit中定義瞭一些對Fit的實例對象操作時執行的操作。

六、定制序列

  • __len__(self):定義當該類的實例對象被len()調用時的行為
  • __getitem__(self, key):定義獲取該類的實例對象中指定元素的行為,也就是說執行self[key]時的行為
  • __setitem__(self, key, value):定義設置該類的實例對象中指定元素的行為,相當於self[key] = value
  • __delitem__(self, key):定義刪除該類的實例對象中指定元素的新聞,相當於del self[key]
class CountList:
    def __init__(self,*args):
        self.values = [x for x in args]#這是一個列表推導式,把args裡的元素作為values的元素
        self.count = {}.fromkeys(range(len(self.values)),0)

    def __len__(self):
        return len(self.values)

    def __getitem__(self,key):
        self.count[key] += 1;
        return self.values[key]

c = CountList(1,3,5,7,9,11)
print(c[1])
print(c[1]+c[2])
print(c.count)
# output:
# 3
# 8
# {0: 0, 1: 2, 2: 1, 3: 0, 4: 0, 5: 0}

該類中的count是記錄對應元素被訪問的次數,其他兩個也差不多,不再舉例瞭

七、迭代器

迭代器,就是提供瞭迭代方法的容器,而所謂的迭代方法,就是下面這兩個__iter____next__
可迭代,就是提供瞭__iter__方法的容器,我們之前講的字符串,列表,元組,字典,集合都是可迭代的,但他們不是迭代器,可以使用Python的內置函數iter(iterable)來獲取他們相應的迭代器,而迭代器使用next(iterator)可以獲取下一個元素,而這兩個方法其實就是調用瞭迭代器的__iter____next__

  • __iter__(self):定義獲取迭代器時的行為
  • __next__(self):定義獲取迭代器對應的下一個元素時的行為
class Fb:
    def __init__(self,n = 20):
        self.a = 0
        self.b = 1
        self.n = n
    def __iter__(self):
        return self
    def __next__(self):
        t = self.a
        self.a = self.b
        self.b = t + self.b
        if(self.a <= self.n):
            return self.a
        else:
            raise StopIteration

f = Fb()
for i in f:
    print(i,end=' ')
# output:1 1 2 3 5 8 13 

其中 raise 是返回一個異常,上面的程序等價於下面這個

class Fb:
    def __init__(self,n = 20):
        self.a = 0
        self.b = 1
        self.n = n
    def __iter__(self):
        return self
    def __next__(self):
        t = self.a
        self.a = self.b
        self.b = t + self.b
        if(self.a <= self.n):
            return self.a
        else:
            raise StopIteration

f = Fb()
it = iter(f)
while True:
    try:
        i = next(it)
        print(i, end=' ')
    except StopIteration:
        break;

這樣我們就很清楚Python中for循環的原理瞭,先通過iter來獲取迭代器對象,然後不斷調用next來獲取下一個元素賦值給i,直到遇到StopIteration異常

到此這篇關於詳解Python常用的魔法方法的文章就介紹到這瞭,更多相關python魔法方法內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet!

推薦閱讀: