經(jīng)驗拾憶（純手工）=> Python黑魔法

tulayang 發(fā)布于2019-07-31 10:27 / 1061人閱讀

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

類的繼承

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

B().say("Tom")

上下文管理器

"""
    上下文管理器可以用兩種方式實現(xiàn)：
"""
     方式1：通過類來實現(xiàn)
        主要實現(xiàn)兩種協(xié)議
            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：通過函數(shù)來實現(xiàn)
        from contextlib import contextmanager
        @contextmanager
        def f():
            print("開始")    # yield 之前 對應 with f()
            yield "中間"     # yield 的值 就是    as 之后的值
            print("結(jié)束")    # yield 之后 對應 print(str1) 這個語句體
        
        with f() as str1:
            print(str1)
        ------------------Output----------------------
        開始
        中間
        結(jié)束

屬性描述符-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__()

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

__call__()

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

__str__()

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

__new__()

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

__setattr__() 和 __getattr__() 和 __delattr__()

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

    def __init__(self, name):
        self.name = name        # 賦值操作就會調(diào)用 __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")    # 調(diào)用了 __init__
a.name = "Tom"   # 賦值操作再次調(diào)用 __setattr__()
a.name           # 取值操作調(diào)用 __getattr__()
---------------------output---------------------
name:Jack
name:Tom
name
del了

__getattribute__()

"""
    和 __getattr__() 一樣，只不過 __getattribute__最先調(diào)用，并攔截了 __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__()

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

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

__init_subclass__（）

"""
    被繼承的類 會自動調(diào)用__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 就會自動調(diào)用  __contains__()
"""

文章版權(quán)歸作者所有，未經(jīng)允許請勿轉(zhuǎn)載,若此文章存在違規(guī)行為，您可以聯(lián)系管理員刪除。

轉(zhuǎn)載請注明本文地址：http://m.hztianpu.com/yun/43860.html

經(jīng)驗拾憶（純手工）=> Python三器

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

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

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

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

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

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

摘要：解釋就相當于把每個序列元素的每一個單獨用一個管道函數(shù)處理，再把他們按順序組合成一個新可迭代對象注意這個管道函數(shù)只能是單參數(shù)函數(shù)，如果想傳遞多個參數(shù)怎么辦使用偏函數(shù)怕有些人看不懂，這里就不用了，而是用普通函數(shù)定義方式固定值固定值固定值固定值固 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
經(jīng)驗拾憶（純手工）=> Python基本數(shù)據(jù)類型

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

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