Python面向?qū)ο缶幊蹋ㄈ?/h1>

 更新時(shí)間：2022年05月30日 09:08:14   作者：springsnow  

本文詳細(xì)講解了Python的面向?qū)ο缶幊?，文中通過示例代碼介紹的非常詳細(xì)。對(duì)大家的學(xué)習(xí)或工作具有一定的參考借鑒價(jià)值，需要的朋友可以參考下

目錄

• 一、isinstance和issubclass
• 二、反射(hasattr和getattr和setattr和delattr)
• 1、反射在類中的使用
• 2、反射在模塊中的使用
• 3、實(shí)例：基于反射機(jī)制模擬web框架路由
• 三、__getattr__、__setattr__和__delattr__和__getattribute__事件
• __getattribute__
• 四、__setitem__和__getitem和__delitem__
• 五、__format__：自定制格式化字符串
• 六、__del__：析構(gòu)方法
• 七、__slots__
• 八、__doc__：返回類的注釋信息
• 九、__call__：會(huì)在調(diào)用對(duì)象時(shí)自動(dòng)觸發(fā)。
• 十、__init__和__new__：類構(gòu)造器
• 十一、__str__和__repr__
• __str__：執(zhí)行str函數(shù)或print函數(shù)觸發(fā)
• __repr__：執(zhí)行repr函數(shù)或者交互式解釋器觸發(fā)
• 十二、__module__和__class__
• 十三、實(shí)現(xiàn)文件上下文管理(__enter__和__exit__)
• 模擬open
• 十四、描述符(__get__和__set__和__delete__)
• 1、使用描述符
• 2、類的裝飾器:無參
• 3、類的裝飾器:有參
• 4、描述符與類裝飾器結(jié)合使用
• 5、利用描述符原理自定制@property
• 6、自定制@classmethod
• 7、自定制@staticmethod
• 十五、元類(metaclass)
• 1、type實(shí)現(xiàn)
• 2、自定義元類控制類
• 3、自定義元類控制類的實(shí)例化
• 4、練習(xí)：使用元類修改屬性為隱藏屬性
• 5、利用元類實(shí)現(xiàn)單例模式

Python面向?qū)ο缶幊蹋ㄒ唬?/a>

Python面向?qū)ο缶幊蹋ǘ?/a>

Python面向?qū)ο缶幊蹋ㄈ?/a>

一、isinstance和issubclass

• type()：不會(huì)認(rèn)為子類實(shí)例是一種父類類型；
• isinstance()：認(rèn)為子類實(shí)例是一種父類類型。
• issubclass()：判斷是否為其子類。

class Foo(object):
    pass


class Bar(Foo):
    pass


print(type(Foo()) == Foo)
# True

print(type(Bar()) == Foo)
# False

# isinstance參數(shù)為對(duì)象和類
print(isinstance(Bar(), Foo))
# True


print(issubclass(Bar, Foo))
# True

print(issubclass(Foo, object))
# True

二、反射(hasattr和getattr和setattr和delattr)

1、反射在類中的使用

反射就是通過字符串來操作類或者對(duì)象的屬性。反射本質(zhì)就是在使用內(nèi)置函數(shù)，其中反射有以下四個(gè)內(nèi)置函數(shù)：

• hasattr：判斷一個(gè)方法是否存在與這個(gè)類中
• getattr：根據(jù)字符串去獲取obj對(duì)象里的對(duì)應(yīng)的方法的內(nèi)存地址，加"()"括號(hào)即可執(zhí)行
• setattr：通過setattr將外部的一個(gè)函數(shù)綁定到實(shí)例中
• delattr：刪除一個(gè)實(shí)例或者類中的方法

class People:
    country = 'China'

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

    def eat(self):
        print('%s is eating' % self.name)


peo1 = People('nick')

print(hasattr(peo1, 'eat'))  # peo1.eat
# True

print(getattr(peo1, 'eat'))  # peo1.eat
# >

print(getattr(peo1, 'xxxxx', None))
# None

setattr(peo1, 'age', 18)  # peo1.age=18
print(peo1.age)
# 18

print(peo1.__dict__)
# {'name': 'egon', 'age': 18}

delattr(peo1, 'name')  # del peo1.name
print(peo1.__dict__)
# {'age': 18}

2、反射在模塊中的使用

動(dòng)態(tài)導(dǎo)入一個(gè)模塊__import__，并且動(dòng)態(tài)輸入函數(shù)名然后執(zhí)行相應(yīng)功能。

注意：getattr,hasattr,setattr,delattr對(duì)模塊的修改都在內(nèi)存中進(jìn)行，并不會(huì)影響文件中真實(shí)內(nèi)容。

# dynamic.py
imp = input("請(qǐng)輸入模塊:")
commons = __import__(imp)  # 等價(jià)于import imp
# commons = __import__(imp, fromlist=True)  # 模塊名可能不是在本級(jí)目錄中存放著,改用這種方式就能導(dǎo)入成功
inp_func = input("請(qǐng)輸入要執(zhí)行的函數(shù)：")
f = getattr(commons, inp_func, None)  # 作用:從導(dǎo)入模塊中找到你需要調(diào)用的函數(shù)inp_func,然后返回一個(gè)該函數(shù)的引用.沒有找到就煩會(huì)None
f()  # 執(zhí)行該函數(shù)

r = hasattr(commons, 'age')  # 判斷某個(gè)函數(shù)或者變量是否存在
print(r)

setattr(commons, 'age', 18)  # 給commons模塊增加一個(gè)全局變量age = 18，創(chuàng)建成功返回none

setattr(commons, 'age', lambda a: a + 1)  # 給模塊添加一個(gè)函數(shù)

delattr(commons, 'age')  # 刪除模塊中某個(gè)變量或者函數(shù)

3、實(shí)例：基于反射機(jī)制模擬web框架路由

需求：比如我們輸入<www.xxx.com/commons/f1> ，返回f1的結(jié)果。

# 動(dòng)態(tài)導(dǎo)入模塊，并執(zhí)行其中函數(shù)
url = input("url: ")

target_host,target_module, target_func = url.split('/')
m = __import__('aaa.' + target_module, fromlist=True)

inp = url.split("/")[-1]  # 分割url,并取出url最后一個(gè)字符串
if hasattr(m, inp):  # 判斷在commons模塊中是否存在inp這個(gè)字符串
    inp= getattr(m, inp)  # 獲取inp的引用
    inp()  # 執(zhí)行
else:
    print("404")

三、__getattr__、__setattr__和__delattr__和__getattribute__事件

• __getattr__：只有在使用點(diǎn)調(diào)用屬性且屬性不存在的時(shí)候才會(huì)觸發(fā)。比較有用
• __delattr__：刪除屬性的時(shí)候會(huì)觸發(fā)
• __setattr__：添加/修改屬性會(huì)觸發(fā)它的執(zhí)行
  當(dāng)你自己寫__getattr__、__delattr__、__setattr__方法，系統(tǒng)會(huì)調(diào)用你寫的方法，如果沒寫，系統(tǒng)調(diào)用默認(rèn)

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  # 應(yīng)該使用它

    def __delattr__(self, item):
        print('----> from delattr')
        # del self.item  # 無限遞歸了
        self.__dict__.pop(item)


f1 = Foo(10)
# ----> from setattr
print(f1.__dict__ )  # 因?yàn)槟阒貙懥薩_setattr__，凡是賦值操作都會(huì)觸發(fā)它的運(yùn)行，你啥都沒寫，就是根本沒賦值。除非你直接操作屬性字典，否則永遠(yuǎn)無法賦值
# {}

f1.z = 3
# ----> from setattr
print(f1.__dict__)
# {}

f1.__dict__['a'] = 3  # 我們可以直接修改屬性字典，來完成添加/修改屬性的操作（不會(huì)觸發(fā)__setattr__）
del f1.a
# ----> from delattr
 
print(f1.__dict__)
# {}

__getattribute__

查找屬性無論是否存在，都會(huì)執(zhí)行。

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

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


f1 = Foo(10)

f1.x
# 不管是否存在，我都會(huì)執(zhí)行

f1.xxxxxx
# 不管是否存在，我都會(huì)執(zhí)行

當(dāng)__getattribute__與__getattr__同時(shí)存在，只會(huì)執(zhí)行__getattrbute__，除非__getattribute__在執(zhí)行過程中拋出異常AttributeError

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

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

    def __getattribute__(self, item):
        print('不管是否存在,我都會(huì)執(zhí)行')
        raise AttributeError('哈哈')


f1 = Foo(10)

f1.x
# 不管是否存在,我都會(huì)執(zhí)行
# 執(zhí)行的是我

f1.xxxxxx
# 不管是否存在,我都會(huì)執(zhí)行
# 執(zhí)行的是我

四、__setitem__和__getitem和__delitem__

• __setitem__:中括號(hào)賦值時(shí)觸發(fā)
• __getitem__:中括號(hào)取值時(shí)觸發(fā)
• __delitem__：中括號(hào)刪除時(shí)觸發(fā)
• __delattr__：.刪除時(shí)觸發(fā)

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

    def __getitem__(self, item):
        print('getitem執(zhí)行', self.__dict__[item])

    def __setitem__(self, key, value):
        print('setitem執(zhí)行')
        self.__dict__[key] = value

    def __delitem__(self, key):
        print('del obj[key]時(shí)，delitem執(zhí)行')
        self.__dict__.pop(key)

    def __delattr__(self, item):
        print('del obj.key時(shí)，delattr執(zhí)行')
        self.__dict__.pop(item)


f1 = Foo('sb')

f1['age'] = 18
# setitem執(zhí)行

f1['age1'] = 19
# setitem執(zhí)行

f1['age']
# getitem執(zhí)行 18

f1['name'] = 'tank'
# setitem執(zhí)行

del f1.age1
# del obj.key時(shí)，delattr執(zhí)行

del f1['age']
# del obj[key]時(shí)，delitem執(zhí)行

print(f1.__dict__)
# {'name': 'tank'}

五、__format__：自定制格式化字符串

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):
        # 默認(rèn)打印ymd的{0.year}:{0.month}:{0.day}格式
        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))
# 2016:12:29

print('{:mdy}'.format(d1))
# 12-29-2016

六、__del__：析構(gòu)方法

會(huì)在對(duì)象被刪除之前自動(dòng)觸發(fā)

class People:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.f = open('test.txt', 'w', encoding='utf-8')

    def __del__(self):
        print('run======>')
        # 做回收系統(tǒng)資源相關(guān)的事情
        self.f.close()


obj = People('egon', 18)

del obj  # del obj會(huì)間接刪除f的內(nèi)存占用，但是還需要自定制__del__刪除文件的系統(tǒng)占用
# run=-====>

七、__slots__

使用點(diǎn)來訪問屬性本質(zhì)就是在訪問類或者對(duì)象的__dict__屬性字典(類的字典是共享的，而每個(gè)實(shí)例的是獨(dú)立的)。

__slots__是一個(gè)類變量，變量值可以是列表，元祖，或者可迭代對(duì)象，也可以是一個(gè)字符串(意味著所有實(shí)例只有一個(gè)數(shù)據(jù)屬性)

字典會(huì)占用大量內(nèi)存，如果你有一個(gè)屬性很少的類，但是有很多實(shí)例，為了節(jié)省內(nèi)存可以使用__slots__取代實(shí)例的__dict__。

class Foo:
    __slots__ = 'x'


f1 = Foo()
f1.x = 1
f1.y = 2  # 報(bào)錯(cuò)
print(f1.__slots__ )  # f1不再有__dict__

當(dāng)你定義__slots__后，__slots__就會(huì)為實(shí)例使用一種更加緊湊的內(nèi)部表示。使用__slots__后不能再給實(shí)例添加新的屬性了，只能使用在__slots__中定義的那些屬性名。

注意：__slots__的很多特性都依賴于普通的基于字典的實(shí)現(xiàn)。另外，定義了__slots__后的類不再支持一些普通類特性了，比如多繼承。

大多數(shù)情況下，你應(yīng)該只在那些經(jīng)常被使用到的用作數(shù)據(jù)結(jié)構(gòu)的類上定義__slots__比如在程序中需要?jiǎng)?chuàng)建某個(gè)類的幾百萬個(gè)實(shí)例對(duì)象 。

class Bar:
    __slots__ = ['x', 'y']


n = Bar()
n.x, n.y = 1, 2
n.z = 3  # 報(bào)錯(cuò)

八、__doc__：返回類的注釋信息

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


print(Foo.__doc__)
# 我是描述信息

該屬性無法被繼承

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


class Bar(Foo):
    pass


print(Bar.__doc__)  # 該屬性無法繼承給子類
# None

九、__call__：會(huì)在調(diào)用對(duì)象時(shí)自動(dòng)觸發(fā)。

構(gòu)造方法的執(zhí)行是由創(chuàng)建對(duì)象觸發(fā)的，即：對(duì)象 = 類名() ；而對(duì)于 __call__ 方法的執(zhí)行是由對(duì)象后加括號(hào)觸發(fā)的，即：對(duì)象() 或者 類()()

class Foo:
    def __init__(self):
        print('__init__觸發(fā)了')

    def __call__(self, *args, **kwargs):
        print('__call__觸發(fā)了')


obj = Foo()  # 執(zhí)行 __init__
# __init__觸發(fā)了

obj()  # 執(zhí)行 __call__
# __call__

十、__init__和__new__：類構(gòu)造器

__new__方法的第一個(gè)參數(shù)是這個(gè)類，而其余的參數(shù)會(huì)在調(diào)用成功后全部傳遞給__init__方法初始化。

__new__方法（第一個(gè)執(zhí)行）先于__init__方法執(zhí)行：

class A:
    pass


class B(A):
    def __new__(cls):
        print("__new__方法被執(zhí)行")
        return super().__new__(cls)

    def __init__(self):
        print("__init__方法被執(zhí)行")


b = B()

# __new__方法被執(zhí)行
# __init__方法被執(zhí)行

絕大多數(shù)情況下，我們都不需要自己重寫__new__方法，但在當(dāng)繼承一個(gè)不可變的類型（例如str類,int類等）時(shí)，它的特性就尤顯重要了。我們舉下面這個(gè)例子：

# 1、使用init的情況：
class CapStr1(str):
    def __init__(self, string):
        string = string.upper()


a = CapStr1("I love China!")
print(a)
# I love China!   無變化 ?。。。。。?！



# 2、使用__new__的情況
class CapStr2(str):
    def __new__(cls, string):
        string = string.upper()
        return super().__new__(cls, string)


a = CapStr2("I love China!")
print(a)
# I LOVE CHINA!

十一、__str__和__repr__

__str__：執(zhí)行str函數(shù)或print函數(shù)觸發(fā)

class Foo:
    def __init__(self, name, age):
        """對(duì)象實(shí)例化的時(shí)候自動(dòng)觸發(fā)"""
        self.name = name
        self.age = age

    def __str__(self):
        print('打印的時(shí)候自動(dòng)觸發(fā)，但是其實(shí)不需要print即可打印')
        return f'{self.name}:{self.age}'  # 如果不返回字符串類型，則會(huì)報(bào)錯(cuò)


obj = Foo('nick', 18)
print(obj)  # obj.__str__() # 打印的時(shí)候就是在打印返回值
# 打印的時(shí)候自動(dòng)觸發(fā)，但是其實(shí)不需要print即可打印
# nick:18

__repr__：執(zhí)行repr函數(shù)或者交互式解釋器觸發(fā)

• 如果__str__沒有被定義，那么就會(huì)使用__repr__來代替輸出。
• 注意：這倆方法的返回值必須是字符串，否則拋出異常。

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)


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

print('from str: ', str(s1))
# from str:  (oldboy1,北京)

print(s1)
# (oldboy1,北京)

s1  # jupyter屬于交互式
# School(oldboy1,北京)

十二、__module__和__class__

• __module__ 表示當(dāng)前操作的對(duì)象在那個(gè)模塊
• __class__表示當(dāng)前操作的對(duì)象的類是什么

# lib/aa.py
class C:
    def __init__(self):
        self.name = 'SB'


# index.py
from lib.aa import C

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

十三、實(shí)現(xiàn)文件上下文管理(__enter__和__exit__)

with語句，即上下文管理協(xié)議，為了讓一個(gè)對(duì)象兼容with語句，必須在這個(gè)對(duì)象的類中聲明__enter__和__exit__方法。

• 使用with語句的目的就是把代碼塊放入with中執(zhí)行，with結(jié)束后，自動(dòng)完成清理工作，無須手動(dòng)干預(yù)
• 在需要管理一些資源比如文件，網(wǎng)絡(luò)連接和鎖的編程環(huán)境中，可以在__exit__中定制自動(dòng)釋放資源的機(jī)制，你無須再去關(guān)系這個(gè)問題，這將大有用處。

__exit__()中的三個(gè)參數(shù)分別代表異常類型，異常值和追溯信息。with語句中代碼塊出現(xiàn)異常，則with后的代碼都無法執(zhí)行。

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

    def __enter__(self):
        print('出現(xiàn)with語句，對(duì)象的__enter__被觸發(fā)，有返回值則賦值給as聲明的變量')

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('with中代碼塊執(zhí)行完畢時(shí)執(zhí)行我啊')
        print(exc_type)
        print(exc_val)
        print(exc_tb)


try:
    with Open('a.txt') as f:
        print('=====>執(zhí)行代碼塊')
        raise AttributeError('***著火啦，救火啊***')
except Exception as e:
    print(e)

# 出現(xiàn)with語句，對(duì)象的__enter__被觸發(fā)，有返回值則賦值給as聲明的變量
# =====>執(zhí)行代碼塊
# with中代碼塊執(zhí)行完畢時(shí)執(zhí)行我啊
# <class 'AttributeError'>
# ***著火啦，救火啊***
#
# ***著火啦，救火啊***

如果__exit()返回值為True,那么異常會(huì)被清空，就好像啥都沒發(fā)生一樣，with后的語句正常執(zhí)行。

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

    def __enter__(self):
        print('出現(xiàn)with語句，對(duì)象的__enter__被觸發(fā)，有返回值則賦值給as聲明的變量')

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


with Open('a.txt') as f:
    print('=====>執(zhí)行代碼塊')
    raise AttributeError('***著火啦，救火啊***')
print('0' * 100)  # ------------------------------->會(huì)執(zhí)行

# 出現(xiàn)with語句，對(duì)象的__enter__被觸發(fā)，有返回值則賦值給as聲明的變量
# =====>執(zhí)行代碼塊
# with中代碼塊執(zhí)行完畢時(shí)執(zhí)行我啊
# <class 'AttributeError'>
# ***著火啦，救火啊***
#
# 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

#

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

# <_io.TextIOWrapper name='a.txt' mode='w' encoding='utf-8'>

十四、描述符(__get__和__set__和__delete__)

描述符是可以實(shí)現(xiàn)大部分python類特性中的底層魔法，包括@classmethod，@staticmethd，@property甚至是__slots__屬性。

描述符是很多高級(jí)庫和框架的重要工具之一，描述符通常是使用到裝飾器或者元類的大型框架中的一個(gè)組件。

描述符本質(zhì)就是一個(gè)新式類，在這個(gè)新式類中，至少實(shí)現(xiàn)了__get__()，__set__()，__delete__()中的一個(gè)，這也被稱為描述符協(xié)議

• __get__()：調(diào)用一個(gè)屬性時(shí)，觸發(fā)
• __set__()：為一個(gè)屬性賦值時(shí)，觸發(fā)
• __delete__()：采用del刪除屬性時(shí)，觸發(fā)

描述符的作用是用來代理另外一個(gè)類的屬性的。包含這三個(gè)方法的新式類稱為描述符，由這個(gè)類產(chǎn)生的實(shí)例進(jìn)行屬性的調(diào)用/賦值/刪除，并不會(huì)觸發(fā)這三個(gè)方法

class Foo:
    def __get__(self, instance, owner):
        print('觸發(fā)get')

    def __set__(self, instance, value):
        print('觸發(fā)set')

    def __delete__(self, instance):
        print('觸發(fā)delete')


f1 = Foo()
f1.name = 'nick'
f1.name
del f1.name
#無任何輸出結(jié)果?。。?/pre>

必須把描述符定義成這個(gè)類的類屬性，不能定義到構(gòu)造函數(shù)中。

class ST:
    """描述符Str"""

    def __get__(self, instance, owner):
        print('Str調(diào)用')

    def __set__(self, instance, value):
        print('Str設(shè)置...')

    def __delete__(self, instance):
        print('Str刪除...')


class IN:
    """描述符Int"""

    def __get__(self, instance, owner):
        print('Int調(diào)用')

    def __set__(self, instance, value):
        print('Int設(shè)置...')

    def __delete__(self, instance):
        print('Int刪除...')


class People:
    name = ST()
    age = IN()

    def __init__(self, name, age):  # name被ST類代理，age被IN類代理
        self.name = name
        self.age = age


p1 = People('alex', 18)
# Str設(shè)置...
# Int設(shè)置...

p1.name  # Str調(diào)用
p1.name = 'nick'  # Str設(shè)置...
del p1.name  # Str刪除...

p1.age  # Int調(diào)用
p1.age = 18  # Int設(shè)置...
del p1.age  # Int刪除...

print(p1.__dict__)  # {}
print(People.__dict__)
# {'__module__': '__main__', 'name': <__main__.ST object at 0x0000000002167490>, 'age': <__main__.IN object at 0x000000000234A700>, '__init__': , '__dict__': <attribute '__dict__' of 'People' objects>, '__weakref__': <attribute '__weakref__' of 'People' objects>, '__doc__': None}

print(type(p1) == People)  # True
print(type(p1).__dict__ == People.__dict__)  # True

1、使用描述符

眾所周知，python是弱類型語言，即參數(shù)的賦值沒有類型限制，下面我們通過描述符機(jī)制來實(shí)現(xiàn)類型限制功能。

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


try:
    p1 = People(123, 18, 3333.3)
except Exception as e:
    print(e)
# set---> <__main__.People object at 0x1082c7908> 123
# Expected <class 'str'>

try:
    p1 = People('nick', '18', 3333.3)
except Exception as e:
    print(e)
# set---> <__main__.People object at 0x1078dd438> nick
# set---> <__main__.People object at 0x1078dd438> 18
# Expected <class 'int'>

p1 = People('nick', 18, 3333.3)
# set---> <__main__.People object at 0x1081b3da0> nick
# set---> <__main__.People object at 0x1081b3da0> 18
# set---> <__main__.People object at 0x1081b3da0> 3333.3

2、類的裝飾器:無參

def decorate(cls):
    print('類的裝飾器開始運(yùn)行啦------>')
    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('nick', 18, 3333.3)

# 類的裝飾器開始運(yùn)行啦------>

3、類的裝飾器:有參

def typeassert(**kwargs):
    def decorate(cls):
        print('類的裝飾器開始運(yùn)行啦------>', kwargs)
        return cls

    return decorate


@typeassert( name=str, age=int, salary=float)  # 有參：1.運(yùn)行typeassert(...)返回結(jié)果是decorate，此時(shí)參數(shù)都傳給kwargs 2.People=decorate(People)
class People:
    def __init__(self, name, age, salary):
        self.name = name
        self.age = age
        self.salary = salary


p1 = People('nick', 18, 3333.3)
# 類的裝飾器開始運(yùn)行啦------> {'name': <class 'str'>, 'age': <class 'int'>, 'salary': <class 'float'>}

4、描述符與類裝飾器結(jié)合使用

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('類的裝飾器開始運(yùn)行啦------>', 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.運(yùn)行typeassert(...)返回結(jié)果是decorate，此時(shí)參數(shù)都傳給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__)
# 類的裝飾器開始運(yùn)行啦------> {'name': <class 'str'>, 'age': <class 'int'>, 'salary': <class 'float'>}
# {'__module__': '__main__', '__init__': , '__dict__': <attribute '__dict__' of 'People' objects>, '__weakref__': <attribute '__weakref__' of 'People' objects>, '__doc__': None, 'name': <__main__.Typed object at 0x000000000238F8B0>, 'age': <__main__.Typed object at 0x000000000238FF40>, 'salary': <__main__.Typed object at 0x000000000238FFA0>}

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


# set---> <__main__.People object at 0x0000000001E07490> nick
# set---> <__main__.People object at 0x0000000001E07490> 18
# set---> <__main__.People object at 0x0000000001E07490> 3333.3

5、利用描述符原理自定制@property

實(shí)現(xiàn)延遲計(jì)算（本質(zhì)就是把一個(gè)函數(shù)屬性利用裝飾器原理做成一個(gè)描述符：類的屬性字典中函數(shù)名為key，value為描述符類產(chǎn)生的對(duì)象）

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

    def __get__(self, instance, owner):
        print('這是我們自己定制的靜態(tài)屬性，r1.area實(shí)際是要執(zhí)行r1.area()')
        if instance is None:
            return self
        else:
            print('--->')
            value = self.func(instance)
            setattr(instance, self.func.__name__, value)  # 計(jì)算一次就緩存到實(shí)例的屬性字典中
            return value


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

    @Lazyproperty  # area=Lazyproperty(area) 相當(dāng)于'定義了一個(gè)類屬性,即描述符'
    def area(self):
        return self.width * self.length


r1 = Room('alex', 1, 2)
print(r1.area)  # 先從自己的屬性字典找,沒有再去類的中找,然后出發(fā)了area的__get__方法

# 這是我們自己定制的靜態(tài)屬性，r1.area實(shí)際是要執(zhí)行r1.area()
# --->
# 2

print(r1.area)  # 先從自己的屬性字典找,找到了,是上次計(jì)算的結(jié)果,這樣就不用每執(zhí)行一次都去計(jì)算
# 2

6、自定制@classmethod

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

    def __get__(self, instance, owner):  # 類來調(diào)用,instance為None,owner為類本身,實(shí)例來調(diào)用,instance為實(shí)例,owner為類本身,
        def feedback(*args, **kwargs):
            print('在這里可以加功能啊...')
            return self.func(owner, *args, **kwargs)

        return feedback


class People:
    name = 'nick'

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


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

p1 = People()
# 在這里可以加功能啊...
# 你好啊,帥哥 nick 你是那偷心的賊

p1.say_hi('你是那偷心的賊')
# 在這里可以加功能啊...
# 你好啊,帥哥 nick 你是那偷心的賊

7、自定制@staticmethod

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

    def __get__(self, instance, owner):  # 類來調(diào)用，instance為None，owner為類本身，實(shí)例來調(diào)用，instance為實(shí)例，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)
# 在這里可以加功能啊...
# ------> 1 2 3

p1 = People()
p1.say_hi(4, 5, 6)
# 在這里可以加功能啊...
# ------> 4 5 6

十五、元類(metaclass)

元類:負(fù)責(zé)產(chǎn)生該對(duì)象的類稱之為元類，即元類可以簡稱為類的類

用class關(guān)鍵字創(chuàng)建一個(gè)類，用的默認(rèn)的元類type，因此以前說不要用type作為類別判斷

class People:  # People=type(...)
    country = 'China'

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

    def eat(self):
        print('%s is eating' % self.name)

print(type(People))
<class 'type'>

1、type實(shí)現(xiàn)

• 創(chuàng)建類的3個(gè)要素：類名，基類，類的名稱空間
• People = type(類名，基類，類的名稱空間)

class_name = 'People'  # 類名
class_bases = (object,)  # 基類

class_dic = {}  # 類的名稱空間
class_body = """
country='China'
def __init__(self,name,age):
    self.name=name
    self.age=age
def eat(self):
    print('%s is eating' %self.name)
"""

exec(class_body, {}, class_dic, )  #執(zhí)行class_body中的代碼，然后把產(chǎn)生的名字丟入class_dic字典中

print(class_name)  # People
print(class_bases)  # (<class 'object'>,)
print(class_dic)  # 類的名稱空間
# {'country': 'China', '__init__': , 'eat': }


People1 = type(class_name, class_bases, class_dic)
print(People1)  # <class '__main__.People'>

obj1 = People1(1, 2)
obj1.eat()  # 1 is eating

2、自定義元類控制類

自定義元類控制類的產(chǎn)生過程，類的產(chǎn)生過程其實(shí)就是元類的調(diào)用過程。

分析用class自定義類的運(yùn)行原理（而非元類的的運(yùn)行原理）：

• 拿到一個(gè)字符串格式的類名class_name='People'

• 拿到一個(gè)類的基類們class_bases=(obejct,)

• 執(zhí)行類體代碼，拿到一個(gè)類的名稱空間class_dic={...}

• 調(diào)用People=type(class_name,class_bases,class_dic)

class Mymeta(type):  # 只有繼承了type類才能稱之為一個(gè)元類，否則就是一個(gè)普通的自定義類
    def __init__(self, class_name, class_bases, class_dic):
        print('self:', self)  # 現(xiàn)在是People
        print('class_name:', class_name)
        print('class_bases:', class_bases)
        print('class_dic:', class_dic)
        super(Mymeta, self).__init__(class_name, class_bases, class_dic)  # 重用父類type的功能


class People(object, metaclass=Mymeta):  # People=Mymeta(類名,基類們,類的名稱空間)
    country = 'China'

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

    def eat(self):
        print('%s is eating' % self.name)

# self: <class '__main__.People'>
# class_name: People
# class_bases: (<class 'object'>,)
# class_dic: {'__module__': '__main__', '__qualname__': 'People', 'country': 'China', '__init__': , 'eat': }

應(yīng)用：我們可以控制類必須有文檔。

class Mymeta(type):  # 只有繼承了type類才能稱之為一個(gè)元類，否則就是一個(gè)普通的自定義類
    def __init__(self, class_name, class_bases, class_dic):
        if class_dic.get('__doc__') is None or len(
                class_dic.get('__doc__').strip()) == 0:
            raise TypeError('類中必須有文檔注釋，并且文檔注釋不能為空')
        if not class_name.istitle():
            raise TypeError('類名首字母必須大寫')
        super(Mymeta, self).__init__(class_name, class_bases,   class_dic)  # 重用父類的功能


try:

    class People(object, metaclass=Mymeta ):  # People  = Mymeta('People',(object,),{....})
        #     """這是People類"""
        country = 'China'

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

        def eat(self):
            print('%s is eating' % self.name)
except Exception as e:
    print(e)
# 類中必須有文檔注釋，并且文檔注釋不能為空

3、自定義元類控制類的實(shí)例化

類的調(diào)用，即類實(shí)例化就是元類的調(diào)用過程，可以通過元類Mymeta的__call__方法控制。

繼承的查找順序:子類->Class –>object–> Mymeta->type

class Mymeta(type):
    def __call__(self, *args, **kwargs):
        print(self)  # self是People
        print(args)  # args = ('nick',)
        print(kwargs)  # kwargs = {'age':18}
        # return 123
        # 1. 先造出一個(gè)People的空對(duì)象，申請(qǐng)內(nèi)存空間
        # __new__方法接受的參數(shù)雖然也是和__init__一樣，但__init__是在類實(shí)例創(chuàng)建之后調(diào)用，而 __new__方法正是創(chuàng)建這個(gè)類實(shí)例的方法。
        obj = self.__new__(self)  # 雖然和下面同樣是People，但是People沒有，找到的__new__是父類的
        # 2. 為該對(duì)空對(duì)象初始化獨(dú)有的屬性
        self.__init__(obj, *args, **kwargs)
        # 3. 返回一個(gè)初始化好的對(duì)象
        return obj


class People(object, metaclass=Mymeta):  # People = Mymeta()，People()則會(huì)觸發(fā)__call__
    country = 'China'

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

    def eat(self):
        print('%s is eating' % self.name)


#     在調(diào)用Mymeta的__call__的時(shí)候，首先會(huì)找自己（如下函數(shù)）的，自己的沒有才會(huì)找父類的
#     def __new__(cls, *args, **kwargs):
#         # print(cls)  # cls是People
#         # cls.__new__(cls) # 錯(cuò)誤，無限死循環(huán)，自己找自己的，會(huì)無限遞歸
#         obj = super(People, cls).__new__(cls)  # 使用父類的，則是去父類中找__new__
#         return obj

obj = People('nick', age=18)
# <class '__main__.People'>
# ('nick',)
# {'age': 18}

print(obj.__dict__)
# {'name': 'nick', 'age': 18}

4、練習(xí)：使用元類修改屬性為隱藏屬性

class Mymeta(type):
    def __init__(self, class_name, class_bases, class_dic):
        # 加上邏輯，控制類Foo的創(chuàng)建
        super(Mymeta, self).__init__(class_name, class_bases, class_dic)

    def __call__(self, *args, **kwargs):
        # 加上邏輯，控制Foo的調(diào)用過程，即Foo對(duì)象的產(chǎn)生過程
        obj = self.__new__(self)
        self.__init__(obj, *args, **kwargs)
        # 修改屬性為隱藏屬性
        obj.__dict__ = {
            '_%s__%s' % (self.__name__, k): v
            for k, v in obj.__dict__.items()
        }

        return obj


class Foo(object, metaclass=Mymeta):  # Foo = Mymeta(...)
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex


obj = Foo('nick', 18, 'male')
print(obj.age)  # 'Foo' object has no attribute 'age'
print(obj.__dict__)
# {'_Foo__name': 'egon', '_Foo__age': 18, '_Foo__sex': 'male'}

5、利用元類實(shí)現(xiàn)單例模式

NAME = 'nick'
AGE = 18

class Mymeta(type):
    def __init__(self,class_name,class_bases,class_dict):
        super().__init__(class_name,class_bases,class_dict)
        self.__instance = self(NAME,AGE)
     
    def __call__(self,*args,**kwargs):
        
        if len(args) == 0 and len(kwargs) == 0:
return self.__instance
        
        obj = object.__new__(self)
        self.__init__(obj,*args,**kwargs)
        
        return obj
    
class People(metaclass=Mymeta):
    def __init__(self,name,age):
        self.name = name
        self.age = age
        
peo1 = People()
peo2 = People()

到此這篇關(guān)于Python面向?qū)ο缶幊痰奈恼戮徒榻B到這了。希望對(duì)大家的學(xué)習(xí)有所幫助，也希望大家多多支持腳本之家。

您可能感興趣的文章:

• Python面向?qū)ο缶幊蹋ǘ?/a>
• Python面向?qū)ο缶幊蹋ㄒ唬?/a>
• python?面向?qū)ο箝_發(fā)及基本特征
• Python學(xué)習(xí)之面向函數(shù)轉(zhuǎn)面向?qū)ο笤斀?/a>
• python面向?qū)ο缶幊淘O(shè)計(jì)原則之單一職責(zé)原則詳解
• Python學(xué)習(xí)之面向?qū)ο缶幊淘斀?/a>
• Python面向?qū)ο笾械姆庋b詳情
• Python基礎(chǔ)之面向?qū)ο筮M(jìn)階詳解
• Python超細(xì)致探究面向?qū)ο?/a>

• Python
• 面向?qū)ο?/a>
• 編程

相關(guān)文章

• 

  關(guān)于Python數(shù)據(jù)結(jié)構(gòu)中字典的心得

  給大家詳細(xì)簡介了Python數(shù)據(jù)結(jié)構(gòu)中字典的方法和使用心得，學(xué)習(xí)一下吧 ，有助于你更好的理解Python數(shù)據(jù)結(jié)構(gòu)。

  2017-12-12
• 

  python讀寫LMDB文件的方法

  這篇文章主要為大家詳細(xì)介紹了python讀寫LMDB文件的方法，具有一定的參考價(jià)值，感興趣的小伙伴們可以參考一下

  2018-07-07
• 

  python筆記之使用fillna()填充缺失值

  這篇文章主要介紹了python筆記之使用fillna()填充缺失值方式，具有很好的參考價(jià)值，希望對(duì)大家有所幫助。如有錯(cuò)誤或未考慮完全的地方，望不吝賜教

  2022-07-07
• 

  python跨文件使用全局變量的實(shí)現(xiàn)

  本文主要介紹了python跨文件使用全局變量的實(shí)現(xiàn)，文中通過示例代碼介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧

  2023-03-03
• 

  Python中裝飾器的一個(gè)妙用

  這篇文章主要介紹了Python中裝飾器的一個(gè)妙用,本文是在寫一個(gè)爬蟲程序時(shí)總結(jié)而來,實(shí)現(xiàn)定義一個(gè)裝飾器，如果之前取到數(shù)據(jù)，就直接取cache的數(shù)據(jù),如果之前沒有取到,那么就從網(wǎng)站拉取,并且存入cache中,需要的朋友可以參考下

  2015-02-02
• 

  Python語法垃圾回收機(jī)制原理解析

  這篇文章主要介紹了Python語法垃圾回收機(jī)制原理解析,文中通過示例代碼介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值,需要的朋友可以參考下

  2020-03-03
• 

  Python實(shí)現(xiàn)從PPT中導(dǎo)出高分辨率圖片

  這篇文章主要為大家分享了一個(gè)實(shí)用腳本——如何利用Python實(shí)現(xiàn)從PPT中導(dǎo)出高分辨率(高 dpi)的圖片，文中的示例代碼講解詳細(xì)，感興趣的可以了解一下

  2023-05-05
• 

  python實(shí)現(xiàn)文本進(jìn)度條 程序進(jìn)度條 加載進(jìn)度條 單行刷新功能

  這篇文章主要介紹了python實(shí)現(xiàn)文本進(jìn)度條 程序進(jìn)度條 加載進(jìn)度條 單行刷新功能，本文通過實(shí)例代碼給大家介紹的非常詳細(xì)，具有一定的參考借鑒價(jià)值,需要的朋友可以參考下

  2019-07-07
• 

  python中如何使用函數(shù)改變list

  這篇文章主要介紹了python中如何使用函數(shù)改變list，具有很好的參考價(jià)值，希望對(duì)大家有所幫助。如有錯(cuò)誤或未考慮完全的地方，望不吝賜教

  2022-09-09
• 

  Python下應(yīng)用opencv 實(shí)現(xiàn)人臉檢測(cè)功能

  OpenCV是如今最流行的計(jì)算機(jī)視覺庫，今天我們通過本文給大家分享Python下應(yīng)用opencv 實(shí)現(xiàn)人臉檢測(cè)功能，感興趣的朋友跟隨小編一起看看吧

  2019-10-10

最新評(píng)論