一、isinstance（obj，cls）和 issubclass（sub，super）

---

1，isinstance(obj,cls) 檢查 obj 是否是類 cls 的物件

class Foo(object):
    pass

obj = Foo()
print(isinstance(obj, Foo))
# True

2，issubclass(sub, super)檢查sub類是否是 super 類的派生類

class Foo(object):
    pass

class Bar(Foo):
    pass

print(issubclass(Bar, Foo))
# True
 

二、反射

---

1，什麼是反射？

反射的概念是由 Smith 在1982年首次提出的，主要是指程式可以訪問、檢測和修改它本身狀態或行為的一種能力（自省）。

這一概念的提出很快引發了電腦科學領域關於應用反射性的研究。

它首先被程式語言的設計領域所採用，並在 Lisp 和麵向物件方面取得了成績。

2，python 面向物件中的反射：

通過字串的形式操作物件相關的屬性，python 中的一切事物都是物件（都可以使用反射）

四個可以實現自省的函式

下列方法適用於類和物件（一切皆物件，類本身也是一個物件）

判斷object中有沒有一個name字串對應的方法或屬性

hasattr(object,name)

getattr(object, "name", None)
"""
從這個類中獲得一個 name 的屬性或者方法(視情況而定)，
getattr(x, 'y') 相當於 x.y (x類呼叫y方法或屬性)。
最後一個引數不寫的話，如果沒有這個屬性會報錯，寫上最後一個引數，防止報錯，沒有這個屬性的話返回 None
"""

getattr(object,name,default=None)

setattr(obj, "name", value)
# 三個引數，物件，字串屬性，最後一個是你要把屬性設定成什麼值。

setattr(obj, "name", value)

delattr(obj, "
 
name")
# 兩個引數，物件和字串形式的屬性。

delattr(obj, "name")

class People:
    country = "China"

    def __init__(self,name,age):
        self.name = name
        self.age = age

    def talk(self):
        print("%s is talking" % self.name)

    def learn(self):
        print("%s is learning" % self.name)

zx = People("子系",18)

# 檢查是否含有某屬性
print(hasattr(zx, "name"))      # True
print(hasattr(zx, "talk"))      # True

# 獲取屬性
func = getattr(zx, "learn")
print(func)     # <bound method People.learn of <__main__.People object at 0x0000023B4E2B2208>>
func()          # 子系 is learning, 繫結方法

print(getattr(zx, "zoling", "不存在，別瞎寫"))     # 不存在，別瞎寫（最後一個引數是預設值，屬性不存在，返回這個引數，防止報錯）

# 設定屬性
setattr(zx, "is_iron", True)
setattr(zx, "show_name", lambda self:self.name + "is_iron")
print(zx.__dict__)
# {'name': '子系', 'age': 18, 'is_iron': True, 'show_name': <function <lambda> at 0x000001CD3504FAE8>}
print(zx.show_name(zx))     # 子系is_iron

# 刪除屬性
delattr(zx, "show_name")
# delattr(zx, "show_name_zx")     # 刪除一個不存在的屬性會報錯
print(zx.__dict__)      # {'name': '子系', 'age': 18, 'is_iron': True}

四個方法的使用演示

class Foo(object):
    field = "Python"

    def __init__(self):
        self.name = 'zixi'

    def func(self):
        return 'func'

    @staticmethod
    def bar():
        return 'bar'

print(getattr(Foo, 'field'))
print(getattr(Foo, 'func'))
print(getattr(Foo, 'bar'))

"""
Python
<function Foo.func at 0x000002A1F5F0FBF8>
<function Foo.bar at 0x000002A1F5F0FC80>
"""

類也是物件

import sys

def s1():
    print('s1')

def s2():
    print('s2')

this_module = sys.modules[__name__]

hasattr(this_module, 's1')
getattr(this_module, 's2')

反射當前模組成員

匯入其他模組，利用反射查詢該模組是否存在某個方法

#!/usr/bin/env python
# -*- coding:utf-8 -*-

def test():
    print('from the test')

module_test.py

#!/usr/bin/env python
# -*- coding:utf-8 -*-

"""
程式目錄：
    module_test.py
    index.py

當前檔案：
    index.py
"""

import module_test as obj

#obj.test()

print(hasattr(obj,'test'))

getattr(obj,'test')()

3，反射的好處

1）好處一：

有倆程式設計師，一個 zixi，一個是 zoling，zixi 在寫程式的時候需要用到 zolinig 所寫的類，但是 zoling 還沒有完成他寫的類，zixi 想到了反射，使用了反射機制 zixi 可以繼續完成自己的程式碼，等 zoling 忙完之後再繼續完成類的定義並且去實現 zixi 想要的功能。

總之反射的好處就是，可以事先定義好介面，介面只有在被完成後才會真正執行，這實現了即插即用，這其實是一種"後期繫結"，什麼意思？即你可以事先把主要的邏輯寫好（只定義介面），然後後期再去實現介面的功能。

class FtpClient:
    """ftp客戶端,但是還麼有實現具體的功能"""
    def __init__(self,addr):
        print('正在連線伺服器[%s]' % addr)
        self.addr = addr

zoling 還沒有實現全部的功能

# from module import FtpClient
f = FtpClient('192.168.1.107')
if hasattr(f,'get'):
    func_get = getattr(f,'get')
    func_get()
else:
    print('---->不存在此方法')
    print('處理其他的邏輯')

不影響 zixi 程式碼的編寫

2）好處二：

動態匯入模組（基於反射當前模組成員）

三、__setattr__，__delattr__，__getattr__

---

1，演示：

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

"""
----> from setattr
{}
----> from setattr
{}
----> from delattr
{}
----> from getattr:你找的屬性不存在
"""

三者用法演示

四、二次加工標準型別（包裝）

---

1，包裝：

python為大家提供了標準資料型別，以及豐富的內建方法，其實在很多場景下我們都需要基於標準資料型別來定製我們自己的資料型別，新增/改寫方法，這就用到了我們剛學的繼承/派生知識（其他的標準型別均可以通過下面的方式進行二次加工）

class List(list): #繼承list所有的屬性，也可以派生出自己新的，比如append和mid
    def append(self, p_object):
        ' 派生自己的append：加上型別檢查'
        if not isinstance(p_object,int):
            raise TypeError('must be int')
        super().append(p_object)

    @property
    def mid(self):
        '新增自己的屬性'
        index=len(self)//2
        return self[index]

l=List([1,2,3,4])
print(l)
l.append(5)
print(l)
# l.append('1111111') #報錯，必須為int型別

print(l.mid)

#其餘的方法都繼承list的
l.insert(0,-123)
print(l)
l.clear()
print(l)

二次加工標準型別（基於繼承實現）

class List(list):
    def __init__(self,item,tag=False):
        super().__init__(item)
        self.tag=tag
    def append(self, p_object):
        if not isinstance(p_object,str):
            raise TypeError
        super().append(p_object)
    def clear(self):
        if not self.tag:
            raise PermissionError
        super().clear()

l=List([1,2,3],False)
print(l)
print(l.tag)

l.append('saf')
print(l)

# l.clear() #異常

l.tag=True
l.clear()

練習（clear加許可權限制）

2，授權：

授權是包裝的一個特性,包裝一個型別通常是對已存在的型別的一些定製,這種做法可以新建,修改或刪除原有產品的功能。其它的則保持原樣。授權的過程,即是所有更新的功能都是由新類的某部分來處理,但已存在的功能就授權給物件的預設屬性。

實現授權的關鍵點就是覆蓋__getattr__方法

import time
class FileHandle:
    def __init__(self,filename,mode='r',encoding='utf-8'):
        self.file=open(filename,mode,encoding=encoding)
    def write(self,line):
        t=time.strftime('%Y-%m-%d %T')
        self.file.write('%s %s' %(t,line))

    def __getattr__(self, item):
        return getattr(self.file,item)

f1=FileHandle('b.txt','w+')
f1.write('你好啊')
f1.seek(0)
print(f1.read())
f1.close()

授權示範一

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
#我們來加上b模式支援
import time
class FileHandle:
    def __init__(self,filename,mode='r',encoding='utf-8'):
        if 'b' in mode:
            self.file=open(filename,mode)
        else:
            self.file=open(filename,mode,encoding=encoding)
        self.filename=filename
        self.mode=mode
        self.encoding=encoding

    def write(self,line):
        if 'b' in self.mode:
            if not isinstance(line,bytes):
                raise TypeError('must be bytes')
        self.file.write(line)

    def __getattr__(self, item):
        return getattr(self.file,item)

    def __str__(self):
        if 'b' in self.mode:
            res="<_io.BufferedReader name='%s'>" %self.filename
        else:
            res="<_io.TextIOWrapper name='%s' mode='%s' encoding='%s'>" %(self.filename,self.mode,self.encoding)
        return res
f1=FileHandle('b.txt','wb')
# f1.write('你好啊啊啊啊啊') #自定製的write,不用在進行encode轉成二進位制去寫了,簡單,大氣
f1.write('你好啊'.encode('utf-8'))
print(f1)
f1.close()

授權示範二

#練習一
class List:
    def __init__(self,seq):
        self.seq=seq

    def append(self, p_object):
        ' 派生自己的append加上型別檢查，覆蓋原有的append'
        if not isinstance(p_object,int):
            raise TypeError('must be int')
        self.seq.append(p_object)

    @property
    def mid(self):
        '新增自己的方法'
        index=len(self.seq)//2
        return self.seq[index]

    def __getattr__(self, item):
        return getattr(self.seq,item)

    def __str__(self):
        return str(self.seq)

l=List([1,2,3])
print(l)
l.append(4)
print(l)
# l.append('3333333') #報錯，必須為int型別

print(l.mid)

#基於授權，獲得insert方法
l.insert(0,-123)
print(l)





#練習二
class List:
    def __init__(self,seq,permission=False):
        self.seq=seq
        self.permission=permission
    def clear(self):
        if not self.permission:
            raise PermissionError('not allow the operation')
        self.seq.clear()

    def __getattr__(self, item):
        return getattr(self.seq,item)

    def __str__(self):
        return str(self.seq)
l=List([1,2,3])
# l.clear() #此時沒有許可權，丟擲異常


l.permission=True
print(l)
l.clear()
print(l)

#基於授權，獲得insert方法
l.insert(0,-123)
print(l)

練習（授權）

五、__getattribute__

---

1，__getattribute__ 方法

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

    def __getattr__(self, item):
        print('執行的是我')
        # return self.__dict__[item]

f1=Foo(10)
print(f1.x)
f1.xxxxxx #不存在的屬性訪問，觸發__getattr__

回顧 __getattr__

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

    def __getattribute__(self, item):
        print('不管是否存在,我都會執行')

f1=Foo(10)
f1.x
f1.xxxxxx

__getattribute__

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'

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

    def __getattr__(self, item):
        print('執行的是我')
        # return self.__dict__[item]
    def __getattribute__(self, item):
        print('不管是否存在,我都會執行')
        raise AttributeError('哈哈')

f1=Foo(10)
f1.x
f1.xxxxxx

#當__getattribute__與__getattr__同時存在,只會執行__getattrbute__,除非__getattribute__在執行過程中丟擲異常AttributeError

二者同時出現

六、描述符（__get__，__set__，__delete__）

---

1，描述符是什麼：

描述符本質就是一個新式類，在這個新式類中，至少實現了__get__()，__set__()，__delete__()中的一個，這也被稱為描述符協議。
__get__()：呼叫一個屬性時，觸發
__set__()：為一個屬性賦值時，觸發
__delete__()：採用del刪除屬性時，觸發

class Foo: #在python3中Foo是新式類,它實現了三種方法,這個類就被稱作一個描述符
    def __get__(self, instance, owner):
        pass
    def __set__(self, instance, value):
        pass
    def __delete__(self, instance):
        pass

定義一個描述符

2，描述符是幹什麼的：

描述符的作用是用來代理另外一個類的屬性的（必須把描述符定義成這個類的類屬性，不能定義到建構函式中）

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

#包含這三個方法的新式類稱為描述符,由這個類產生的例項進行屬性的呼叫/賦值/刪除,並不會觸發這三個方法
f1=Foo()
f1.name='egon'
f1.name
del f1.name
#疑問:何時,何地,會觸發這三個方法的執行

引言：描述符類產生的例項進行屬性操作並不會觸發三個方法的執行

#描述符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__)

描述符在什麼時候，什麼地方使用？

3，描述符分兩種：

1）資料描述符：至少實現了 __get__() 和 __set__()

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

2）非資料描述符：沒有實現 __set__()

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

4，注意事項：

1）描述符本身應該定義成新式類，被代理的類也應該是新式類。

2）必須把描述符定義成這個類的類屬性，不能定義到建構函式中。

3）要嚴格遵循該優先順序，優先順序由高到低分別是：

1，類屬性

2，資料描述符

3，例項屬性

4，非資料描述符

5，找不到的實行觸發 __getattr__()

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

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


#基於上面的演示,我們已經知道,在一個類中定義描述符它就是一個類屬性,存在於類的屬性字典中,而不是例項的屬性字典

#那既然描述符被定義成了一個類屬性,直接通過類名也一定可以呼叫吧,沒錯
People.name #恩,呼叫類屬性name,本質就是在呼叫描述符Str,觸發了__get__()

People.name='egon' #那賦值呢,我去,並沒有觸發__set__()
del People.name #趕緊試試del,我去,也沒有觸發__delete__()
#結論:描述符對類沒有作用-------->傻逼到家的結論

'''
原因:描述符在使用時被定義成另外一個類的類屬性,因而類屬性比二次加工的描述符偽裝而來的類屬性有更高的優先順序
People.name #恩,呼叫類屬性name,找不到就去找描述符偽裝的類屬性name,觸發了__get__()

People.name='egon' #那賦值呢,直接賦值了一個類屬性,它擁有更高的優先順序,相當於覆蓋了描述符,肯定不會觸發描述符的__set__()
del People.name #同上
'''

類屬性 > 資料描述符

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

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


p1=People('egon',18)

#如果描述符是一個數據描述符(即有__get__又有__set__),那麼p1.name的呼叫與賦值都是觸發描述符的操作,於p1本身無關了,相當於覆蓋了例項的屬性
p1.name='egonnnnnn'
p1.name
print(p1.__dict__)#例項的屬性字典中沒有name,因為name是一個數據描述符,優先順序高於例項屬性,檢視/賦值/刪除都是跟描述符有關,與例項無關了
del p1.name

資料描述符 > 例項屬性

class Foo:
    def func(self):
        print('我胡漢三又回來了')
f1=Foo()
f1.func() #呼叫類的方法,也可以說是呼叫非資料描述符
#函式是一個非資料描述符物件(一切皆物件麼)
print(dir(Foo.func))
print(hasattr(Foo.func,'__set__'))
print(hasattr(Foo.func,'__get__'))
print(hasattr(Foo.func,'__delete__'))
#有人可能會問,描述符不都是類麼,函式怎麼算也應該是一個物件啊,怎麼就是描述符了
#笨蛋哥,描述符是類沒問題,描述符在應用的時候不都是例項化成一個類屬性麼
#函式就是一個由非描述符類例項化得到的物件
#沒錯，字串也一樣


f1.func='這是例項屬性啊'
print(f1.func)

del f1.func #刪掉了非資料
f1.func()

例項屬性 > 非資料描述符

class Foo:
    def __set__(self, instance, value):
        print('set')
    def __get__(self, instance, owner):
        print('get')
class Room:
    name=Foo()
    def __init__(self,name,width,length):
        self.name=name
        self.width=width
        self.length=length


#name是一個數據描述符,因為name=Foo()而Foo實現了get和set方法,因而比例項屬性有更高的優先順序
#對例項的屬性操作,觸發的都是描述符的
r1=Room('廁所',1,1)
r1.name
r1.name='廚房'



class Foo:
    def __get__(self, instance, owner):
        print('get')
class Room:
    name=Foo()
    def __init__(self,name,width,length):
        self.name=name
        self.width=width
        self.length=length


#name是一個非資料描述符,因為name=Foo()而Foo沒有實現set方法,因而比例項屬性有更低的優先順序
#對例項的屬性操作,觸發的都是例項自己的
r1=Room('廁所',1,1)
r1.name
r1.name='廚房'

再次驗證：例項屬性 > 非資料描述符

class Foo:
    def func(self):
        print('我胡漢三又回來了')

    def __getattr__(self, item):
        print('找不到了當然是來找我啦',item)
f1=Foo()

f1.xxxxxxxxxxx

非資料描述符 > 找不到

5，描述符使用

眾所周知，python是弱型別語言，即引數的賦值沒有型別限制，下面我們通過描述符機制來實現型別限制功能

class Str:
    def __init__(self,name):
        self.name=name
    def __get__(self, instance, owner):
        print('get--->',instance,owner)
        return instance.__dict__[self.name]

    def __set__(self, instance, value):
        print('set--->',instance,value)
        instance.__dict__[self.name]=value
    def __delete__(self, instance):
        print('delete--->',instance)
        instance.__dict__.pop(self.name)


class People:
    name=Str('name')
    def __init__(self,name,age,salary):
        self.name=name
        self.age=age
        self.salary=salary

p1=People('egon',18,3231.3)

#呼叫
print(p1.__dict__)
p1.name

#賦值
print(p1.__dict__)
p1.name='egonlin'
print(p1.__dict__)

#刪除
print(p1.__dict__)
del p1.name
print(p1.__dict__)

牛刀小試

class Str:
    def __init__(self,name):
        self.name=name
    def __get__(self, instance, owner):
        print('get--->',instance,owner)
        return instance.__dict__[self.name]

    def __set__(self, instance, value):
        print('set--->',instance,value)
        instance.__dict__[self.name]=value
    def __delete__(self, instance):
        print('delete--->',instance)
        instance.__dict__.pop(self.name)


class People:
    name=Str('name')
    def __init__(self,name,age,salary):
        self.name=name
        self.age=age
        self.salary=salary

#疑問:如果我用類名去操作屬性呢
People.name #報錯,錯誤的根源在於類去操作屬性時,會把None傳給instance

#修訂__get__方法
class Str:
    def __init__(self,name):
        self.name=name
    def __get__(self, instance, owner):
        print('get--->',instance,owner)
        if instance is None:
            return self
        return instance.__dict__[self.name]

    def __set__(self, instance, value):
        print('set--->',instance,value)
        instance.__dict__[self.name]=value
    def __delete__(self, instance):
        print('delete--->',instance)
        instance.__dict__.pop(self.name)


class People:
    name=Str('name')
    def __init__(self,name,age,salary):
        self.name=name
        self.age=age
        self.salary=salary
print(People.name) #完美,解決

拔刀相助

class Str:
    def __init__(self,name,expected_type):
        self.name=name
        self.expected_type=expected_type
    def __get__(self, instance, owner):
        print('get--->',instance,owner)
        if instance is None:
            return self
        return instance.__dict__[self.name]

    def __set__(self, instance, value):
        print('set--->',instance,value)
        if not isinstance(value,self.expected_type): #如果不是期望的型別，則丟擲異常
            raise TypeError('Expected %s' %str(self.expected_type))
        instance.__dict__[self.name]=value
    def __delete__(self, instance):
        print('delete--->',instance)
        instance.__dict__.pop(self.name)


class People:
    name=Str('name',str) #新增型別限制str
    def __init__(self,name,age,salary):
        self.name=name
        self.age=age
        self.salary=salary

p1=People(123,18,3333.3)#傳入的name因不是字串型別而丟擲異常

磨刀霍霍

class Typed:
    def __init__(self,name,expected_type):
        self.name=name
        self.expected_type=expected_type
    def __get__(self, instance, owner):
        print('get--->',instance,owner)
        if instance is None:
            return self
        return instance.__dict__[self.name]

    def __set__(self, instance, value):
        print('set--->',instance,value)
        if not isinstance(value,self.expected_type):
            raise TypeError('Expected %s' %str(self.expected_type))
        instance.__dict__[self.name]=value
    def __delete__(self, instance):
        print('delete--->',instance)
        instance.__dict__.pop(self.name)


class People:
    name=Typed('name',str)
    age=Typed('name',int)
    salary=Typed('name',float)
    def __init__(self,name,age,salary):
        self.name=name
        self.age=age
        self.salary=salary

p1=People(123,18,3333.3)
p1=People('egon','18',3333.3)
p1=People('egon',18,3333)

大刀闊斧

大刀闊斧之後我們已然能實現功能了，但是問題是，如果我們的類有很多屬性，你仍然採用在定義一堆類屬性的方式去實現，low，這時候我需要教你一招：獨孤九劍

def decorate(cls):
    print('類的裝飾器開始執行啦------>')
    return cls

@decorate #無參:People=decorate(People)
class People:
    def __init__(self,name,age,salary):
        self.name=name
        self.age=age
        self.salary=salary

p1=People('egon',18,3333.3)

類的裝飾器：無參

def typeassert(**kwargs):
    def decorate(cls):
        print('類的裝飾器開始執行啦------>',kwargs)
        return cls
    return decorate
@typeassert(name=str,age=int,salary=float) #有參:1.執行typeassert(...)返回結果是decorate,此時引數都傳給kwargs 2.People=decorate(People)
class People:
    def __init__(self,name,age,salary):
        self.name=name
        self.age=age
        self.salary=salary

p1=People('egon',18,3333.3)

類的裝飾器：有參

終極大招

class Typed:
    def __init__(self,name,expected_type):
        self.name=name
        self.expected_type=expected_type
    def __get__(self, instance, owner):
        print('get--->',instance,owner)
        if instance is None:
            return self
        return instance.__dict__[self.name]

    def __set__(self, instance, value):
        print('set--->',instance,value)
        if not isinstance(value,self.expected_type):
            raise TypeError('Expected %s' %str(self.expected_type))
        instance.__dict__[self.name]=value
    def __delete__(self, instance):
        print('delete--->',instance)
        instance.__dict__.pop(self.name)

def typeassert(**kwargs):
    def decorate(cls):
        print('類的裝飾器開始執行啦------>',kwargs)
        for name,expected_type in kwargs.items():
            setattr(cls,name,Typed(name,expected_type))
        return cls
    return decorate
@typeassert(name=str,age=int,salary=float) #有參:1.執行typeassert(...)返回結果是decorate,此時引數都傳給kwargs 2.People=decorate(People)
class People:
    def __init__(self,name,age,salary):
        self.name=name
        self.age=age
        self.salary=salary

print(People.__dict__)
p1=People('egon',18,3333.3)

刀光劍影

6，描述符總結

描述符是可以實現大部分python類特性中的底層魔法,包括@classmethod,@staticmethd,@property甚至是__slots__屬性。

描述父是很多高階庫和框架的重要工具之一,描述符通常是使用到裝飾器或者元類的大型框架中的一個元件。

7，利用描述符原理完成一個自定製@property，實現延遲計算（本質就是把一個函式屬性利用裝飾器原理做成一個描述符：

類的屬性字典中函式名為key，value為描述符類產生的物件）。

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

    @property
    def area(self):
        return self.width * self.length

r1=Room('alex',1,1)
print(r1.area)

@property

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
        return self.func(instance) #此時你應該明白,到底是誰在為你做自動傳遞self的事情

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)

自己做一個@property

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) #先從自己的屬性字典找,找到了,是上次計算的結果,這樣就不用每執行一次都去計算

實現延遲計算功能

#快取不起來了

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:
            value=self.func(instance)
            instance.__dict__[self.func.__name__]=value
            return value
        # return self.func(instance) #此時你應該明白,到底是誰在為你做自動傳遞self的事情
    def __set__(self, instance, value):
        print('hahahahahah')

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

print(Room.__dict__)
r1=Room('alex',1,1)
print(r1.area)
print(r1.area) 
print(r1.area) 
print(r1.area) #快取功能失效,每次都去找描述符了,為何,因為描述符實現了set方法,它由非資料描述符變成了資料描述符,資料描述符比例項屬性有更高的優先順序,因而所有的屬性操作都去找描述符了

一個小的改動，延遲計算的美夢就破碎了

8，利用描述符原理完成一個自定製@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('你是那偷心的賊')

自己做一個@classmethod

9，利用描述符原理完成一個自定製@staticmethod

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)

自己做一個 @staticmethod

七、再看 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

用法二

怎麼用？

class Goods:

    def __init__(self):
        # 原價
        self.original_price = 100
        # 折扣
        self.discount = 0.8

    @property
    def price(self):
        # 實際價格 = 原價 * 折扣
        new_price = self.original_price * self.discount
        return new_price

    @price.setter
    def price(self, value):
        self.original_price = value

    @price.deleter
    def price(self):
        del self.original_price


obj = Goods()
obj.price         # 獲取商品價格
obj.price = 200   # 修改商品原價
print(obj.price)
del obj.price     # 刪除商品原價

案例一

#實現型別檢測功能

#第一關：
class People:
    def __init__(self,name):
        self.name=name

    @property
    def name(self):
        return self.name

# p1=People('alex') #property自動實現了set和get方法屬於資料描述符,比例項屬性優先順序高,所以你這面寫會觸發property內建的set,丟擲異常


#第二關：修訂版

class People:
    def __init__(self,name):
        self.name=name #例項化就觸發property

    @property
    def name(self):
        # return self.name #無限遞迴
        print('get------>')
        return self.DouNiWan

    @name.setter
    def name(self,value):
        print('set------>')
        self.DouNiWan=value

    @name.deleter
    def name(self):
        print('delete------>')
        del self.DouNiWan

p1=People('alex') #self.name實際是存放到self.DouNiWan裡
print(p1.name)
print(p1.name)
print(p1.name)
print(p1.__dict__)

p1.name='egon'
print(p1.__dict__)

del p1.name
print(p1.__dict__)


#第三關:加上型別檢查
class People:
    def __init__(self,name):
        self.name=name #例項化就觸發property

    @property
    def name(self):
        # return self.name #無限遞迴
        print('get------>')
        return self.DouNiWan

    @name.setter
    def name(self,value):
        print('set------>')
        if not isinstance(value,str):
            raise TypeError('必須是字串型別')
        self.DouNiWan=value

    @name.deleter
    def name(self):
        print('delete------>')
        del self.DouNiWan

p1=People('alex') #self.name實際是存放到self.DouNiWan裡
p1.name=1

案例二

八、__setitem__，__getitem__，__delitem__

---

1，用法：

# item系列,就是為了把你的物件模擬成像字典一樣的東西
class Foo:      # 帶__開頭結尾的方法，不要自己去用，python 會自動的去呼叫

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

    def __getitem__(self,item):     # item = "name"
        # print("getitem")
        # print(item)
        return self.__dict__.get(item)

    def __setitem__(self,key,value):
        # print("setitem")
        # print(key,value)
        self.__dict__[key] = value

    def __delitem__(self,key):
        # print("delitem")
        # print(key)
        self.__dict__.pop(key)

obj = Foo("子系")
print(obj.__dict__)     # {'name': '子系'}

# 檢視屬性：
# obj.屬性名
print(obj["name"])     # getitem   name    ,沒有的話會返回一個空值


# 設定屬性
obj.sex = "male"
# obj["sex"] = "male"

print(obj.__dict__)     # {'name': '子系', 'sex': 'male'}
print(obj.sex)          # male


# 刪除屬性
# del obj.name
del obj["name"]

print(obj.__dict__)     # {}

item系列

九、__str__，__repr__，__format_

---

改變物件的字串顯示__str__，__repr__

自定製格式化字串__format__

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
format_dict={
    'nat':'{obj.name}-{obj.addr}-{obj.type}',#學校名-學校地址-學校型別
    'tna':'{obj.type}:{obj.name}:{obj.addr}',#學校型別:學校名:學校地址
    'tan':'{obj.type}/{obj.addr}/{obj.name}',#學校型別/學校地址/學校名
}
class School:
    def __init__(self,name,addr,type):
        self.name=name
        self.addr=addr
        self.type=type

    def __repr__(self):
        return 'School(%s,%s)' %(self.name,self.addr)
    def __str__(self):
        return '(%s,%s)' %(self.name,self.addr)

    def __format__(self, format_spec):
        # if format_spec
        if not format_spec or format_spec not in format_dict:
            format_spec='nat'
        fmt=format_dict[format_spec]
        return fmt.format(obj=self)

s1=School('oldboy1','北京','私立')
print('from repr: ',repr(s1))
print('from str: ',str(s1))
print(s1)

'''
str函式或者print函式--->obj.__str__()
repr或者互動式直譯器--->obj.__repr__()
如果__str__沒有被定義,那麼就會使用__repr__來代替輸出
注意:這倆方法的返回值必須是字串,否則丟擲異常
'''
print(format(s1,'nat'))
print(format(s1,'tna'))
print(format(s1,'tan'))
print(format(s1,'asfdasdffd'))

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))

自定義 format 練習

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'

class A:
    pass

class B(A):
    pass

print(issubclass(B,A)) #B是A的子類,返回True

a1=A()
print(isinstance(a1,A)) #a1是A的例項

issubclass 和 isinstance

十、__slots__

---

1，__slots__ 是什麼：

是一個類變數，變數值可以是列表，元組，或者可迭代物件，也可以是一個字串（意味著所有例項只有一個數據屬性）。

2，引子：

使用點 “.” 來訪問屬性本質就是在訪問類或者物件的 __dict__ 屬性字典（類的字典是共享的，而每個例項是獨立的）。

3，為何使用__slots__：

字典會佔用大量記憶體，如果你有一個屬性很少的類，但是有很多例項，為了節省記憶體可以使用 __slots__ 取代例項的 __dict__ ，當你定義 __slots__ 後，__slots__ 就會為例項使用一種更加緊湊的內部表示。例項通過一個很小的固定大小的陣列來構建，而不是為每個例項定義一個字典，這跟元組或列表很類似。在 __slots__ 中列出的屬性名在內部被對映到這個陣列的指定標上。使用 __slots__ 一個不好的地方就是我們不能再給例項新增新的屬性了，只能使用在 __slots__ 中定義的那些屬性。

4，注意事項：

__slots__ 的很多特性都依賴於普通的基於字典的實現。另外，定義了 __slots__ 後的類不再支援一些普通類特性了，比如多繼承。大多數情況下，你應該只在那些經常被使用到的用作資料結構的類上定義 __slots__ 比如在程式中需要建立某個類的幾百萬個例項物件。

關於 __slots__ 的一個常見誤區是它可以作為一個封裝工具來防止使用者給例項增加新的屬性。

儘管使用 __slots__ 可以達到這樣的目的，但是這個並不是它的初衷。

'''
class Foo:
    __slots__='x'


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

class Bar:
    __slots__=['x','y']
    
n=Bar()
n.x,n.y=1,2
n.z=3#報錯

__slots__ 使用

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

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

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

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

View Code

十一、__next__ 和 __iter__ 實現迭代器協議

---

1，示範：

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
class Foo:
    def __init__(self,x):
        self.x=x

    def __iter__(self):
        return self

    def __next__(self):
        n=self.x
        self.x+=1
        return self.x

f=Foo(3)
for i in f:
    print(i)

簡單示範

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)

class Range:
    def __init__(self,n,stop,step):
        self.n=n
        self.stop=stop
        self.step=step

    def __next__(self):
        if self.n >= self.stop:
            raise StopIteration
        x=self.n
        self.n+=self.step
        return x

    def __iter__(self):
        return self

for i in Range(1,7,3): #
    print(i)

練習：簡單模擬range，加上步長

class Fib:
    def __init__(self):
        self._a=0
        self._b=1

    def __iter__(self):
        return self

    def __next__(self):
        self._a,self._b=self._b,self._a + self._b
        return self._a

f1=Fib()

print(f1.__next__())
print(next(f1))
print(next(f1))

for i in f1:
    if i > 100:
        break
    print('%s ' %i,end='')

斐波那契數列

十二、 __doc__

---

1，它類的描述資訊

class Foo:
    '我是描述資訊'
    pass

print(Foo.__doc__)

class Foo:
    '我是描述資訊'
    pass

class Bar(Foo):
    pass
print(Bar.__doc__) #該屬性無法繼承給子類

該屬性無法被繼承

十三、 __module__ 和 __class__

---

__module__ 表示當前操作的物件在那個模組

__class__ 表示當前操作的物件的類是什麼

#!/usr/bin/env python
# -*- coding:utf-8 -*-

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，即：輸出類

index.py

十四、 __del__

---

析構方法，當物件在記憶體中被釋放時，自動觸發執行。

注：如果產生的物件僅僅只是python程式級別的（使用者級），那麼無需定義__del__,如果產生的物件的同時還會向作業系統發起系統呼叫，即一個物件有使用者級與核心級兩種資源，比如（開啟一個檔案，建立一個數據庫連結），則必須在清除物件的同時回收系統資源，這就用到了__del__。

class Foo:

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

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

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

簡單示範

class Foo:

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

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

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





#為何啊？？？

View Code

典型的應用場景：

建立資料庫類，用該類例項化出資料庫連結物件，物件本身是存放於使用者空間記憶體中，而連結則是由作業系統管理的，存放於核心空間記憶體中

當程式結束時，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上下文管理

十五、 __enter_ 和 __exit__

---

我們知道在操作檔案物件的時候可以這麼寫

with open('a.txt') as f:
　　'程式碼塊'

上述叫做上下文管理協議，即with語句，為了讓一個物件相容with語句，必須在這個物件的類中宣告__enter__和__exit__方法。

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

    def __enter__(self):
        print('出現with語句,物件的__enter__被觸發,有返回值則賦值給as宣告的變數')
        # return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        print('with中程式碼塊執行完畢時執行我啊')


with Open('a.txt') as f:
    print('=====>執行程式碼塊')
    # print(f,f.name)

上下文管理協議

__exit__()中的三個引數分別代表異常型別，異常值和追溯資訊,with語句中程式碼塊出現異常，則with後的程式碼都無法執行。

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

    def __enter__(self):
        print('出現with語句,物件的__enter__被觸發,有返回值則賦值給as宣告的變數')

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('with中程式碼塊執行完畢時執行我啊')
        print(exc_type)
        print(exc_val)
        print(exc_tb)



with Open('a.txt') as f:
    print('=====>執行程式碼塊')
    raise AttributeError('***著火啦,救火啊***')
print('0'*100) #------------------------------->不會執行

View Code

如果__exit()返回值為True,那麼異常會被清空，就好像啥都沒發生一樣，with後的語句正常執行。

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

    def __enter__(self):
        print('出現with語句,物件的__enter__被觸發,有返回值則賦值給as宣告的變數')

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('with中程式碼塊執行完畢時執行我啊')
        print(exc_type)
        print(exc_val)
        print(exc_tb)
        return True



with Open('a.txt') as f:
    print('=====>執行程式碼塊')
    raise AttributeError('***著火啦,救火啊***')
print('0'*100) #------------------------------->會執行

View Code

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__處理

練習：模擬Open

用途或者說好處：

1，使用with語句的目的就是把程式碼塊放入with中執行，with結束後，自動完成清理工作，無須手動干預。

2，在需要管理一些資源比如檔案，網路連線和鎖的程式設計環境中，可以在__exit__中定製自動釋放資源的機制，你無須再去關係這個問題，這將大有用處。

十六、 __call__

---

物件後面加括號，觸發執行。

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

class Foo:
    def __init__(self):
        pass

    def __call__(self, *args, **kwargs):
        print('__call__')

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

View Code