反射實際案例面向物件的雙下方法元類

阿新 • • 發佈：2022-04-12

day29

反射實際案例

反射需要掌握的四個方法

　　hasattr():判斷物件是否含有字串對應的資料或者功能

　　getattr():根據字串獲取對應的變數名或者函式名

　　setattr():根據字串給物件設定鍵值對(名稱空間中的名字）

　　delattr():根據字串刪除物件對應的鍵值對(名稱空間中的名字)

示例

需求：利用面向物件在window系統和linux系統中查詢系統中是否有相關指令

class WinCmd(object):
    def ls(self):
        print('windows系統正在執行ls命令')
    def dir(self):
        print('windows系統正在執行dir命令')
    def cd(self):
        print('windows系統正在執行cd命令')

class LinuxCmd(object):
    def ls(self):
        print('Linux系統正在執行ls命令')
    def dir(self):
        print('Linux系統正在執行dir命令')
    def cd(self):
        print('Linux系統正在執行cd命令')

obj = WinCmd()
obj1 = LinuxCmd()
"""反射提供了一種不需要考慮程式碼的前提下 操作資料和功能"""
def run(obj):
    while True:
        cmd = input('請輸入您的指令>>>:')
        if hasattr 
(obj, cmd):
            func_name = getattr(obj, cmd)
            func_name()
        else:
            print('cmd command not found')
run(obj1)
run(obj)

面向物件的雙下方法

　　面向物件中的雙下方法也有一些人稱之為是魔法方法

　　特點：無需特地呼叫到達某個條件會自動觸發　　

class MyClass(object):
    '''__init__		物件例項化的時候自動觸發'''
    def __init__(self, name):
        self.name = name


    def __str__ 
(self):
        """
        物件被執行列印(print、前端展示)操作的時候自動觸發
            該方法必須返回字串型別的資料
        很多時候用來更加精準的描述物件
        """
        print('我到底什麼時候觸發')
        return '物件:%s'%self.name

    def __del__(self):
        """物件被執行(被動、主動)刪除操作之後自動執行"""
        print("del啥時候執行")
        pass

    def __getattr__ 
(self, item):
        """物件查詢不存在名字的時候自動觸發"""
        print('__getattr__方法', item)
        return '不好意思 沒有%s這個名字'%item
        pass

    def __setattr__(self, key, value):
        """物件在執行新增屬性操作的時候自動觸發>>>obj.變數名=變數值"""
        print('__setattr__方法')
        print(key, value)
        if key == 'gender':
            raise Exception('你沒有資格擁有gender')
        if not key.islower():
            raise Exception('名字只能小寫')
        super().__setattr__(key, value)
        pass

    def __call__(self, *args, **kwargs):
        """物件被加括號呼叫的時候自動觸發"""
        print('__call__方法',args,kwargs)
        return '嘿嘿嘿'

    def __enter__(self):
        """物件被執行with上下文管理語法自動觸發"""
        print('__enter__方法')

    def __exit__(self, exc_type, exc_val, exc_tb):
        """物件被執行with上下文管理語法結束之後自動觸發"""
        print('__exit__方法')

    def __getattribute__(self, item):
        """
        只要物件查詢名字無論名字是否存在都會執行該方法
            如果類中有__getattribute__方法 那麼就不會去執行__getattr__方法
        """
        print('__getattribute__方法', item)

筆試題講解

需求：讓字典具備句點符查詢值的功能

d = {'name':'jason','pwd':123}
print(d['name'])
print(d.get('name'))
# print(d.name)  報錯

# 1.定義一個類繼承字典
class MyDict(dict):
    def __getattr__(self, item):
        return self.get(item)

    def __setattr__(self, key, value):
        self[key] = value
'''要區別是名稱空間的名字還是資料k:v鍵值對'''


obj = MyDict({'name':'jason','age':18})
# 1.具備句點符取v
print(obj.name)
print(obj.age)
# 2.具備句點符設k:v
obj['gender'] = 'male'
obj.pwd = 123  # 給字典名稱空間新增名字  不是資料k:v
print(obj)


class Context:
    def __enter__(self):
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        pass
    def do_something(self):
        pass
with Context() as ctx:
    print(ctx)
    ctx.do_something()

元類簡介

　　元類就是用來例項化產生類的類

print(type(123))  # <class 'int'>
print(type([12, 33, 44]))  # <class 'list'>
print(type({'name':'jason','pwd':123}))  # <class 'dict'>

type檢視的其實是當前物件所屬的類名稱　　

class MyClass(object):
    pass
obj = MyClass()
print(type(obj))
print(type(MyClass))  # <class 'type'>

class Student:
    pass
print(type(Student))  # <class 'type'>

class Teacher(MyClass):
    pass
print(type(Teacher))  # <class 'type'>

我們用class關鍵字定義的所有類都是由內建的元類type例項產生(所有類以及內建類都是type產生的)

產生類的兩種表現形式(本質是一種)

方式1 class關鍵字
class C1(object):
    pass
print(C1)  # <class '__main__.C1'>

方式2 type元類
res = type('C1', (), {})
print(res)  # <class '__main__.C1'>

學習元類的目的

　　元類能夠控制類的建立也就意味著我們可以高度定製類的行為

　　eg:掌握了物品的生產過程就可以在過程中做任何的額外操作

如果你想高度定製類的產生過程

　　　　　　　　　　　　　　　　那麼編寫元類裡面的__init__方法
如果你想高度定製物件的產生過程

　　　　　　　　　　　　　　　　那麼編寫元類裡面的__call__方法

元類的基本使用

　　元類是不能通過繼承的方式直接指定的

　　需要通過關鍵字引數的形式修改

  	class C1(metaclass=MyTypeClass):
    	pass
    
class MyTypeClass(type):
    def __init__(cls, cls_name, cls_bases, cls_dict):
        # print(cls, cls_name, cls_bases, cls_dict)
        if not cls_name.istitle():
            raise Exception("類名的首字母必須大寫")
        super().__init__(cls_name, cls_bases, cls_dict)

class C1(metaclass=MyTypeClass):
    school = '清華大學'

class a(metaclass=MyTypeClass):
    school = '清華大學'

元類進階操作

　　回想__call__方法

　　　　物件加括號會自動執行產生該物件的類裡面的__call__,並且該方法返回什麼物件加括號就會得到什麼

　　推導得出：

　　　　類加括號會執行元類的裡面的__call__該方法返回什麼其實類加括號就會得到什麼

類裡面的__init__方法和元類裡面的__call__方法執行的先後順序

    def __call__(self, *args, **kwargs):
        # 1.會產生一個空物件
        # 2.呼叫類裡面的__init__例項化
        print('__call__ run')  # 重寫__call__
        print(args,kwargs)
        if args:
            raise Exception('必須全部採用關鍵字引數')
        super().__call__(*args, **kwargs)  # 使用原有功能
      


class MyClass(metaclass=MyTypeClass):
    def __init__(self, name):
        print('__init__ run')
        self.name = name

"""強制規定:類在例項化產生物件的時候 物件的獨有資料必須採用關鍵字引數"""
# obj1 = MyClass('jason')  # 報錯
obj2 = MyClass(name='jason')

執行結果: 先執行__call__ 再執行__init__

雙下new方法

__new__用於產生空物件(類) ---->骨架

__init__用於例項化物件(類)-----> 血肉

注意:並不是所有的地方都可以直接呼叫__new__ 該方法過於底層

如果是在元類的__new__裡面可以直接呼叫

class Meta(type):
      def __new__(cls, *args, **kwargs):
          obj = type.__new__(cls,*args,**kwargs)
          return obj

如果是在元類的__call__裡面需要間接呼叫

class Mate(type):
    	def __call__(self, *args, **kwargs):
         obj = object.__new__(self) # 建立一個空物件
         self.__init__(obj,*args,**kwargs) # 讓物件去初始化
         return obj