oop（面向對象）中的內置函數

時間 2019-11-18

原文原文鏈接

oop中的內置函數

類中存在一些名字帶有雙下劃線__開頭的內置函數，這些函數會在某些時候被自動調用,例如以前學習的迭代器__init__函數python

1、isinstance(obj, cls)

檢查obj是不是cls的對象程序員

class Foo(object):
     pass
 obj = Foo()
 isinstance(obj, Foo)

2、issubclass(sub, super)

檢查sub類是不是super類的派生類數據庫

class Foo(object):
    pass
class Bar(Foo):
    pass
issubclass(Bar, Foo)

3、操做對象屬性時自動觸發

一、__setattr__ 使用點語法添加/修改屬性會觸發編程

__delattr__ 使用點語法刪除屬性的時候會觸發數組

__getattr__ 使用點語法調用屬性且屬性不存在的時候纔會觸發緩存

__getattribute__ 使用點語法調用屬性的時候觸發,不管屬性是否存在都會執行網絡

注意：當getattribute與getattr同時存在時，僅執行getattribute

class Foo:
    x=1
    def __init__(self,y):
        self.y=y
    def __getattr__(self, item):
        print('----> from getattr:你找的屬性不存在')
    def __setattr__(self, key, value):
        print('----> from setattr')
        # self.key=value #這就無限遞歸了,你好好想一想
        # self.__dict__[key]=value #應該使用它
    def __delattr__(self, item):
        print('----> from delattr')
        # del self.item #無限遞歸了
        self.__dict__.pop(item)

#__setattr__添加/修改屬性會觸發它的執行
f1=Foo(10)
print(f1.__dict__) # 由於你重寫了__setattr__,凡是賦值操做都會觸發它的運行,你啥都沒寫,就是根本沒賦值,除非你直接操做屬性字典,不然永遠沒法賦值
f1.z=3
print(f1.__dict__)

#__delattr__刪除屬性的時候會觸發
f1.__dict__['a']=3#咱們能夠直接修改屬性字典,來完成添加/修改屬性的操做
del f1.a
print(f1.__dict__)

#__getattr__只有在使用點調用屬性且屬性不存在的時候纔會觸發
f1.xxxxxx

#三者的用法演示

二、__setitem__ 使用key的形式添加/修改屬性時觸發數據結構

__getitem__ 使用key的形式獲取屬性時觸發框架

__delitem__ 使用key的形式刪除屬性時觸發函數

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

    def __getitem__(self, item):
        print(self.__dict__[item])

    def __setitem__(self, key, value):
        self.__dict__[key]=value
    def __delitem__(self, key):
        print('del obj[key]時,我執行')
        self.__dict__.pop(key)
    def __delattr__(self, item):
        print('del obj.key時,我執行')
        self.__dict__.pop(item)

f1=Foo('sb')
f1['age']=18
f1['age1']=19
del f1.age1
del f1['age']
f1['name']='alex'
print(f1.__dict__)

4、描述符

一、什麼是描述符

描述符本質就是一個類，在這個新式類中，至少實現了__get__, __set__, __delete__中的一個，也被成爲描述符協議

__get__() 調用一個屬性時觸發

__set__() 爲一個屬性賦值時觸發

__delete__() 採用del刪除屬性時觸發

二、爲何須要描述符

描述符的做用是用來代理另外一個類的屬性的（必須把描述符定義成這個類的類屬性，不能定義到構造函數中），python底層的不少特性都是使用描述符來實現的，例如實例方法，classmethod，statisticmethod等等

簡單的說，描述符能夠檢測到一個屬性的訪問和修改，從而對這些操做增長額外的功能邏輯

#描述符Str
class Str:
    def __get__(self, instance, owner):
        print('Str調用')
    def __set__(self, instance, value):
        print('Str設置...')
    def __delete__(self, instance):
        print('Str刪除...')

#描述符Int
class Int:
    def __get__(self, instance, owner):
        print('Int調用')
    def __set__(self, instance, value):
        print('Int設置...')
    def __delete__(self, instance):
        print('Int刪除...')

class People:
    name=Str()
    age=Int()
    def __init__(self,name,age): #name被Str類代理,age被Int類代理,
        self.name=name
        self.age=age

#何地？：定義成另一個類的類屬性

#什麼時候？：且看下列演示

p1=People('alex',18)

#描述符Str的使用
p1.name
p1.name='egon'
del p1.name

#描述符Int的使用
p1.age
p1.age=18
del p1.age

#咱們來瞅瞅到底發生了什麼
print(p1.__dict__)
print(People.__dict__)

#補充
print(type(p1) == People) #type(obj)實際上是查看obj是由哪一個類實例化來的
print(type(p1).__dict__ == People.__dict__)

# 描述符應用 以及執行時機

三、描述的分類

數據描述符

至少實現了__get__()和__set__()兩個方法

class Foo:
    def __set__(self, instance, value):
        print('set')
    def __get__(self, instance, owner):
        print('get')

非數據描述符

沒有實現__set__()方法

class Foo:
  def __get__(self, instance, owner):
    print('get')

四、注意事項

描述符自己應該被定義成新式類，被代理的類也應該是新式類
必須把描述符定義成這個類的類屬性，不能定義到構造函數中
要嚴格遵循下面的優先級，有高到低：

類屬性

數據描述符

實例屬性

非數據描述符

找不到的屬性觸發__getattr__

五、描述符總結

描述符是能夠實現大部分python類特性中的底層魔法，包括@classmethod, @statisticmethod,@property甚至是__slots__屬性
描述符是不少高級庫和框架的重要工具之一，描述符一般是使用到裝飾器或者元類的大型框架中的一個組件

案例1：利用描述符原理完成一個自定製@property，完成延遲計算（本質就是把一個函數屬性利用裝飾器原理作成一個描述符：類的屬性字典中函數名爲key，value爲描述符類產生的對象）

class Lazyproperty:
    def __init__(self,func):
        self.func=func
    def __get__(self, instance, owner):
        print('這是咱們本身定製的靜態屬性,r1.area實際是要執行r1.area()')
        if instance is None:
            return self
        else:
            print('--->')
            value=self.func(instance)
            setattr(instance,self.func.__name__,value) #計算一次就緩存到實例的屬性字典中
            return value

class Room:
    def __init__(self,name,width,length):
        self.name=name
        self.width=width
        self.length=length

    @Lazyproperty #area=Lazyproperty(area) 至關於'定義了一個類屬性,即描述符'
    def area(self):
        return self.width * self.length

r1=Room('alex',1,1)
print(r1.area) #先從本身的屬性字典找,沒有再去類的中找,而後觸發了area的__get__方法
print(r1.area) #先從本身的屬性字典找,找到了,是上次計算的結果,這樣就不用每執行一次都去計算

案例2：利用描述符原理完成一個自定製@classmethod

class ClassMethod:
    def __init__(self,func):
        self.func=func

    def __get__(self, instance, owner): #類來調用,instance爲None,owner爲類自己,實例來調用,instance爲實例,owner爲類自己,
        def feedback():
            print('在這裏能夠加功能啊...')
            return self.func(owner)
        return feedback

class People:
    name='linhaifeng'
    @ClassMethod # say_hi=ClassMethod(say_hi)
    def say_hi(cls):
        print('你好啊,帥哥 %s' %cls.name)

People.say_hi()

p1=People()
p1.say_hi()
#疑問,類方法若是有參數呢,好說,好說

class ClassMethod:
    def __init__(self,func):
        self.func=func

    def __get__(self, instance, owner): #類來調用,instance爲None,owner爲類自己,實例來調用,instance爲實例,owner爲類自己,
        def feedback(*args,**kwargs):
            print('在這裏能夠加功能啊...')
            return self.func(owner,*args,**kwargs)
        return feedback

class People:
    name='linhaifeng'
    @ClassMethod # say_hi=ClassMethod(say_hi)
    def say_hi(cls,msg):
        print('你好啊,帥哥 %s %s' %(cls.name,msg))

People.say_hi('你是那偷心的賊')

p1=People()
p1.say_hi('你是那偷心的賊')

案例3：利用描述符原理完成一個自定製的@statisticmethod

class StaticMethod:
    def __init__(self,func):
        self.func=func

    def __get__(self, instance, owner): #類來調用,instance爲None,owner爲類自己,實例來調用,instance爲實例,owner爲類自己,
        def feedback(*args,**kwargs):
            print('在這裏能夠加功能啊...')
            return self.func(*args,**kwargs)
        return feedback

class People:
    @StaticMethod# say_hi=StaticMethod(say_hi)
    def say_hi(x,y,z):
        print('------>',x,y,z)

People.say_hi(1,2,3)

p1=People()
p1.say_hi(4,5,6)

5、再看property

一個靜態屬性property本質就是實現了get，set，delete三種方法

class Foo:
    @property
    def AAA(self):
        print('get的時候運行我啊')

    @AAA.setter
    def AAA(self,value):
        print('set的時候運行我啊')

    @AAA.deleter
    def AAA(self):
        print('delete的時候運行我啊')

#只有在屬性AAA定義property後才能定義AAA.setter,AAA.deleter
f1=Foo()
f1.AAA
f1.AAA='aaa'
del f1.AAA

#==============================================用法二
class Foo:
    def get_AAA(self):
        print('get的時候運行我啊')

    def set_AAA(self,value):
        print('set的時候運行我啊')

    def delete_AAA(self):
        print('delete的時候運行我啊')
    AAA=property(get_AAA,set_AAA,delete_AAA) #內置property三個參數與get,set,delete一一對應

f1=Foo()
f1.AAA
f1.AAA='aaa'
del f1.AAA

6、對象的顯示相關函數

__str__ 調用str函數或者print函數時自動執行，返回值做爲顯示內容
__repr__ 調用repr函數或者交互式解釋器輸出對象時自動執行，返回值做爲顯示內容
注意：若是__str__沒有被定義，那麼就會使用__repe__來代替輸出，這兩方法的返回值必須是字符串，不然拋出異常
__format__ 調用format函數時自動執行，用於定製對象的格式化輸出

format使用案例

#{0.year}:{0.month}:{0.day} 這是一個格式化字符串 ,想到於"%s:%s:%s" year表示取對象的year屬性值
date_dic={
    'ymd':'{0.year}:{0.month}:{0.day}',
    'dmy':'{0.day}/{0.month}/{0.year}',
    'mdy':'{0.month}-{0.day}-{0.year}',
}
class Date:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day

    def __format__(self, format_spec):
        if not format_spec or format_spec not in date_dic:
            format_spec='ymd'
        fmt=date_dic[format_spec]
        return fmt.format(self)

d1=Date(2016,12,29)
print(format(d1))
print('{:mdy}'.format(d1))

7、內存優化之slots

__slots__是什麼

是一個類變量，變量值能夠是列表，元組，或者可迭代對象，也能夠是一個字符串（意味着全部實例只有一個數據屬性）
引子

使用點來訪問屬性本質就是在訪問類或者對象的__dict__屬性字典（類的字典是共享的，而每一個實例是獨立的，須要給每個實例建立一個字典）
爲什麼使用__slots__

字典會佔用大量內存,若是你有一個屬性不多的類,可是有不少實例,爲了節省內存可使用__slots__取代實例的__dict__
當你定義__slots__後,__slots__就會爲實例使用一種更加緊湊的內部表示,實例經過一個很小的固定大小的數組來構建,而不是爲每一個實例定義一個字典,這跟元組或列表很相似。
在__slots__中列出的屬性名在內部被映射到這個數組的指定下標上。
使用__slots__一個很差的地方就是咱們不能再給實例添加新的屬性了,只能使用在__slots__中定義的那些屬性名。
注意事項

__slots__的不少特性都依賴於普通的基於字典的實現。另外,定義了__slots__後的類再也不支持一些普通類特性了,好比多繼承。大多數狀況下,你應該只在那些常常被使用到的數據結構的類上定義__slots__好比在程序中須要建立某個類的幾百萬個實例對象。關於__slots__的一個常見誤區是它能夠做爲一個封裝工具來防止用戶給實例增長新的屬性。儘管使用__slots__能夠達到這樣的目的,可是這個並非它的初衷。更多的是用來做爲一個內存優化工具。

案例

class Foo:
    __slots__=['name','age']

f1=Foo()
f1.name='alex'
f1.age=18
print(f1.__slots__)

#f1.y=2  報錯
print(f1.__slots__) #f1再也不有__dict__


f2=Foo()
f2.name='egon'
f2.age=19
print(f2.__slots__)

print(Foo.__dict__)
#f1與f2都沒有屬性字典__dict__了,統一歸__slots__管,節省內存

8、迭代器協議之next和iter

class Foo:
    def __init__(self,start,stop):
        self.num=start
        self.stop=stop
    def __iter__(self):
        return self
    def __next__(self):
        if self.num >= self.stop:
            raise StopIteration
        n=self.num
        self.num+=1
        return n

f=Foo(1,5)
from collections import Iterable,Iterator
print(isinstance(f,Iterator))

for i in Foo(1,5):
    print(i)

9、幫助文檔doc

這是一個隱藏屬性，用於獲取類的幫助文檔，其實就是類下面的多行註釋

class Foo:
    '我是描述信息'
    pass

class Bar(Foo):
    pass
print(Foo.__doc__) 
#輸出 我是描述
print(Bar.__doc__) #該屬性沒法繼承給子類
#輸出 None

須要注意的是：該屬性不會被繼承

10、module和class

__module__ 表示當前操做的對象在那個模塊

__class__ 表示當前操做的對象的類是什麼

class C:

    def __init__(self):
        self.name = 'SB'
#該類位於lib/aa.py文件中

在另外一個文件中

from lib.aa import C

obj = C()
print obj.__module__  # 輸出 lib.aa，即：輸出模塊
print obj.__class__      # 輸出 lib.aa.C，即：輸出類

11、del析構方法

什麼是析構方法

析構看作構建的反義詞,構建指一個東西從無到有,析構指一個東西從有到無

析構方法的特色是: 當對象在內存中被釋放時，會自動觸發執行
爲何須要析構方法

若是產生的對象僅僅只是python程序級別的（用戶級），那麼無需定義__del__,由於python會自動完成全部資源的回收;
若是產生的對象的同時還會向操做系統發起系統調用，即一個對象有用戶級與內核級兩種資源，好比（打開一個文件，建立一個數據庫連接），則必須在清除對象的同時回收系統資源，這就用到了__del__

class Foo:

    def __del__(self):
        print('執行我啦')

f1=Foo()
del f1
print('------->')

#輸出 執行我啦
#輸出 ------->

class Foo:
    def __del__(self):
        print('執行我啦')

f1=Foo()
# del f1
print('------->')
#輸出 ------->
#輸出 執行我啦

你會發現就算不去調用del方法同樣會出發執行__del__,這是由於你python解釋器在程序運行結束時必須將全部資源所有釋放,固然包括建立的f1對象

典型的應用場景

建立數據庫類，用該類實例化出數據庫連接對象，對象自己是存放於用戶空間內存中，而連接則是由操做系統管理的，存放於內核空間內存中

當程序結束時，python只會回收本身的內存空間，即用戶態內存，而操做系統的資源則沒有被回收，這就須要咱們定製__del__，在對象被刪除前向操做系統發起關閉數據庫連接的系統調用，回收資源
這與文件處理是一個道理

f=open('a.txt') #作了兩件事，在用戶空間拿到一個f變量，在操做系統內核空間打開一個文件
del f #只回收用戶空間的f，操做系統的文件還處於打開狀態

#因此咱們應該在del f以前保證f.close()執行,即使是沒有del，程序執行完畢也會自動del清理資源，因而文件操做的正確用法應該是
f=open('a.txt')
#讀寫...
f.close()
#不少狀況下你們都容易忽略f.close,這就用到了with上下文管理

12、上下文管理之`enter`和`exit`

什麼是上下文管理

上下文指的是一種語境,屬於語言科學,提及來很抽象,其實你已經在不少地方使用到他了,來看一個實例

with open('a.txt') as f:
　　print(f.read())

在這個代碼中python解釋器分析出你的代碼想要作的事情,而後在結束的時候自動幫你將資源釋放了,with中的全部代碼都在一個上下文中,你能夠把他理解爲一個代碼範圍

爲何須要上下文管理

上面的例子能夠看出不使用上下文管理徹底沒有問題,只須要程序員,在合適的位置編寫代碼來關閉文件資源,這實際上是一種體力活徹底沒有技術含量

因此使用上下文能夠省略掉一些重複代碼的編寫工做,同時避免了一些粗心的程序員忘記作一些清理工做
如何使用

該協議包含兩個方法

__enter__ 出現with語句,對象的__enter__被觸發,有返回值則賦值給as聲明的變量

__exit__ with中代碼塊執行完畢時執行

只要這個一個類實現了這兩個方法就能夠被with 語句使用

案例: 模擬open

class Open:
    def __init__(self,filepath,mode='r',encoding='utf-8'):
        self.filepath=filepath
        self.mode=mode
        self.encoding=encoding

    def __enter__(self):
        # print('enter')
        self.f=open(self.filepath,mode=self.mode,encoding=self.encoding)
        return self.f

    def __exit__(self, exc_type, exc_val, exc_tb):
        # print('exit')
        self.f.close()
        return True 
    def __getattr__(self, item):
        return getattr(self.f,item)

with Open('a.txt','w') as f:
    print(f)
    f.write('aaaaaa')
    f.wasdf #拋出異常，交給__exit__處理

須要注意的是：

__exit__()中的三個參數分別表明異常類型，異常值和追溯信息
with語句中代碼塊出現異常時,會當即觸發方法__exit__的執行,並將異常信息錯誤參數傳入
with語句中代碼塊未出現異常正常結束時也會觸發方法__exit__的執行,此時參數中的異常信息爲空
若是__exit__()返回值爲True,那麼異常會被清空，就好像啥都沒發生同樣，with後的語句正常執行

總結：

使用with語句的目的就是把代碼塊放入with中執行，with結束後，自動完成清理工做，無須手動干預
在須要管理一些資源好比文件，網絡鏈接和鎖的編程環境中，能夠在__exit__中定製自動釋放資源的機制，你無須再去關心這個問題，這將大有用處

十3、call

__call__是一個函數，在對象被調用時執行，調用就是加括號()

注：構造方法的執行是由建立對象觸發的，即：對象 = 類名() ；而對於 __call__方法的執行是由對象後加括號觸發的，即：對象() 或者類()的區別

class Foo:
    def __init__(self):
        pass
    
    def __call__(self, *args, **kwargs):

        print('__call__')
obj = Foo() # 執行 __init__
obj()       # 執行 __call__