今日作業

  編寫元類規定物件的所有資料值轉大寫
    	eg:
        	obj.name = 'jason'
          print(obj.name)  # JASON

  class MyTypeClass(type):
      def __call__(self, *args, **kwargs):
          args1 = []
          kwargs1 = {}
          if args:
              for i in range(len(args)):
                  args1.append(args[i].upper())
              print(args1)
          if kwargs:
              for i in kwargs:
                  kwargs1[i] = kwargs[i].upper()
              print(kwargs1)
          return super().__call__(*args1, **kwargs1)

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

  my = MyClass('aaa')
  print(my.name)
 

面向物件的雙下方法

1.__ str__, __ repr__

  __str__(***) 裡邊必須有return "字串"型別  (優先順序高於__repr__)
    1.列印物件的時候,會觸發__str__方法
    2.直接str轉化也可以觸發
  class A:
      def __init__(self,name,age):
          self.name = name
          self.age =age

      def __str__(self):
          print(666)
          return f'姓名: {self.name} 年齡: {self.age}'

  a = A('二狗',35) 
  b = A('大狗',56)
  c = A('老狗',18)
  列印物件觸發__str__方法
  print(f'{a.name}  {a.age}') # 二狗  35
  print(f'{b.name}  {b.age}')
  print(f'{c.name}  {c.age}')
  print(a) # 666
             姓名: 二狗 年齡: 35
  print(b)
  print(c)
  直接str轉化也可以觸發.
  print(str(a))  # 666
                   姓名: 二狗 年齡: 35

  __repr__  裡邊必須有return "字串"型別
    列印物件的時候,會觸發__repr__方法
  class A:
      def __init__(self,name,age):
          self.name = name
          self.age =age

      def __repr__(self):
          print(666)
          return f'姓名: {self.name} 年齡: {self.age}'

  a = A('二狗',35)
  b = A('大狗',56)
  c = A('老狗',18)
  print(a)
  print(repr(a))


  __str__和__repr__ 一起使用時，只執行__str__的內容
  class A:

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

      def __str__(self):
          return '777'


      def __repr__(self):
          return '666'

  a = A('二狗',35)
  b = A('大狗',56)
  c = A('老狗',18)
  # print(a)
  print(a) # 777
  print(b) # 777
'''
   str()方法定義當被print()方法或者str()方法呼叫時的行為，repr()方法定義當被print()方法或者
repr()方法呼叫時的行為，一般來說，它們的功能都是實現類到字串的轉化，實現方式上也沒有特別的差
異。 但實際上，str()方法的返回結果可讀性應該要更強一些，repr()方法的返回結果要更加準確，也就是
說，str()方法的意義是得到便於人們閱讀的資訊，而__repr__()方法的目的在於開發者便於除錯。
   注意：當進行print()的時候，首先被執行的是__str__()方法，如果沒定義__str__()方法，repr()
方法才會被執行。
'''
 

2.__call__

  __call__(***)  物件()觸發物件從屬類(父類)的__call__方法
  class Foo:

      def __init__(self):
          pass

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

  obj = Foo()
  obj()
  當呼叫obj()時，call()方法會被呼叫，call()方法也可以接受引數
'''
  call()方法可以讓類的例項像函式一樣被呼叫
'''

3. __del__

  __del__當一個物件的生命週期結束被徹底銷燬的時候被調，__del__方法會被呼叫，不常用，一般不需要
進行重寫。
  class A:
      def __del__(self):
          print(666)

  obj = A()
  del obj
 

4.__getattr__,__getattribute__,__setattr__

  __getattr__表示的是當一個物件訪問一個屬性時，沒有從它定義的屬性當中查詢到就會呼叫這個方法。
  class A(object):
      def __init__(self, value):
          self.value = value

      def __getattr__(self, item):
          print("into __getattr__")       
          return "can not find"
  a = A(10)
  print(a.value)
  # 10
  print(a.name)
  # into __getattr__
  # can not find

  __getattribute__只要物件查詢名字無論名字是否存在都會執行該方法,如果類中有__getattribute__方
法 那麼就不會去執行__getattr__方法
  class A(object):
      def __init__(self, value):
          self.value = value

      def __getattribute__(self, item):
          print("into __getattribute__")
          return "__getattribute__"
  a = A(10)
  print(a.value)
  into __getattribute__
  __getattribute__
  print(a.name)
  into __getattribute__
  __getattribute__


  class A(object):
      def __init__(self, value):
          self.value = value

      def __getattribute__(self, item):
          print("into __getattribute__")
          return "__getattribute__"

      def __getattr__(self, item):
          print('into __getattr__')
          return '__getattr__'


  a = A(10)
  print(a.value)
  # into __getattribute__
  # __getattribute__
  print(a.name)
  # into __getattribute__
  # __getattribute__
'''
  使用歸納：

  1.__getattribute__方法優先順序比__getattr__高

  2.當同時定義__getattribute__和__getattr__時，__getattr__方法不會再被呼叫，除非顯示呼叫
__getattr__方法或引發AttributeError異常。

  3.如果是對不存在的屬性做處理，儘量把邏輯寫在__getattr__方法中

  4.如果非得重寫__getattribute__方法，需要注意兩點：第一是避免.操作帶來的死迴圈；第二是不要遺
忘父類的__getattribute__方法在子類中起的作用
'''

 __setattr__物件在執行新增屬性操作的時候自動觸發	>>>	obj.變數名=變數值
  class A(object):
      def __init__(self, value):
          print("into __init__")
          self.value = value

      def __setattr__(self, name, value):
          print("into __setattr__")
          if value == 10:
              print("from __init__")
          object.__setattr__(self, name, value)


  a = A(10)
  # into __init__
  # into __setattr__
  # from __init__
  print(a.value)
  # 10
  a.value = 100
  # into __setattr__
  print(a.value)
  # 100

5.__enter__，__exit__

  我們知道在操作檔案物件的時候可以這麼寫
  with open('a.txt') as f:
      　'程式碼塊'
  上述叫做上下文管理協議，即with語句，為了讓一個物件相容with語句，必須在這個物件的類中宣告__enter__和__exit__方法

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

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

  # coding=utf-8
  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中程式碼塊執行完畢時執行我啊')
          print(exc_type)
          print(exc_val)
          print(exc_tb)
          return True


  with Open('aa.txt') as f:
      print(f)
      print(f.name)
      print(sdsd)  # 觸發 __exit__ ,之後的程式碼就不會執行
      print('-------')

  print('End....')

  '''
  執行結果：
  出現with語句,物件的__enter__被觸發,有返回值則賦值給as宣告的變數
  <__main__.Open object at 0x0000016D7FA95BE0>
  aa.txt
  with中程式碼塊執行完畢時執行我啊
  <class 'NameError'>
  name 'sdsd' is not defined
  <traceback object at 0x0000016D7FA925C8>
  End....
  '''

  '''
  總結：
  __enter__在with語句後自動呼叫，可以給as後的變數賦值
  __exit__用於捕獲異常，返回boolean物件，如果為True異常被忽略，如果為False異常被丟擲
  三個引數分別是：
  1.exc_type 異常型別
  2.exc_value異常值
  3.traceback
  with obj as f:
      程式碼塊
  1. with obj ----> 觸發obj.__enter__(),拿到返回值
  2. as f --> f = 返回值
  3. with obj as f 等同於  f = obj.__enter__()
  4. 執行程式碼塊
   1> 沒有異常，整個程式碼塊執行完畢後去觸發__exit__(),它的三個引數都返回None
   2> 有異常的情況下，從異常出現的位置直接觸發__exit））
      a:如果__exit__返回值為True,代表吞掉了異常(不報異常)
      b:如果__exit__返回值不為True,代表吐出了異常(異常報錯)
      c:__exit__執行完畢，就代表整個with語句執行完畢
  '''

針對雙下方法的筆試題

  1.讓字典具備句點符查詢值的功能
  	# 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)

  2.補全下列程式碼 使其執行不報錯
  	"""
  	class Context:
  			pass
  	with Context() as ctx:
  			ctx.do_something()
  	"""
    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:
      ctx.do_something()