經驗拾憶（純手工）=> Python黑魔法

tulayang 發布于2019-07-31 10:27 / 1005人閱讀

摘要：類的繼承類繼承有三種調用方式，其實是有區別的，聽我慢慢道來第一種父類方法參數直接調用第二種方法參數直接調用在誰的類下調用，就找此類對應的下一個就是要繼承的第三種方法參數找類名對應的的下一個，就是繼承的，一般寫本身的類名上下文管理器上下文管理

類的繼承

類繼承有三種調用方式，其實是 有區別 的，聽我慢慢道來
class A:
    def say(self, name):
        print(f"Im {name}")
class B(A):
    def say(self, name):
    # 第一種：父類.方法(self, 參數) 直接調用
        A.say(self, name)    
        
    def say(self, name):
    # 第二種：super().方法(參數)    直接調用
    # 在誰的類下調用super，就找此類對應 mro()的下一個,就是要繼承的
         super().say(name)
         
    def say(self, name):
    # 第三種：super(B, self).方法(參數)
    # 找類名 對應的 mro()的下一個，就是 繼承的，一般寫本身的類名
        super(B, self).say(name)

B().say("Tom")

上下文管理器

"""
    上下文管理器可以用兩種方式實現：
"""
     方式1：通過類來實現
        主要實現兩種協議
            1. __enter__(self)
            2. __exit__(self, *args, **kwargs)
                
        class A():
            def __init__(self, name):
                self.name = name
            def __enter__(self):
                print("進入")
                return self
            def __exit__(self, *args, **kwargs):
                print("退出")
                return True
        
        with A("Tom") as a:
            print(a.name)

    方式2：通過函數來實現
        from contextlib import contextmanager
        @contextmanager
        def f():
            print("開始")    # yield 之前 對應 with f()
            yield "中間"     # yield 的值 就是    as 之后的值
            print("結束")    # yield 之后 對應 print(str1) 這個語句體
        
        with f() as str1:
            print(str1)
        ------------------Output----------------------
        開始
        中間
        結束

屬性描述符-property-setter

class A:
@property
def name(self):
    return "123"
@name.setter
def name(self, value):
    self.age=value

a = A()
print(a.name)
a.name = "456"
print(a.age)

__init__()

實例化對象時自動調用，這里先賣個關子，見下面 __new__()

__call__()

"""
   對象當做函數執行的時候會自動調用 __call__()
"""
class A():
    pass
a = A()    # 此處自動調用了 __init__()
a()        # 此處自動調用了 __call__()

__str__()

"""
    對對象進行print操作的時候 會自動調用 __str__()
"""
class A:
    def __str__(self):
        return "5"
a = A()
print(a)  # 此處自動調用了 __str__()

__new__()

"""
    上面說過 __init__()是實例化對象的時候自動調用，在它之前還隱式調用了 __new__()
    __new__返回的是什么，對象就是什么
"""
In [2]: class A:
   ...:   def __new__(self):
   ...:     print("__new__")    # 初始化對象只調用 __new__ 而不調用 __init__
   ...:     return 1
   ...:   def __init__(self):
   ...:     print(2)
   ...: print(A())
    __new__
    1

__setattr__() 和 __getattr__() 和 __delattr__()

"""
    __setattr__()：=號 屬性賦值 會自動調用此方法 
    __getattr__()：.號 屬性取值 會自動調用此方法    # 注：找不到屬性才會調用此方法
    __delattr__()：del 屬性刪除 會自動調用此方法
"""
class A:

    def __init__(self, name):
        self.name = name        # 賦值操作就會調用 __setattr__()
    
    def __setattr__(self, name, value):
        print(f"{name}:{value}")
    def __getattr__(self, name):
        print(name)
    def __delattr__(self,name):
        print("del了")
        
a = A("Jack")    # 調用了 __init__
a.name = "Tom"   # 賦值操作再次調用 __setattr__()
a.name           # 取值操作調用 __getattr__()
---------------------output---------------------
name:Jack
name:Tom
name
del了

__getattribute__()

"""
    和 __getattr__() 一樣，只不過 __getattribute__最先調用，并攔截了 __getattr__()
"""
class A:
    def __init__(self):
        self.name = 1
    def __getattr__(self,x,*args, **kwargs):
        print(456)
    def __getattribute__(self, x):
        print(123)

a = A()
a.aaaaaa
-----------output---------------
123

__getitem__()

"""
    對對象進行 切片、索引、遍歷 等 會自動調用此方法
"""
class A:
def __getitem__(self,x,*args, **kwargs):
    return x

a = A()
觸發方式1： 如果直接索引此對象，那么索引值就會傳遞到上面 x 當作參數
    print(a[5])
    >> 5
觸發方式2： 如果直接切片此對象，那么slice對象 就會傳遞到上面 x 當作參數
    print(a[1:5])
    >> slice(1, 5, None)
觸發方式3： 如果for循環迭代此對象，那么 上面的 x 每次將會被賦予從零開始 自增1的自然整數
    for x in a:
        print(x)
    >> 0,1,2,3,4....................

__init_subclass__（）

"""
    被繼承的類 會自動調用__init_subclass__ 
"""
class A:
    def __init_subclass__(self):
        print("我被繼承了")

class B(A):
    pass

__base__（）

"""
    查看基類
"""
class A:
    pass
class B(A):
    pass
print(B.__base__)
-----------output---------------

__contains__()

"""
    xx in xx 就會自動調用  __contains__()
"""

文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

轉載請注明本文地址：http://m.specialneedsforspecialkids.com/yun/43860.html

經驗拾憶（純手工）=> Python三器

摘要：也就是給原函數加個外殼。類裝飾填充了啊我是原函數類裝飾填充了啊我是原函數說明后面關于類的裝飾器如果理解困難當做了解即可，用的也少。可迭代對象、生成器、迭代器三者的關系 1. 迭代器一定是可迭代對象 2. 生成器是迭代器的一種 3. 可迭代對象：必須實現 __iter__方法 4. 迭代器：必須實現 __iter__方法和 __next__ 方法 5. 生成器：必須實現 __it...

Miracle_lihb 2019-07-31 10:26 評論0 收藏0
經驗拾憶（純手工）=> Python三程

摘要：多線程對于爬蟲方面也可以表現出較好的性能。計算密集型就別想多線程了，一律多進程。所以同一時刻最大的并行線程數進程數的核數這條我的個人理解很模糊，參考吧多線程多線程有種通過的那種方式，非常普遍，此處就不寫了。 GIL的理解 GIL這個話題至今也是個爭議較多的，對于不用應用場景對線程的需求也就不同，說下我聽過的優點： 1. 我沒有用過其他語言的多線程，所以無法比較什么，但是對于I/O而言，...

Snailclimb 2019-07-31 10:27 評論0 收藏0
經驗拾憶（純手工）=> Python好用深度技能工具介紹

摘要：單元素元祖這是整數這才是元祖也許這兩行，你們當時疑惑過，并且現在也都知道了，當然重點并不在這里。。雖然我水平很垃圾，但是我知道匿名函數有一種執行方式叫做自執行。看吧，這就是版的匿名函數自執行方法。單元素元祖： a = (1) # 這是整數1 a = (1,) # 這才是元祖也許這兩行，你們當時疑惑過，并且現在也都知道了，當然重點并不在這里。。我無聊的時候想過，為什么單...

UnixAgain 2019-07-31 10:29 評論0 收藏0
經驗拾憶（純手工）=> Python高階函數操作

摘要：解釋就相當于把每個序列元素的每一個單獨用一個管道函數處理，再把他們按順序組合成一個新可迭代對象注意這個管道函數只能是單參數函數，如果想傳遞多個參數怎么辦使用偏函數怕有些人看不懂，這里就不用了，而是用普通函數定義方式固定值固定值固定值固定值固 map In [25]: list(map(lambda a:a**2, [1,2,3,4])) Out[25]: [1, 4, 9, 16] 解...

Elle 2019-07-31 10:26 評論0 收藏0
經驗拾憶（純手工）=> Python基本數據類型

摘要：不要疑惑，告訴你答案這個代表正負號的正。雖然一點技術含量沒有，但是你要懂序列也許叫可迭代對象更為合適，但是我喜歡叫序列。數據結構可變類型與不可變類型（重頭戲）基操：可變類型：[], {} # 可增刪改查不可變類型: int float str () # 無法增刪改，只可查升操： + 與...

Andrman 2019-07-31 10:26 評論0 收藏0